@teammates/cli 0.1.0 → 0.2.0

package/dist/adapters/cli-proxy.js

@@ -15,44 +15,66 @@
  *   4. Captures output for result parsing (changed files, handoff envelopes)
  */
 import { spawn } from "node:child_process";
-import { writeFile, unlink, mkdir } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { randomUUID } from "node:crypto";
 import { buildTeammatePrompt } from "../adapter.js";
 export const PRESETS = {
     claude: {
         name: "claude",
         command: "claude",
-        buildArgs({ prompt }, teammate, options) {
+        buildArgs(_ctx, _teammate, options) {
             const args = ["-p", "--verbose", "--dangerously-skip-permissions"];
             if (options.model)
                 args.push("--model", options.model);
-            args.push("--", prompt);
             return args;
         },
         env: { FORCE_COLOR: "1", CLAUDECODE: "" },
+        stdinPrompt: true,
     },
     codex: {
         name: "codex",
         command: "codex",
-        buildArgs({ prompt }, teammate, options) {
-            const args = ["exec", prompt];
+        buildArgs(_ctx, teammate, options) {
+            const args = ["exec", "-"];
             if (teammate.cwd)
                 args.push("-C", teammate.cwd);
             const sandbox = teammate.sandbox ?? options.defaultSandbox ?? "workspace-write";
             args.push("-s", sandbox);
             args.push("--full-auto");
+            args.push("--ephemeral");
+            args.push("--json");
             if (options.model)
                 args.push("-m", options.model);
             return args;
         },
-        env: { FORCE_COLOR: "1" },
+        env: { NO_COLOR: "1" },
+        stdinPrompt: true,
+        /** Parse JSONL output from codex exec --json, returning only the last agent message */
+        parseOutput(raw) {
+            let lastMessage = "";
+            for (const line of raw.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === "item.completed" &&
+                        event.item?.type === "agent_message") {
+                        lastMessage = event.item.text;
+                    }
+                }
+                catch {
+                    /* skip non-JSON lines */
+                }
+            }
+            return lastMessage || raw;
+        },
     },
     aider: {
         name: "aider",
         command: "aider",
-        buildArgs({ promptFile }, teammate, options) {
+        buildArgs({ promptFile }, _teammate, options) {
             const args = ["--message-file", promptFile, "--yes", "--no-git"];
             if (options.model)
                 args.push("--model", options.model);
@@ -89,17 +111,26 @@ export class CliProxyAdapter {
     }
     async startSession(teammate) {
         const id = `${this.name}-${teammate.name}-${nextId++}`;
-        // Create session file for this teammate
+        // Create session file inside .teammates/.tmp so sandboxed agents can access it
         if (!this.sessionsDir) {
-            this.sessionsDir = join(tmpdir(), `teammates-sessions-${randomUUID()}`);
+            const tmpBase = join(teammate.cwd ?? process.cwd(), ".teammates", ".tmp");
+            this.sessionsDir = join(tmpBase, "sessions");
             await mkdir(this.sessionsDir, { recursive: true });
+            // Ensure .tmp is gitignored
+            const gitignorePath = join(tmpBase, "..", ".gitignore");
+            const existing = await readFile(gitignorePath, "utf-8").catch(() => "");
+            if (!existing.includes(".tmp/")) {
+                await writeFile(gitignorePath, existing +
+                    (existing.endsWith("\n") || !existing ? "" : "\n") +
+                    ".tmp/\n").catch(() => { });
+            }
         }
         const sessionFile = join(this.sessionsDir, `${teammate.name}.md`);
         await writeFile(sessionFile, `# Session — ${teammate.name}\n\n`, "utf-8");
         this.sessionFiles.set(teammate.name, sessionFile);
         return id;
     }
-    async executeTask(sessionId, teammate, prompt) {
+    async executeTask(_sessionId, teammate, prompt) {
         // If the teammate has no soul (e.g. the raw agent), skip identity/memory
         // wrapping but include handoff instructions so it can delegate to teammates
         const sessionFile = this.sessionFiles.get(teammate.name);
@@ -124,10 +155,8 @@ export class CliProxyAdapter {
                         : "";
                     parts.push(`- @${t.name}: ${t.role}${owns}`);
                 }
-                parts.push("\nTo hand off, end your response with:");
-                parts.push("```json");
-                parts.push('{ "handoff": { "to": "<teammate>", "task": "<what you need them to do>", "context": "<any context>" } }');
-                parts.push("```");
+                parts.push("\nTo hand off, include a fenced handoff block in your response:");
+                parts.push("```handoff\n@<teammate>\n<task details>\n```");
             }
             fullPrompt = parts.join("\n");
         }
@@ -136,7 +165,10 @@ export class CliProxyAdapter {
         await writeFile(promptFile, fullPrompt, "utf-8");
         this.pendingTempFiles.add(promptFile);
         try {
-            const output = await this.spawnAndProxy(teammate, promptFile, fullPrompt);
+            const rawOutput = await this.spawnAndProxy(teammate, promptFile, fullPrompt);
+            const output = this.preset.parseOutput
+                ? this.preset.parseOutput(rawOutput)
+                : rawOutput;
             const teammateNames = this.roster.map((r) => r.name);
             return parseResult(teammate.name, output, teammateNames, prompt);
         }
@@ -163,15 +195,39 @@ export class CliProxyAdapter {
         await writeFile(promptFile, prompt, "utf-8");
         try {
             const command = this.options.commandPath ?? this.preset.command;
-            const args = this.preset.buildArgs({ promptFile, prompt }, { name: "_router", role: "", soul: "", memories: "", dailyLogs: [], ownership: { primary: [], secondary: [] } }, { ...this.options, model: this.options.model ?? "haiku" });
+            const args = this.preset.buildArgs({ promptFile, prompt }, {
+                name: "_router",
+                role: "",
+                soul: "",
+                wisdom: "",
+                dailyLogs: [],
+                weeklyLogs: [],
+                ownership: { primary: [], secondary: [] },
+                routingKeywords: [],
+            }, { ...this.options, model: this.options.model ?? "haiku" });
             const env = { ...process.env, ...this.preset.env };
+            // Suppress Node.js ExperimentalWarning in routing subprocesses
+            const existingNodeOpts = env.NODE_OPTIONS ?? "";
+            if (!existingNodeOpts.includes("--disable-warning=ExperimentalWarning")) {
+                env.NODE_OPTIONS = existingNodeOpts
+                    ? `${existingNodeOpts} --disable-warning=ExperimentalWarning`
+                    : "--disable-warning=ExperimentalWarning";
+            }
             const output = await new Promise((resolve, reject) => {
-                const child = spawn(command, args, {
+                const routeStdin = this.preset.stdinPrompt ?? false;
+                const needsShell = this.preset.shell ?? process.platform === "win32";
+                const spawnCmd = needsShell ? [command, ...args].join(" ") : command;
+                const spawnArgs = needsShell ? [] : args;
+                const child = spawn(spawnCmd, spawnArgs, {
                     cwd: process.cwd(),
                     env,
-                    stdio: ["ignore", "pipe", "pipe"],
-                    shell: this.preset.shell ?? false,
+                    stdio: [routeStdin ? "pipe" : "ignore", "pipe", "pipe"],
+                    shell: needsShell,
                 });
+                if (routeStdin && child.stdin) {
+                    child.stdin.write(prompt);
+                    child.stdin.end();
+                }
                 const captured = [];
                 child.stdout?.on("data", (chunk) => captured.push(chunk));
                 child.stderr?.on("data", (chunk) => captured.push(chunk));
@@ -193,7 +249,8 @@ export class CliProxyAdapter {
             const trimmed = output.trim().toLowerCase();
             // Check each name — the agent should have returned just one
             for (const name of rosterNames) {
-                if (trimmed === name.toLowerCase() || trimmed.endsWith(name.toLowerCase())) {
+                if (trimmed === name.toLowerCase() ||
+                    trimmed.endsWith(name.toLowerCase())) {
                     return name;
                 }
             }
@@ -212,7 +269,7 @@ export class CliProxyAdapter {
             await unlink(promptFile).catch(() => { });
         }
     }
-    async destroySession(sessionId) {
+    async destroySession(_sessionId) {
         // Clean up any leaked temp prompt files
         for (const file of this.pendingTempFiles) {
             await unlink(file).catch(() => { });
@@ -237,12 +294,32 @@ export class CliProxyAdapter {
             const env = { ...process.env, ...this.preset.env };
             const timeout = this.options.timeout ?? 600_000;
             const interactive = this.preset.interactive ?? false;
-            const child = spawn(command, args, {
+            const useStdin = this.preset.stdinPrompt ?? false;
+            // Suppress Node.js ExperimentalWarning (e.g. SQLite) in agent
+            // subprocesses so it doesn't leak into the terminal UI.
+            const existingNodeOpts = env.NODE_OPTIONS ?? "";
+            if (!existingNodeOpts.includes("--disable-warning=ExperimentalWarning")) {
+                env.NODE_OPTIONS = existingNodeOpts
+                    ? `${existingNodeOpts} --disable-warning=ExperimentalWarning`
+                    : "--disable-warning=ExperimentalWarning";
+            }
+            // On Windows, npm-installed CLIs are .cmd wrappers that require shell.
+            // When using shell mode, pass command+args as a single string to avoid
+            // Node DEP0190 deprecation warning about unescaped args with shell: true.
+            const needsShell = this.preset.shell ?? process.platform === "win32";
+            const spawnCmd = needsShell ? [command, ...args].join(" ") : command;
+            const spawnArgs = needsShell ? [] : args;
+            const child = spawn(spawnCmd, spawnArgs, {
                 cwd: teammate.cwd ?? process.cwd(),
                 env,
-                stdio: [interactive ? "pipe" : "ignore", "pipe", "pipe"],
-                shell: this.preset.shell ?? false,
+                stdio: [interactive || useStdin ? "pipe" : "ignore", "pipe", "pipe"],
+                shell: needsShell,
             });
+            // Pipe prompt via stdin if the preset requires it
+            if (useStdin && child.stdin) {
+                child.stdin.write(fullPrompt);
+                child.stdin.end();
+            }
             // ── Timeout with SIGTERM → SIGKILL escalation ──────────────
             let killed = false;
             let killTimer = null;
@@ -260,7 +337,7 @@ export class CliProxyAdapter {
             }, timeout);
             // Connect user's stdin → child only if agent may ask questions
             let onUserInput = null;
-            if (interactive && child.stdin) {
+            if (interactive && !useStdin && child.stdin) {
                 onUserInput = (chunk) => {
                     child.stdin?.write(chunk);
                 };
@@ -285,11 +362,11 @@ export class CliProxyAdapter {
                     process.stdin.removeListener("data", onUserInput);
                 }
             };
-            child.on("close", (code) => {
+            child.on("close", (_code) => {
                 cleanup();
                 const output = Buffer.concat(captured).toString("utf-8");
                 if (killed) {
-                    resolve(output + `\n\n[TIMEOUT] Agent process killed after ${timeout}ms`);
+                    resolve(`${output}\n\n[TIMEOUT] Agent process killed after ${timeout}ms`);
                 }
                 else {
                     resolve(output);
@@ -303,66 +380,90 @@ export class CliProxyAdapter {
     }
 }
 // ─── Output parsing (shared across all agents) ─────────────────────
-function parseResult(teammateName, output, teammateNames = [], originalTask) {
-    // Try to parse the structured JSON block the agent was asked to produce
-    const structured = parseStructuredOutput(output);
-    if (structured) {
-        return { ...structured, teammate: teammateName, rawOutput: output };
-    }
-    // Fallback: scrape what we can from freeform output
+export function parseResult(teammateName, output, teammateNames = [], _originalTask) {
+    // Parse the TO: / # Subject protocol
+    const parsed = parseMessageProtocol(output, teammateName, teammateNames);
+    if (parsed)
+        return parsed;
+    // Fallback: no structured output detected
     return {
         teammate: teammateName,
         success: true,
-        summary: extractSummary(output),
+        summary: "",
         changedFiles: parseChangedFiles(output),
-        handoff: parseHandoffEnvelope(output) ?? parseHandoffFromMention(teammateName, output, teammateNames, originalTask) ?? undefined,
+        handoffs: [],
         rawOutput: output,
     };
 }
 /**
- * Parse the structured JSON block from the output protocol.
- * Looks for either { "result": ... } or { "handoff": ... }.
+ * Parse the message protocol from agent output.
+ *
+ * Detects two things:
+ *   1. ```handoff blocks — fenced code blocks with language "handoff"
+ *      containing @<teammate> on the first line and the task body below.
+ *   2. TO: / # Subject headers for message framing.
+ *
+ * The ```handoff block is the primary handoff signal and works reliably
+ * regardless of where it appears in the output.
  */
-function parseStructuredOutput(output) {
-    const jsonBlocks = [...output.matchAll(/```json\s*\n([\s\S]*?)```/g)];
-    // Take the last JSON block — that's the protocol output
-    for (let i = jsonBlocks.length - 1; i >= 0; i--) {
-        const block = jsonBlocks[i][1].trim();
-        try {
-            const parsed = JSON.parse(block);
-            if (parsed.result) {
-                return {
-                    success: true,
-                    summary: parsed.result.summary ?? "",
-                    changedFiles: parsed.result.changedFiles ?? parsed.result.changed_files ?? [],
-                };
-            }
-            if (parsed.handoff && parsed.handoff.to && parsed.handoff.task) {
-                const h = parsed.handoff;
-                return {
-                    success: true,
-                    summary: h.context ?? h.task,
-                    changedFiles: h.changedFiles ?? h.changed_files ?? [],
-                    handoff: {
-                        from: h.from ?? "",
-                        to: h.to,
-                        task: h.task,
-                        changedFiles: h.changedFiles ?? h.changed_files,
-                        acceptanceCriteria: h.acceptanceCriteria ?? h.acceptance_criteria,
-                        openQuestions: h.openQuestions ?? h.open_questions,
-                        context: h.context,
-                    },
-                };
-            }
-        }
-        catch {
-            // Not valid JSON
+function parseMessageProtocol(output, teammateName, _teammateNames) {
+    const lines = output.split("\n");
+    // Find # Subject heading
+    let subjectLineIdx = -1;
+    for (let i = 0; i < Math.min(lines.length, 10); i++) {
+        // Skip TO: lines
+        if (lines[i].match(/^TO:\s/i))
+            continue;
+        const headingMatch = lines[i].match(/^#\s+(.+)/);
+        if (headingMatch) {
+            subjectLineIdx = i;
+            break;
         }
     }
-    return null;
+    // Find all ```handoff blocks
+    const handoffBlocks = findHandoffBlocks(output);
+    const handoffs = handoffBlocks.map((h) => ({
+        from: teammateName,
+        to: h.target,
+        task: h.task,
+    }));
+    // If no heading and no handoffs, can't parse
+    if (subjectLineIdx < 0 && handoffs.length === 0)
+        return null;
+    const subject = subjectLineIdx >= 0
+        ? lines[subjectLineIdx].replace(/^#\s+/, "").trim()
+        : "";
+    return {
+        teammate: teammateName,
+        success: true,
+        summary: subject,
+        changedFiles: parseChangedFiles(output),
+        handoffs,
+        rawOutput: output,
+    };
+}
+/**
+ * Find a ```handoff fenced code block in the output.
+ *
+ * Format:
+ *   ```handoff
+ *   @<teammate>
+ *   <task description>
+ *   ```
+ *
+ * Returns the target teammate name and task body, or null.
+ */
+function findHandoffBlocks(output) {
+    const results = [];
+    const pattern = /```handoff\s*\n@(\w+)\s*\n([\s\S]*?)```/gi;
+    let match;
+    while ((match = pattern.exec(output)) !== null) {
+        results.push({ target: match[1].toLowerCase(), task: match[2].trim() });
+    }
+    return results;
 }
 /** Extract file paths from agent output. */
-function parseChangedFiles(output) {
+export function parseChangedFiles(output) {
     const files = new Set();
     // diff --git a/path b/path
     for (const match of output.matchAll(/diff --git a\/(.+?) b\//g)) {
@@ -374,90 +475,3 @@ function parseChangedFiles(output) {
     }
     return Array.from(files);
 }
-/**
- * Look for a JSON handoff envelope in the output.
- * Agents request handoffs by including a fenced JSON block:
- *
- * ```json
- * { "handoff": { "to": "tester", "task": "...", ... } }
- * ```
- */
-function parseHandoffEnvelope(output) {
-    const jsonBlocks = output.matchAll(/```json\s*\n([\s\S]*?)```/g);
-    for (const match of jsonBlocks) {
-        const block = match[1].trim();
-        if (!block.includes('"handoff"') && !block.includes('"to"'))
-            continue;
-        try {
-            const parsed = JSON.parse(block);
-            const envelope = parsed.handoff ?? parsed;
-            if (envelope.to && envelope.task) {
-                return {
-                    from: envelope.from ?? "",
-                    to: envelope.to,
-                    task: envelope.task,
-                    changedFiles: envelope.changedFiles ?? envelope.changed_files,
-                    acceptanceCriteria: envelope.acceptanceCriteria ?? envelope.acceptance_criteria,
-                    openQuestions: envelope.openQuestions ?? envelope.open_questions,
-                    context: envelope.context,
-                };
-            }
-        }
-        catch {
-            // Not valid JSON, skip
-        }
-    }
-    return null;
-}
-/**
- * Detect handoff intent from plain-text @mentions in the agent's response.
- * Catches cases like "This is in @beacon's domain. Let me hand it off."
- * where the agent didn't produce the structured JSON block.
- */
-/**
- * Detect handoff intent from plain-text @mentions in the agent's response.
- * Catches cases like "This is in @beacon's domain. Let me hand it off."
- * where the agent didn't produce the structured JSON block.
- */
-function parseHandoffFromMention(fromTeammate, output, teammateNames, originalTask) {
-    if (teammateNames.length === 0)
-        return null;
-    // Look for @teammate mentions (excluding the agent's own name)
-    const others = teammateNames.filter((n) => n !== fromTeammate);
-    if (others.length === 0)
-        return null;
-    // Match @name patterns — require handoff-like language nearby
-    const handoffPatterns = /\bhand(?:ing)?\s*(?:it\s+)?off\b|\bdelegate\b|\broute\b|\bpass(?:ing)?\s+(?:it\s+)?(?:to|along)\b|\bbelong(?:s)?\s+to\b|\b(?:is\s+in)\s+@\w+'?s?\s+domain\b/i;
-    for (const name of others) {
-        const mentionPattern = new RegExp(`@${name}\\b`, "i");
-        if (mentionPattern.test(output) && handoffPatterns.test(output)) {
-            return {
-                from: fromTeammate,
-                to: name,
-                task: originalTask || output.slice(0, 200).trim(),
-                context: output.replace(/```json[\s\S]*?```/g, "").trim().slice(0, 500),
-            };
-        }
-    }
-    return null;
-}
-/** Extract a summary from agent output. */
-function extractSummary(output) {
-    // Look for a "## Summary" or "Summary:" section
-    const summaryMatch = output.match(/(?:##?\s*Summary|Summary:)\s*\n([\s\S]*?)(?:\n##|\n---|\n```|$)/i);
-    if (summaryMatch) {
-        const summary = summaryMatch[1].trim();
-        if (summary.length > 0)
-            return summary.slice(0, 500);
-    }
-    // Fall back to last non-empty paragraph
-    const paragraphs = output
-        .split(/\n\s*\n/)
-        .map((p) => p.trim())
-        .filter((p) => p.length > 0 && !p.startsWith("```"));
-    if (paragraphs.length > 0) {
-        const last = paragraphs[paragraphs.length - 1];
-        return last.length > 500 ? last.slice(0, 497) + "..." : last;
-    }
-    return output.slice(0, 200).trim();
-}

package/dist/adapters/copilot.d.ts

@@ -0,0 +1,50 @@
+/**
+ * GitHub Copilot SDK adapter — uses the @github/copilot-sdk to run tasks
+ * through GitHub Copilot's agentic coding engine.
+ *
+ * Unlike the CLI proxy adapter (which spawns subprocesses), this adapter
+ * communicates with Copilot via the SDK's JSON-RPC protocol, giving us:
+ *   - Structured event streaming (no stdout scraping)
+ *   - Session persistence via Copilot's infinite sessions
+ *   - Direct tool/permission control
+ *   - Access to Copilot's built-in coding tools (file ops, git, bash, etc.)
+ */
+import type { AgentAdapter, InstalledService, RosterEntry } from "../adapter.js";
+import type { TaskResult, TeammateConfig } from "../types.js";
+export interface CopilotAdapterOptions {
+    /** Model override (e.g. "gpt-4o", "claude-sonnet-4-5") */
+    model?: string;
+    /** Timeout in ms for sendAndWait (default: 600_000 = 10 min) */
+    timeout?: number;
+    /** GitHub token for authentication (falls back to env/logged-in user) */
+    githubToken?: string;
+    /** Custom provider config for BYOK mode */
+    provider?: {
+        type?: "openai" | "azure" | "anthropic";
+        baseUrl: string;
+        apiKey?: string;
+    };
+}
+export declare class CopilotAdapter implements AgentAdapter {
+    readonly name = "copilot";
+    /** Team roster — set by the orchestrator so prompts include teammate info. */
+    roster: RosterEntry[];
+    /** Installed services — set by the CLI so prompts include service info. */
+    services: InstalledService[];
+    private options;
+    private client;
+    private sessions;
+    /** Session files per teammate — persists state across task invocations. */
+    private sessionFiles;
+    /** Base directory for session files. */
+    private sessionsDir;
+    constructor(options?: CopilotAdapterOptions);
+    startSession(teammate: TeammateConfig): Promise<string>;
+    executeTask(_sessionId: string, teammate: TeammateConfig, prompt: string): Promise<TaskResult>;
+    routeTask(task: string, roster: RosterEntry[]): Promise<string | null>;
+    destroySession(_sessionId: string): Promise<void>;
+    /**
+     * Ensure the CopilotClient is started.
+     */
+    private ensureClient;
+}