Session

export type Session = {
  id: string
  slug: string
  projectID: string
  directory: string
  parentID?: string
  summary?: {
    additions: number
    deletions: number
    files: number
    diffs?: Array<FileDiff>
  }
  share?: {
    url: string
  }
  title: string
  version: string
  time: {
    created: number
    updated: number
    compacting?: number
    archived?: number
  }
  permission?: PermissionRuleset
  revert?: {
    messageID: string
    partID?: string
    snapshot?: string
    diff?: string
  }
}

;["session", projectID, sessionID]

const session = await Session.create({
  title: "Fix bug in login",
  permission: permissionRuleset,
})

console.log(session.id) // sess_abc123

const childSession = await Session.create({
  parentID: parentSession.id,
  title: "Alternative approach",
})

console.log(childSession.parentID) // sess_parent123

await Session.update(session.id, (draft) => {
  draft.title = "Updated title: Fix bug in login"
})

const children = await Session.children(session.id)
console.log(`Found ${children.length} child sessions`)

await Session.remove(session.id)
// 这将删除会话及其所有消息、parts 和子会话

parentID?: string  // 父会话 ID，根会话为空

export const children = fn(Identifier.schema("session"), async (parentID) => {
  const project = Instance.project
  const result = [] as Session.Info[]
  for (const item of await Storage.list(["session", project.id])) {
    const session = await Storage.read<Info>(item)
    if (session.parentID !== parentID) continue
    result.push(session)
  }
  return result
})

// 获取根会话的所有子会
const rootSession = await Session.get("sess_root123")
const children = await Session.children(rootSession.id)

console.log(`Found ${children.length} child sessions`)
for (const child of children) {
  console.log(`- ${child.title} (ID: ${child.id})`)
}

export const remove = fn(Identifier.schema("session"), async (sessionID) => {
  const project = Instance.project
  const session = await get(sessionID)

  // 递归删除所有子会话
  for (const child of await children(sessionID)) {
    await remove(child.id)
  }

  // 删除会话的消息和 parts
  for (const msg of await Storage.list(["message", sessionID])) {
    for (const part of await Storage.list(["part", msg.at(-1)!])) {
      await Storage.remove(part)
    }
    await Storage.remove(msg)
  }

  // 删除会话本身
  await Storage.remove(["session", project.id, sessionID])
})

// 删除根会话，会自动删除所有子会话
await Session.remove(rootSession.id)
// 无需手动删除每个子会话

function createDefaultTitle(isChild = false) {
  return (isChild ? "Child session - " : "New session - ") + new Date().toISOString()
}

title: input.title ?? createDefaultTitle(!!input.parentID)

export const Instance = {
  get directory() {
    return context.use().directory // 当前工作目录
  },
  get worktree() {
    return context.use().worktree // 项目根目录
  },
  get project() {
    return context.use().project // 项目信息
  },
}

const result: Info = {
  id: Identifier.descending("session", input.id),
  slug: Slug.create(),
  version: Installation.VERSION,
  projectID: Instance.project.id, // 👈 继承项目 ID
  directory: input.directory ?? Instance.directory, // 👈 继承工作目录
  parentID: input.parentID, // 👈 父会话 ID
  title: input.title ?? createDefaultTitle(!!input.parentID),
  permission: input.permission,
  time: {
    created: Date.now(),
    updated: Date.now(),
  },
}

// 父会话
const parentSession = await Session.create({
  title: "Main task",
})
// 父会话有 10 条消息

// 创建子会话
const childSession = await Session.create({
  parentID: parentSession.id,
  title: "Subtask",
})

// 子会话的消息历史为空（0 条消息）
// 子会话不会自动复制父会话的消息

permission: [
  {
    permission: "todowrite",
    pattern: "*",
    action: "deny", // 👈 防止子 Agent 管理父 Agent 的 todo
  },
  {
    permission: "todoread",
    pattern: "*",
    action: "deny", // 👈 防止子 Agent 读取父 Agent 的 todo
  },
  ...(hasTaskPermission
    ? []
    : [
        {
          permission: "task",
          pattern: "*",
          action: "deny", // 👈 防止无限递归调用
        },
      ]),
]

const parentSession = await Session.get("sess_parent123")

const childSession = await Session.create({
  parentID: parentSession.id,
  title: "Alternative implementation approach",
  permission: [
    {
      permission: "edit",
      pattern: "*",
      action: "deny", //只读权限
    },
  ],
})

console.log(childSession.parentID) // "sess_parent123"

async function printSessionTree(sessionID: string, depth: number = 0) {
  const session = await Session.get(sessionID)
  const indent = "  ".repeat(depth)
  console.log(`${indent}- ${session.title}`)

  const children = await Session.children(sessionID)
  for (const child of children) {
    await printSessionTree(child.id, depth + 1)
  }
}

// 从根会话开始打印
const rootSessions = await Storage.list(["session", Instance.project.id])
for (const item of rootSessions) {
  const session = await Storage.read<Session.Info>(item)
  if (!session.parentID) {
    // 只处理根会话
    await printSessionTree(session.id)
  }
}

async function hasChildren(sessionID: string): Promise<boolean> {
  const children = await Session.children(sessionID)
  return children.length > 0
}

const session = await Session.get("sess_abc123")
if (await hasChildren(session.id)) {
  console.log("This session has child sessions")
  console.log("Deleting it will also delete all children")
}