@toolkit-cli/toolkode 1.3.7

package/src/team/index.ts

@@ -0,0 +1,428 @@
+/**
+ * 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

@@ -0,0 +1,281 @@
+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,
+    }
+  },
+})