@teammates/cli 0.5.3 → 0.6.0

package/dist/index.js

@@ -1,10 +1,11 @@
 // Public API for @teammates/cli
 export { buildTeammatePrompt, DAILY_LOG_BUDGET_TOKENS, formatHandoffContext, queryRecallContext, syncRecallIndex, } from "./adapter.js";
-export { autoCompactForBudget } from "./compact.js";
 export { CliProxyAdapter, PRESETS, } from "./adapters/cli-proxy.js";
 export { EchoAdapter } from "./adapters/echo.js";
 export { AnimatedBanner } from "./banner.js";
 export { findTeammatesDir, PKG_VERSION, parseCliArgs } from "./cli-args.js";
+export { autoCompactForBudget, buildDailyCompressionPrompt, buildMigrationCompressionPrompt, findUncompressedDailies, } from "./compact.js";
+export { buildConversationLog, formatLogTimeline, parseClaudeDebugLog, parseCodexOutput, parseRawOutput, } from "./log-parser.js";
 export { Orchestrator, } from "./orchestrator.js";
 export { loadPersonas, scaffoldFromPersona } from "./personas.js";
 export { Registry } from "./registry.js";

package/dist/log-parser.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Agent log parser — extracts condensed conversation timelines from agent
+ * debug logs and stdout for the interrupt-and-resume system.
+ *
+ * Each agent type has a different log format:
+ * - Claude: structured --debug-file with tool calls and results
+ * - Codex: JSONL with item.completed events
+ * - Others: raw stdout (truncated)
+ */
+/** A single action extracted from an agent's conversation log. */
+export interface LogEntry {
+    /** Tool name or action type (e.g. "Write", "Read", "Search", "text") */
+    action: string;
+    /** Key parameters — file paths, search queries (NOT full file contents) */
+    summary: string;
+}
+/**
+ * Parse a Claude --debug-file into condensed log entries.
+ *
+ * The debug file contains the full conversation log including tool calls
+ * and their results. We extract tool names and key parameters (file paths,
+ * search queries) but NOT full file contents to keep the resume prompt compact.
+ */
+export declare function parseClaudeDebugLog(debugFilePath: string): LogEntry[];
+/**
+ * Parse Codex JSONL output into condensed log entries.
+ */
+export declare function parseCodexOutput(stdout: string): LogEntry[];
+/**
+ * Parse raw stdout into condensed log entries (fallback for unknown agents).
+ */
+export declare function parseRawOutput(output: string): LogEntry[];
+/**
+ * Format log entries into a condensed markdown timeline for the resume prompt.
+ *
+ * Keeps the output compact — file paths and search queries only, no content.
+ * Groups consecutive same-action entries (e.g., "Wrote 15 files: ...").
+ */
+export declare function formatLogTimeline(entries: LogEntry[]): string;
+/**
+ * Estimate the token count of a string (rough: 1 token ≈ 4 chars).
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Build a condensed conversation log from the available sources.
+ * Tries Claude debug file first, then Codex JSONL, then raw stdout.
+ * Truncates to the token budget if needed.
+ */
+export declare function buildConversationLog(debugFile: string | undefined, stdout: string, presetName: string, tokenBudget?: number): {
+    log: string;
+    toolCallCount: number;
+    filesChanged: string[];
+};

package/dist/log-parser.js

@@ -0,0 +1,228 @@
+/**
+ * Agent log parser — extracts condensed conversation timelines from agent
+ * debug logs and stdout for the interrupt-and-resume system.
+ *
+ * Each agent type has a different log format:
+ * - Claude: structured --debug-file with tool calls and results
+ * - Codex: JSONL with item.completed events
+ * - Others: raw stdout (truncated)
+ */
+import { readFileSync } from "node:fs";
+/**
+ * Parse a Claude --debug-file into condensed log entries.
+ *
+ * The debug file contains the full conversation log including tool calls
+ * and their results. We extract tool names and key parameters (file paths,
+ * search queries) but NOT full file contents to keep the resume prompt compact.
+ */
+export function parseClaudeDebugLog(debugFilePath) {
+    let content;
+    try {
+        content = readFileSync(debugFilePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    // Claude debug logs contain tool_use and tool_result blocks
+    // Extract tool calls with their key parameters
+    const toolUsePattern = /Tool call:\s*(\w+)\s*\{([^}]*)\}|"type":\s*"tool_use".*?"name":\s*"(\w+)".*?"input":\s*\{([^}]*)\}/g;
+    let match;
+    while ((match = toolUsePattern.exec(content)) !== null) {
+        const toolName = match[1] || match[3];
+        const params = match[2] || match[4];
+        if (!toolName)
+            continue;
+        const summary = extractKeyParams(toolName, params);
+        entries.push({ action: toolName, summary });
+    }
+    // If structured parsing found nothing, try line-by-line patterns
+    if (entries.length === 0) {
+        for (const line of content.split("\n")) {
+            // Look for common Claude debug log patterns
+            const writeMatch = line.match(/(?:Write|Edit|Create)\s+(?:file:?\s*)?[`"]?([^\s`"]+\.\w+)/i);
+            if (writeMatch) {
+                entries.push({ action: "Write", summary: writeMatch[1] });
+                continue;
+            }
+            const readMatch = line.match(/(?:Read)\s+(?:file:?\s*)?[`"]?([^\s`"]+\.\w+)/i);
+            if (readMatch) {
+                entries.push({ action: "Read", summary: readMatch[1] });
+                continue;
+            }
+            const searchMatch = line.match(/(?:Search|Grep|Glob)\s+.*?["']([^"']+)["']/i);
+            if (searchMatch) {
+                entries.push({ action: "Search", summary: searchMatch[1] });
+                continue;
+            }
+            const bashMatch = line.match(/(?:Bash|Shell|Execute)\s+.*?["'`]([^"'`]+)["'`]/i);
+            if (bashMatch) {
+                entries.push({
+                    action: "Bash",
+                    summary: bashMatch[1].slice(0, 80),
+                });
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * Parse Codex JSONL output into condensed log entries.
+ */
+export function parseCodexOutput(stdout) {
+    const entries = [];
+    for (const line of stdout.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "item.completed") {
+                if (event.item?.type === "tool_call") {
+                    const toolName = event.item.name ?? "tool";
+                    const summary = event.item.arguments
+                        ? extractKeyParams(toolName, JSON.stringify(event.item.arguments))
+                        : "";
+                    entries.push({ action: toolName, summary });
+                }
+                else if (event.item?.type === "agent_message" && event.item.text) {
+                    entries.push({
+                        action: "text",
+                        summary: event.item.text.slice(0, 100),
+                    });
+                }
+            }
+        }
+        catch {
+            /* skip non-JSON lines */
+        }
+    }
+    return entries;
+}
+/**
+ * Parse raw stdout into condensed log entries (fallback for unknown agents).
+ */
+export function parseRawOutput(output) {
+    const entries = [];
+    for (const line of output.split("\n")) {
+        const writeMatch = line.match(/(?:Created|Modified|Updated|Wrote|Edited)\s+(?:file:?\s*)?[`"]?([^\s`"]+\.\w+)/i);
+        if (writeMatch) {
+            entries.push({ action: "Write", summary: writeMatch[1] });
+        }
+    }
+    return entries;
+}
+/**
+ * Format log entries into a condensed markdown timeline for the resume prompt.
+ *
+ * Keeps the output compact — file paths and search queries only, no content.
+ * Groups consecutive same-action entries (e.g., "Wrote 15 files: ...").
+ */
+export function formatLogTimeline(entries) {
+    if (entries.length === 0)
+        return "(no tool calls captured)";
+    const lines = [];
+    let i = 0;
+    while (i < entries.length) {
+        const entry = entries[i];
+        // Group consecutive same-action entries
+        let groupEnd = i + 1;
+        while (groupEnd < entries.length &&
+            entries[groupEnd].action === entry.action) {
+            groupEnd++;
+        }
+        const groupSize = groupEnd - i;
+        if (groupSize > 3 && entry.action !== "text") {
+            // Collapse large groups
+            const summaries = entries
+                .slice(i, groupEnd)
+                .map((e) => e.summary)
+                .filter(Boolean);
+            const preview = summaries.slice(0, 3).join(", ");
+            const more = summaries.length > 3 ? ` (+${summaries.length - 3} more)` : "";
+            lines.push(`${lines.length + 1}. ${entry.action} ${groupSize} items: ${preview}${more}`);
+            i = groupEnd;
+        }
+        else {
+            // Individual entries
+            for (let j = i; j < groupEnd; j++) {
+                const e = entries[j];
+                const desc = e.summary ? ` ${e.summary}` : "";
+                lines.push(`${lines.length + 1}. ${e.action}${desc}`);
+            }
+            i = groupEnd;
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Extract key parameters from a tool call — file paths and search queries,
+ * NOT full file contents. Keeps the resume prompt compact.
+ */
+function extractKeyParams(toolName, paramsStr) {
+    const lower = toolName.toLowerCase();
+    // Extract file_path parameter
+    const filePathMatch = paramsStr.match(/file_path["']?\s*[:=]\s*["']([^"']+)["']/);
+    if (filePathMatch)
+        return filePathMatch[1];
+    // Extract path parameter
+    const pathMatch = paramsStr.match(/["']?path["']?\s*[:=]\s*["']([^"']+)["']/);
+    if (pathMatch)
+        return pathMatch[1];
+    // Extract command for bash/shell tools
+    if (lower === "bash" || lower === "shell" || lower === "execute") {
+        const cmdMatch = paramsStr.match(/["']?command["']?\s*[:=]\s*["']([^"']+)["']/);
+        if (cmdMatch)
+            return cmdMatch[1].slice(0, 80);
+    }
+    // Extract query/pattern for search tools
+    if (lower === "search" || lower === "grep" || lower === "glob") {
+        const queryMatch = paramsStr.match(/["']?(?:query|pattern)["']?\s*[:=]\s*["']([^"']+)["']/);
+        if (queryMatch)
+            return queryMatch[1];
+    }
+    return "";
+}
+/**
+ * Estimate the token count of a string (rough: 1 token ≈ 4 chars).
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Build a condensed conversation log from the available sources.
+ * Tries Claude debug file first, then Codex JSONL, then raw stdout.
+ * Truncates to the token budget if needed.
+ */
+export function buildConversationLog(debugFile, stdout, presetName, tokenBudget = 8_000) {
+    let entries;
+    if (debugFile && presetName === "claude") {
+        entries = parseClaudeDebugLog(debugFile);
+    }
+    else if (presetName === "codex") {
+        entries = parseCodexOutput(stdout);
+    }
+    else {
+        entries = parseRawOutput(stdout);
+    }
+    // Extract files changed
+    const filesChanged = entries
+        .filter((e) => ["Write", "Edit", "Create", "write", "edit", "create"].includes(e.action))
+        .map((e) => e.summary)
+        .filter(Boolean);
+    const toolCallCount = entries.filter((e) => e.action !== "text").length;
+    let log = formatLogTimeline(entries);
+    // Truncate if over budget
+    if (estimateTokens(log) > tokenBudget) {
+        // Keep first and last entries, summarize the middle
+        const lines = log.split("\n");
+        const keepFirst = Math.floor(lines.length * 0.3);
+        const keepLast = Math.floor(lines.length * 0.2);
+        const omitted = lines.length - keepFirst - keepLast;
+        log = [
+            ...lines.slice(0, keepFirst),
+            `... (${omitted} steps omitted for brevity) ...`,
+            ...lines.slice(lines.length - keepLast),
+        ].join("\n");
+    }
+    return { log, toolCallCount, filesChanged };
+}

package/dist/log-parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/log-parser.test.js

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { buildConversationLog, formatLogTimeline, parseCodexOutput, parseRawOutput, } from "./log-parser.js";
+describe("parseRawOutput", () => {
+    it("extracts file write patterns from stdout", () => {
+        const output = [
+            "Created file: `src/foo.ts`",
+            "Modified bar.js",
+            "Some other output",
+            "Wrote `packages/cli/src/index.ts`",
+        ].join("\n");
+        const entries = parseRawOutput(output);
+        expect(entries).toHaveLength(3);
+        expect(entries[0]).toEqual({ action: "Write", summary: "src/foo.ts" });
+        expect(entries[1]).toEqual({ action: "Write", summary: "bar.js" });
+        expect(entries[2]).toEqual({
+            action: "Write",
+            summary: "packages/cli/src/index.ts",
+        });
+    });
+    it("returns empty array for output with no file patterns", () => {
+        const entries = parseRawOutput("Just some plain text output");
+        expect(entries).toHaveLength(0);
+    });
+});
+describe("parseCodexOutput", () => {
+    it("extracts tool calls from JSONL events", () => {
+        const output = [
+            JSON.stringify({
+                type: "item.completed",
+                item: {
+                    type: "tool_call",
+                    name: "write_file",
+                    arguments: { path: "src/foo.ts" },
+                },
+            }),
+            JSON.stringify({
+                type: "item.completed",
+                item: { type: "agent_message", text: "Done with the task" },
+            }),
+        ].join("\n");
+        const entries = parseCodexOutput(output);
+        expect(entries).toHaveLength(2);
+        expect(entries[0].action).toBe("write_file");
+        expect(entries[1]).toEqual({
+            action: "text",
+            summary: "Done with the task",
+        });
+    });
+    it("skips non-JSON lines", () => {
+        const output = "not json\n{invalid\n";
+        const entries = parseCodexOutput(output);
+        expect(entries).toHaveLength(0);
+    });
+});
+describe("formatLogTimeline", () => {
+    it("formats individual entries with numbered steps", () => {
+        const entries = [
+            { action: "Read", summary: "src/foo.ts" },
+            { action: "Write", summary: "src/bar.ts" },
+        ];
+        const result = formatLogTimeline(entries);
+        expect(result).toBe("1. Read src/foo.ts\n2. Write src/bar.ts");
+    });
+    it("groups consecutive same-action entries when > 3", () => {
+        const entries = [
+            { action: "Write", summary: "a.ts" },
+            { action: "Write", summary: "b.ts" },
+            { action: "Write", summary: "c.ts" },
+            { action: "Write", summary: "d.ts" },
+            { action: "Write", summary: "e.ts" },
+        ];
+        const result = formatLogTimeline(entries);
+        expect(result).toContain("Write 5 items");
+        expect(result).toContain("a.ts, b.ts, c.ts");
+        expect(result).toContain("(+2 more)");
+    });
+    it("does not group when 3 or fewer consecutive entries", () => {
+        const entries = [
+            { action: "Write", summary: "a.ts" },
+            { action: "Write", summary: "b.ts" },
+            { action: "Write", summary: "c.ts" },
+        ];
+        const result = formatLogTimeline(entries);
+        expect(result).toBe("1. Write a.ts\n2. Write b.ts\n3. Write c.ts");
+    });
+    it("returns fallback for empty entries", () => {
+        expect(formatLogTimeline([])).toBe("(no tool calls captured)");
+    });
+});
+describe("buildConversationLog", () => {
+    it("uses raw output parser for unknown presets", () => {
+        const stdout = "Created file: `test.ts`\nDone";
+        const result = buildConversationLog(undefined, stdout, "aider");
+        expect(result.filesChanged).toContain("test.ts");
+        expect(result.toolCallCount).toBe(1);
+        expect(result.log).toContain("Write");
+    });
+    it("groups large batch writes into a compact summary", () => {
+        // 200 file writes should be grouped, not listed individually
+        const entries = Array.from({ length: 200 }, (_, i) => `Created file: \`file${i}.ts\``).join("\n");
+        const result = buildConversationLog(undefined, entries, "generic");
+        expect(result.toolCallCount).toBe(200);
+        expect(result.log).toContain("Write 200 items");
+        // The grouped output should be compact (single line)
+        expect(result.log.split("\n")).toHaveLength(1);
+    });
+    it("handles empty output gracefully", () => {
+        const result = buildConversationLog(undefined, "", "claude");
+        expect(result.toolCallCount).toBe(0);
+        expect(result.filesChanged).toHaveLength(0);
+        expect(result.log).toBe("(no tool calls captured)");
+    });
+});

package/dist/orchestrator.d.ts

@@ -42,6 +42,8 @@ export declare class Orchestrator {
     listTeammates(): string[];
     /** Get the registry for direct access */
     getRegistry(): Registry;
+    /** Get the adapter for direct access (used by /interrupt) */
+    getAdapter(): AgentAdapter;
     /**
      * Assign a task to a specific teammate and execute it.
      * If the result contains a handoff, follows the chain automatically.

package/dist/orchestrator.js

@@ -42,6 +42,10 @@ export class Orchestrator {
     getRegistry() {
         return this.registry;
     }
+    /** Get the adapter for direct access (used by /interrupt) */
+    getAdapter() {
+        return this.adapter;
+    }
     /**
      * Assign a task to a specific teammate and execute it.
      * If the result contains a handoff, follows the chain automatically.

package/dist/types.d.ts

@@ -123,6 +123,7 @@ export type QueueEntry = {
     teammate: string;
     task: string;
     system?: boolean;
+    migration?: boolean;
 } | {
     type: "compact";
     teammate: string;
@@ -144,6 +145,23 @@ export type QueueEntry = {
     teammate: string;
     task: string;
 };
+/** State captured when an agent is interrupted mid-task. */
+export interface InterruptState {
+    /** The teammate that was interrupted */
+    teammate: string;
+    /** The original task prompt (user-facing, not the full wrapped prompt) */
+    originalTask: string;
+    /** The full prompt sent to the agent (identity + memory + task) */
+    originalFullPrompt: string;
+    /** Condensed conversation log from the interrupted session */
+    conversationLog: string;
+    /** How long the agent ran before interruption (ms) */
+    elapsedMs: number;
+    /** Number of tool calls made before interruption */
+    toolCallCount: number;
+    /** Files written/modified before interruption */
+    filesChanged: string[];
+}
 /** A registered slash command. */
 export interface SlashCommand {
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammates/cli",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Agent-agnostic CLI for teammates. Routes tasks, manages handoffs, and plugs into any coding agent backend.",
   "type": "module",
   "main": "dist/index.js",
@@ -34,8 +34,8 @@
   "license": "MIT",
   "dependencies": {
     "@github/copilot-sdk": "^0.1.32",
-    "@teammates/consolonia": "0.5.3",
-    "@teammates/recall": "0.5.3",
+    "@teammates/consolonia": "0.6.0",
+    "@teammates/recall": "0.6.0",
     "chalk": "^5.6.2",
     "ora": "^9.3.0"
   },