@toolkit-cli/toolkode 1.3.8 → 1.3.9

package/src/team/index.ts

@@ -1,428 +0,0 @@
-/**
- * tk_ toolkode — Agent Teams
- *
- * Multi-session coordination. One lead, N teammates.
- * Each teammate is a separate toolkode process with its own context.
- * Shared task list + mailbox for coordination.
- *
- * NOT experimental. Production feature.
- */
-import { Log } from "../util/log"
-import { Global } from "../global"
-import path from "path"
-import fs from "fs/promises"
-import { Filesystem } from "../util/filesystem"
-import { execSync, spawn, type ChildProcess } from "child_process"
-
-const log = Log.create({ service: "team" })
-
-export namespace Team {
-  /* ── Types ──────────────────────────────────────────────────── */
-
-  export interface Member {
-    name: string
-    agentId: string
-    agentType: string
-    pid?: number
-    status: "active" | "idle" | "stopped"
-    model?: string
-    spawnPrompt?: string
-  }
-
-  export interface Config {
-    name: string
-    leadSessionId: string
-    members: Member[]
-    createdAt: number
-    directory: string
-  }
-
-  export interface Task {
-    id: string
-    title: string
-    description: string
-    status: "pending" | "in_progress" | "completed"
-    assignee?: string
-    dependsOn?: string[]
-    createdAt: number
-    completedAt?: number
-    claimedBy?: string
-  }
-
-  export interface Message {
-    id: string
-    from: string
-    to: string | "all" // "all" = broadcast
-    content: string
-    timestamp: number
-  }
-
-  /* ── Paths ──────────────────────────────────────────────────── */
-
-  function teamDir(teamName: string) {
-    return path.join(Global.Path.data, "teams", teamName)
-  }
-
-  function configPath(teamName: string) {
-    return path.join(teamDir(teamName), "config.json")
-  }
-
-  function tasksDir(teamName: string) {
-    return path.join(Global.Path.data, "tasks", teamName)
-  }
-
-  function tasksPath(teamName: string) {
-    return path.join(tasksDir(teamName), "tasks.json")
-  }
-
-  function mailboxPath(teamName: string) {
-    return path.join(teamDir(teamName), "mailbox.json")
-  }
-
-  /* ── Team Lifecycle ─────────────────────────────────────────── */
-
-  const activeTeams = new Map<string, Config>()
-  const processes = new Map<string, ChildProcess>()
-
-  /** Create a new team */
-  export async function create(input: {
-    name: string
-    leadSessionId: string
-    directory: string
-  }): Promise<Config> {
-    const dir = teamDir(input.name)
-    await fs.mkdir(dir, { recursive: true })
-    await fs.mkdir(tasksDir(input.name), { recursive: true })
-
-    const config: Config = {
-      name: input.name,
-      leadSessionId: input.leadSessionId,
-      members: [],
-      createdAt: Date.now(),
-      directory: input.directory,
-    }
-
-    await Filesystem.write(configPath(input.name), JSON.stringify(config, null, 2))
-    await Filesystem.write(tasksPath(input.name), JSON.stringify([], null, 2))
-    await Filesystem.write(mailboxPath(input.name), JSON.stringify([], null, 2))
-
-    activeTeams.set(input.name, config)
-    log.info("team created", { name: input.name })
-    return config
-  }
-
-  /** Get team config */
-  export async function get(teamName: string): Promise<Config | null> {
-    const cached = activeTeams.get(teamName)
-    if (cached) return cached
-
-    try {
-      const data = await Filesystem.readJson<Config>(configPath(teamName))
-      if (data) activeTeams.set(teamName, data)
-      return data ?? null
-    } catch {
-      return null
-    }
-  }
-
-  /** List all teams */
-  export async function list(): Promise<string[]> {
-    try {
-      const teamsRoot = path.join(Global.Path.data, "teams")
-      const entries = await fs.readdir(teamsRoot).catch(() => [])
-      return entries
-    } catch {
-      return []
-    }
-  }
-
-  /* ── Teammate Spawning ──────────────────────────────────────── */
-
-  /** Spawn a teammate as a separate toolkode process */
-  export async function spawnTeammate(input: {
-    teamName: string
-    name: string
-    agentType: string
-    prompt: string
-    model?: string
-    planApproval?: boolean
-  }): Promise<Member> {
-    const config = await get(input.teamName)
-    if (!config) throw new Error(`Team "${input.teamName}" not found`)
-
-    const agentId = crypto.randomUUID().slice(0, 8)
-
-    const member: Member = {
-      name: input.name,
-      agentId,
-      agentType: input.agentType,
-      status: "active",
-      model: input.model,
-      spawnPrompt: input.prompt,
-    }
-
-    // Spawn toolkode process for this teammate
-    // The teammate runs as a headless session with the spawn prompt
-    const args = [
-      "run",
-      "--print",
-      "--no-input",
-    ]
-
-    if (input.model) args.push("--model", input.model)
-    if (input.planApproval) args.push("--permission-mode", "plan")
-
-    // Find the toolkode binary — process.argv[0] is the runtime (node/bun),
-    // process.argv[1] is the script. Prefer TOOLKODE_BIN_PATH env, then which, then argv[1].
-    const toolkodeBin = process.env.TOOLKODE_BIN_PATH
-      || (() => { try { return execSync("which toolkode", { encoding: "utf-8" }).trim() } catch { return undefined } })()
-      || process.argv[1]
-      || "toolkode"
-
-    try {
-      const child = spawn(toolkodeBin, [...args, "--", input.prompt], {
-        cwd: config.directory,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: {
-          ...process.env,
-          TOOLKODE_TEAM_NAME: input.teamName,
-          TOOLKODE_TEAMMATE_NAME: input.name,
-          TOOLKODE_TEAMMATE_ID: agentId,
-        },
-        detached: false,
-      })
-
-      member.pid = child.pid
-      processes.set(agentId, child)
-
-      child.on("exit", (code) => {
-        member.status = "stopped"
-        processes.delete(agentId)
-        log.info("teammate exited", { name: input.name, agentId, code })
-        // Auto-notify lead
-        sendMessage({
-          teamName: input.teamName,
-          from: input.name,
-          to: "lead",
-          content: `Teammate ${input.name} has finished (exit code: ${code})`,
-        }).catch(() => {})
-      })
-
-      // Capture output for logging
-      child.stdout?.on("data", (data: Buffer) => {
-        log.info(`[${input.name}] ${data.toString().trim()}`)
-      })
-      child.stderr?.on("data", (data: Buffer) => {
-        log.error(`[${input.name}] ${data.toString().trim()}`)
-      })
-    } catch (err) {
-      log.error("failed to spawn teammate", { name: input.name, error: err })
-      member.status = "stopped"
-    }
-
-    // Update team config
-    config.members.push(member)
-    await Filesystem.write(configPath(input.teamName), JSON.stringify(config, null, 2))
-    activeTeams.set(input.teamName, config)
-
-    log.info("teammate spawned", { name: input.name, agentId, pid: member.pid })
-    return member
-  }
-
-  /** Shutdown a specific teammate */
-  export async function shutdownTeammate(teamName: string, nameOrId: string): Promise<boolean> {
-    const config = await get(teamName)
-    if (!config) return false
-
-    const member = config.members.find((m) => m.name === nameOrId || m.agentId === nameOrId)
-    if (!member) return false
-
-    const proc = processes.get(member.agentId)
-    if (proc && !proc.killed) {
-      proc.kill("SIGTERM")
-      // Give it 5 seconds, then force
-      setTimeout(() => {
-        if (!proc.killed) proc.kill("SIGKILL")
-      }, 5000)
-    }
-
-    member.status = "stopped"
-    await Filesystem.write(configPath(teamName), JSON.stringify(config, null, 2))
-    return true
-  }
-
-  /* ── Shared Task List ───────────────────────────────────────── */
-
-  /** Get all tasks for a team */
-  export async function getTasks(teamName: string): Promise<Task[]> {
-    try {
-      return (await Filesystem.readJson<Task[]>(tasksPath(teamName))) ?? []
-    } catch {
-      return []
-    }
-  }
-
-  /** Create a task */
-  export async function createTask(teamName: string, input: {
-    title: string
-    description: string
-    assignee?: string
-    dependsOn?: string[]
-  }): Promise<Task> {
-    const tasks = await getTasks(teamName)
-    const task: Task = {
-      id: crypto.randomUUID().slice(0, 8),
-      title: input.title,
-      description: input.description,
-      status: "pending",
-      assignee: input.assignee,
-      dependsOn: input.dependsOn,
-      createdAt: Date.now(),
-    }
-
-    tasks.push(task)
-    await Filesystem.write(tasksPath(teamName), JSON.stringify(tasks, null, 2))
-    log.info("task created", { teamName, taskId: task.id, title: task.title })
-    return task
-  }
-
-  /** Claim a task with file-based locking to prevent race conditions */
-  export async function claimTask(teamName: string, taskId: string, claimant: string): Promise<Task | null> {
-    // Atomic lock: create a lockfile — if it already exists, another teammate is claiming
-    const lockPath = path.join(tasksDir(teamName), `${taskId}.lock`)
-    try {
-      await fs.writeFile(lockPath, claimant, { flag: "wx" }) // wx = exclusive create, fails if exists
-    } catch {
-      return null // Another teammate is claiming this task
-    }
-
-    try {
-      const tasks = await getTasks(teamName)
-      const task = tasks.find((t) => t.id === taskId)
-      if (!task || task.status !== "pending") {
-        await fs.rm(lockPath, { force: true })
-        return null
-      }
-
-      // Check dependencies
-      if (task.dependsOn?.length) {
-        const unresolved = task.dependsOn.filter((depId) => {
-          const dep = tasks.find((t) => t.id === depId)
-          return !dep || dep.status !== "completed"
-        })
-        if (unresolved.length > 0) {
-          await fs.rm(lockPath, { force: true })
-          return null // blocked
-        }
-      }
-
-      // Claim it
-      task.status = "in_progress"
-      task.claimedBy = claimant
-      await Filesystem.write(tasksPath(teamName), JSON.stringify(tasks, null, 2))
-      log.info("task claimed", { teamName, taskId, claimant })
-      return task
-    } finally {
-      await fs.rm(lockPath, { force: true })
-    }
-  }
-
-  /** Complete a task */
-  export async function completeTask(teamName: string, taskId: string): Promise<Task | null> {
-    const tasks = await getTasks(teamName)
-    const task = tasks.find((t) => t.id === taskId)
-    if (!task) return null
-
-    task.status = "completed"
-    task.completedAt = Date.now()
-    await Filesystem.write(tasksPath(teamName), JSON.stringify(tasks, null, 2))
-    log.info("task completed", { teamName, taskId })
-    return task
-  }
-
-  /** Get next available (unblocked, unclaimed) task */
-  export async function getNextTask(teamName: string): Promise<Task | null> {
-    const tasks = await getTasks(teamName)
-    for (const task of tasks) {
-      if (task.status !== "pending") continue
-      if (task.dependsOn?.length) {
-        const allDone = task.dependsOn.every((depId) => {
-          const dep = tasks.find((t) => t.id === depId)
-          return dep?.status === "completed"
-        })
-        if (!allDone) continue
-      }
-      return task
-    }
-    return null
-  }
-
-  /* ── Mailbox ────────────────────────────────────────────────── */
-
-  /** Send a message to a teammate or broadcast */
-  export async function sendMessage(input: {
-    teamName: string
-    from: string
-    to: string // teammate name or "all" for broadcast
-    content: string
-  }): Promise<Message> {
-    const messages = await getMessages(input.teamName)
-    const msg: Message = {
-      id: crypto.randomUUID().slice(0, 8),
-      from: input.from,
-      to: input.to,
-      content: input.content,
-      timestamp: Date.now(),
-    }
-
-    messages.push(msg)
-    await Filesystem.write(mailboxPath(input.teamName), JSON.stringify(messages, null, 2))
-    return msg
-  }
-
-  /** Get all messages for a team */
-  export async function getMessages(teamName: string): Promise<Message[]> {
-    try {
-      return (await Filesystem.readJson<Message[]>(mailboxPath(teamName))) ?? []
-    } catch {
-      return []
-    }
-  }
-
-  /** Get messages for a specific recipient */
-  export async function getMessagesFor(teamName: string, recipient: string): Promise<Message[]> {
-    const all = await getMessages(teamName)
-    return all.filter((m) => m.to === recipient || m.to === "all")
-  }
-
-  /* ── Cleanup ────────────────────────────────────────────────── */
-
-  /** Clean up team resources */
-  export async function cleanup(teamName: string): Promise<{ error?: string }> {
-    const config = await get(teamName)
-    if (!config) return { error: `Team "${teamName}" not found` }
-
-    // Check for active teammates
-    const active = config.members.filter((m) => m.status === "active")
-    if (active.length > 0) {
-      return {
-        error: `Cannot clean up: ${active.length} teammates still active (${active.map((m) => m.name).join(", ")}). Shut them down first.`,
-      }
-    }
-
-    // Kill any remaining processes
-    for (const member of config.members) {
-      const proc = processes.get(member.agentId)
-      if (proc && !proc.killed) proc.kill("SIGKILL")
-      processes.delete(member.agentId)
-    }
-
-    // Remove files
-    await fs.rm(teamDir(teamName), { recursive: true, force: true })
-    await fs.rm(tasksDir(teamName), { recursive: true, force: true })
-    activeTeams.delete(teamName)
-
-    log.info("team cleaned up", { name: teamName })
-    return {}
-  }
-}

package/src/tool/apply_patch.ts

@@ -1,281 +0,0 @@
-import z from "zod"
-import * as path from "path"
-import * as fs from "fs/promises"
-import { Tool } from "./tool"
-import { Bus } from "../bus"
-import { FileWatcher } from "../file/watcher"
-import { Instance } from "../project/instance"
-import { Patch } from "../patch"
-import { createTwoFilesPatch, diffLines } from "diff"
-import { assertExternalDirectory } from "./external-directory"
-import { trimDiff } from "./edit"
-import { LSP } from "../lsp"
-import { Filesystem } from "../util/filesystem"
-import DESCRIPTION from "./apply_patch.txt"
-import { File } from "../file"
-import { Format } from "../format"
-
-const PatchParams = z.object({
-  patchText: z.string().describe("The full patch text that describes all changes to be made"),
-})
-
-export const ApplyPatchTool = Tool.define("apply_patch", {
-  description: DESCRIPTION,
-  parameters: PatchParams,
-  async execute(params, ctx) {
-    if (!params.patchText) {
-      throw new Error("patchText is required")
-    }
-
-    // Parse the patch to get hunks
-    let hunks: Patch.Hunk[]
-    try {
-      const parseResult = Patch.parsePatch(params.patchText)
-      hunks = parseResult.hunks
-    } catch (error) {
-      throw new Error(`apply_patch verification failed: ${error}`)
-    }
-
-    if (hunks.length === 0) {
-      const normalized = params.patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim()
-      if (normalized === "*** Begin Patch\n*** End Patch") {
-        throw new Error("patch rejected: empty patch")
-      }
-      throw new Error("apply_patch verification failed: no hunks found")
-    }
-
-    // Validate file paths and check permissions
-    const fileChanges: Array<{
-      filePath: string
-      oldContent: string
-      newContent: string
-      type: "add" | "update" | "delete" | "move"
-      movePath?: string
-      diff: string
-      additions: number
-      deletions: number
-    }> = []
-
-    let totalDiff = ""
-
-    for (const hunk of hunks) {
-      const filePath = path.resolve(Instance.directory, hunk.path)
-      await assertExternalDirectory(ctx, filePath)
-
-      switch (hunk.type) {
-        case "add": {
-          const oldContent = ""
-          const newContent =
-            hunk.contents.length === 0 || hunk.contents.endsWith("\n") ? hunk.contents : `${hunk.contents}\n`
-          const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, newContent))
-
-          let additions = 0
-          let deletions = 0
-          for (const change of diffLines(oldContent, newContent)) {
-            if (change.added) additions += change.count || 0
-            if (change.removed) deletions += change.count || 0
-          }
-
-          fileChanges.push({
-            filePath,
-            oldContent,
-            newContent,
-            type: "add",
-            diff,
-            additions,
-            deletions,
-          })
-
-          totalDiff += diff + "\n"
-          break
-        }
-
-        case "update": {
-          // Check if file exists for update
-          const stats = await fs.stat(filePath).catch(() => null)
-          if (!stats || stats.isDirectory()) {
-            throw new Error(`apply_patch verification failed: Failed to read file to update: ${filePath}`)
-          }
-
-          const oldContent = await fs.readFile(filePath, "utf-8")
-          let newContent = oldContent
-
-          // Apply the update chunks to get new content
-          try {
-            const fileUpdate = Patch.deriveNewContentsFromChunks(filePath, hunk.chunks)
-            newContent = fileUpdate.content
-          } catch (error) {
-            throw new Error(`apply_patch verification failed: ${error}`)
-          }
-
-          const diff = trimDiff(createTwoFilesPatch(filePath, filePath, oldContent, newContent))
-
-          let additions = 0
-          let deletions = 0
-          for (const change of diffLines(oldContent, newContent)) {
-            if (change.added) additions += change.count || 0
-            if (change.removed) deletions += change.count || 0
-          }
-
-          const movePath = hunk.move_path ? path.resolve(Instance.directory, hunk.move_path) : undefined
-          await assertExternalDirectory(ctx, movePath)
-
-          fileChanges.push({
-            filePath,
-            oldContent,
-            newContent,
-            type: hunk.move_path ? "move" : "update",
-            movePath,
-            diff,
-            additions,
-            deletions,
-          })
-
-          totalDiff += diff + "\n"
-          break
-        }
-
-        case "delete": {
-          const contentToDelete = await fs.readFile(filePath, "utf-8").catch((error) => {
-            throw new Error(`apply_patch verification failed: ${error}`)
-          })
-          const deleteDiff = trimDiff(createTwoFilesPatch(filePath, filePath, contentToDelete, ""))
-
-          const deletions = contentToDelete.split("\n").length
-
-          fileChanges.push({
-            filePath,
-            oldContent: contentToDelete,
-            newContent: "",
-            type: "delete",
-            diff: deleteDiff,
-            additions: 0,
-            deletions,
-          })
-
-          totalDiff += deleteDiff + "\n"
-          break
-        }
-      }
-    }
-
-    // Build per-file metadata for UI rendering (used for both permission and result)
-    const files = fileChanges.map((change) => ({
-      filePath: change.filePath,
-      relativePath: path.relative(Instance.worktree, change.movePath ?? change.filePath).replaceAll("\\", "/"),
-      type: change.type,
-      diff: change.diff,
-      before: change.oldContent,
-      after: change.newContent,
-      additions: change.additions,
-      deletions: change.deletions,
-      movePath: change.movePath,
-    }))
-
-    // Check permissions if needed
-    const relativePaths = fileChanges.map((c) => path.relative(Instance.worktree, c.filePath).replaceAll("\\", "/"))
-    await ctx.ask({
-      permission: "edit",
-      patterns: relativePaths,
-      always: ["*"],
-      metadata: {
-        filepath: relativePaths.join(", "),
-        diff: totalDiff,
-        files,
-      },
-    })
-
-    // Apply the changes
-    const updates: Array<{ file: string; event: "add" | "change" | "unlink" }> = []
-
-    for (const change of fileChanges) {
-      const edited = change.type === "delete" ? undefined : (change.movePath ?? change.filePath)
-      switch (change.type) {
-        case "add":
-          // Create parent directories (recursive: true is safe on existing/root dirs)
-          await fs.mkdir(path.dirname(change.filePath), { recursive: true })
-          await fs.writeFile(change.filePath, change.newContent, "utf-8")
-          updates.push({ file: change.filePath, event: "add" })
-          break
-
-        case "update":
-          await fs.writeFile(change.filePath, change.newContent, "utf-8")
-          updates.push({ file: change.filePath, event: "change" })
-          break
-
-        case "move":
-          if (change.movePath) {
-            // Create parent directories (recursive: true is safe on existing/root dirs)
-            await fs.mkdir(path.dirname(change.movePath), { recursive: true })
-            await fs.writeFile(change.movePath, change.newContent, "utf-8")
-            await fs.unlink(change.filePath)
-            updates.push({ file: change.filePath, event: "unlink" })
-            updates.push({ file: change.movePath, event: "add" })
-          }
-          break
-
-        case "delete":
-          await fs.unlink(change.filePath)
-          updates.push({ file: change.filePath, event: "unlink" })
-          break
-      }
-
-      if (edited) {
-        await Format.file(edited)
-        Bus.publish(File.Event.Edited, { file: edited })
-      }
-    }
-
-    // Publish file change events
-    for (const update of updates) {
-      await Bus.publish(FileWatcher.Event.Updated, update)
-    }
-
-    // Notify LSP of file changes and collect diagnostics
-    for (const change of fileChanges) {
-      if (change.type === "delete") continue
-      const target = change.movePath ?? change.filePath
-      await LSP.touchFile(target, true)
-    }
-    const diagnostics = await LSP.diagnostics()
-
-    // Generate output summary
-    const summaryLines = fileChanges.map((change) => {
-      if (change.type === "add") {
-        return `A ${path.relative(Instance.worktree, change.filePath).replaceAll("\\", "/")}`
-      }
-      if (change.type === "delete") {
-        return `D ${path.relative(Instance.worktree, change.filePath).replaceAll("\\", "/")}`
-      }
-      const target = change.movePath ?? change.filePath
-      return `M ${path.relative(Instance.worktree, target).replaceAll("\\", "/")}`
-    })
-    let output = `Success. Updated the following files:\n${summaryLines.join("\n")}`
-
-    // Report LSP errors for changed files
-    const MAX_DIAGNOSTICS_PER_FILE = 20
-    for (const change of fileChanges) {
-      if (change.type === "delete") continue
-      const target = change.movePath ?? change.filePath
-      const normalized = Filesystem.normalizePath(target)
-      const issues = diagnostics[normalized] ?? []
-      const errors = issues.filter((item) => item.severity === 1)
-      if (errors.length > 0) {
-        const limited = errors.slice(0, MAX_DIAGNOSTICS_PER_FILE)
-        const suffix =
-          errors.length > MAX_DIAGNOSTICS_PER_FILE ? `\n... and ${errors.length - MAX_DIAGNOSTICS_PER_FILE} more` : ""
-        output += `\n\nLSP errors detected in ${path.relative(Instance.worktree, target).replaceAll("\\", "/")}, please fix:\n<diagnostics file="${target}">\n${limited.map(LSP.Diagnostic.pretty).join("\n")}${suffix}\n</diagnostics>`
-      }
-    }
-
-    return {
-      title: output,
-      metadata: {
-        diff: totalDiff,
-        files,
-        diagnostics,
-      },
-      output,
-    }
-  },
-})