@teammates/cli 0.4.1 → 0.5.1

package/dist/adapters/cli-proxy.js

@@ -20,7 +20,8 @@ import { mkdirSync } from "node:fs";
 import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { buildTeammatePrompt, queryRecallContext } from "../adapter.js";
+import { DAILY_LOG_BUDGET_TOKENS, buildTeammatePrompt, queryRecallContext, } from "../adapter.js";
+import { autoCompactForBudget } from "../compact.js";
 export const PRESETS = {
     claude: {
         name: "claude",
@@ -136,12 +137,15 @@ export class CliProxyAdapter {
         this.sessionFiles.set(teammate.name, sessionFile);
         return id;
     }
-    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
+    async executeTask(_sessionId, teammate, prompt, options) {
+        // If raw mode is set, skip all prompt wrapping — send prompt as-is
+        // Used for defensive retries where the full prompt template is counterproductive
         const sessionFile = this.sessionFiles.get(teammate.name);
         let fullPrompt;
-        if (teammate.soul) {
+        if (options?.raw) {
+            fullPrompt = prompt;
+        }
+        else if (teammate.soul) {
             // Query recall for relevant memories before building prompt
             const teammatesDir = teammate.cwd
                 ? join(teammate.cwd, ".teammates")
@@ -149,6 +153,16 @@ export class CliProxyAdapter {
             const recall = teammatesDir
                 ? await queryRecallContext(teammatesDir, teammate.name, prompt)
                 : undefined;
+            // Auto-compact daily logs if they exceed the token budget
+            if (teammatesDir) {
+                const teammateDir = join(teammatesDir, teammate.name);
+                const compacted = await autoCompactForBudget(teammateDir, DAILY_LOG_BUDGET_TOKENS);
+                if (compacted) {
+                    // Filter compacted dates out of in-memory daily logs
+                    const compactedSet = new Set(compacted.compactedDates);
+                    teammate.dailyLogs = teammate.dailyLogs.filter((log) => !compactedSet.has(log.date));
+                }
+            }
             // Read USER.md for injection into the prompt
             let userProfile;
             if (teammatesDir) {
@@ -478,8 +492,12 @@ function parseMessageProtocol(output, teammateName, _teammateNames) {
             break;
         }
     }
-    // Find all ```handoff blocks
+    // Find all ```handoff blocks (primary) + natural-language fallback
     const handoffBlocks = findHandoffBlocks(output);
+    if (handoffBlocks.length === 0) {
+        // Fallback: detect natural-language handoff patterns mentioning known teammates
+        handoffBlocks.push(...findNaturalLanguageHandoffs(output, _teammateNames));
+    }
     const handoffs = handoffBlocks.map((h) => ({
         from: teammateName,
         to: h.target,
@@ -520,6 +538,47 @@ function findHandoffBlocks(output) {
     }
     return results;
 }
+/**
+ * Fallback handoff detector: catches natural-language handoff patterns when
+ * the agent fails to use the ```handoff fenced block format.
+ *
+ * Looks for sentences like:
+ *   - "hand off to @beacon: implement the feature"
+ *   - "handing this to @scribe for documentation"
+ *   - "I'll delegate to @pipeline"
+ *   - "queued a handoff to @beacon"
+ *
+ * Only triggers if the @mentioned name is in the known teammate list.
+ * Extracts the surrounding sentence as the task description.
+ */
+function findNaturalLanguageHandoffs(output, teammateNames) {
+    if (teammateNames.length === 0)
+        return [];
+    const results = [];
+    const seen = new Set();
+    // Pattern: handoff-related verb/noun near @teammate
+    const pattern = /(?:hand(?:off|ing off| off| this off)|delegat(?:e|ing)|pass(?:ing)? (?:this |it )?(?:to|off to)|queued? (?:a )?handoff (?:to|for))\s+@(\w+)\b[.:,]?\s*(.*)/gi;
+    let match;
+    while ((match = pattern.exec(output)) !== null) {
+        const target = match[1].toLowerCase();
+        if (!teammateNames.includes(target))
+            continue;
+        if (seen.has(target))
+            continue;
+        seen.add(target);
+        // Use the rest of the sentence as the task, or a generic description
+        let task = match[2]
+            .replace(/\n.*/s, "") // first line only
+            .replace(/[.!]+$/, "") // strip trailing punctuation
+            .trim();
+        if (!task || task.length < 5) {
+            task =
+                "(handoff detected from natural language — no task details provided)";
+        }
+        results.push({ target, task });
+    }
+    return results;
+}
 /** Extract file paths from agent output. */
 export function parseChangedFiles(output) {
     const files = new Set();

package/dist/adapters/copilot.d.ts

@@ -40,7 +40,9 @@ export declare class CopilotAdapter implements AgentAdapter {
     private sessionsDir;
     constructor(options?: CopilotAdapterOptions);
     startSession(teammate: TeammateConfig): Promise<string>;
-    executeTask(_sessionId: string, teammate: TeammateConfig, prompt: string): Promise<TaskResult>;
+    executeTask(_sessionId: string, teammate: TeammateConfig, prompt: string, options?: {
+        raw?: boolean;
+    }): Promise<TaskResult>;
     routeTask(task: string, roster: RosterEntry[]): Promise<string | null>;
     getSessionFile(teammateName: string): string | undefined;
     destroySession(_sessionId: string): Promise<void>;

package/dist/adapters/copilot.js

@@ -12,7 +12,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { approveAll, CopilotClient, } from "@github/copilot-sdk";
-import { buildTeammatePrompt, queryRecallContext } from "../adapter.js";
+import { DAILY_LOG_BUDGET_TOKENS, buildTeammatePrompt, queryRecallContext, } from "../adapter.js";
+import { autoCompactForBudget } from "../compact.js";
 import { parseResult } from "./cli-proxy.js";
 // ─── Adapter ─────────────────────────────────────────────────────────
 let nextId = 1;
@@ -56,12 +57,15 @@ export class CopilotAdapter {
         this.sessionFiles.set(teammate.name, sessionFile);
         return id;
     }
-    async executeTask(_sessionId, teammate, prompt) {
+    async executeTask(_sessionId, teammate, prompt, options) {
         await this.ensureClient(teammate.cwd);
         const sessionFile = this.sessionFiles.get(teammate.name);
         // Build the full teammate prompt (identity + memory + task)
         let fullPrompt;
-        if (teammate.soul) {
+        if (options?.raw) {
+            fullPrompt = prompt;
+        }
+        else if (teammate.soul) {
             // Query recall for relevant memories before building prompt
             const teammatesDir = teammate.cwd
                 ? join(teammate.cwd, ".teammates")
@@ -69,6 +73,15 @@ export class CopilotAdapter {
             const recall = teammatesDir
                 ? await queryRecallContext(teammatesDir, teammate.name, prompt)
                 : undefined;
+            // Auto-compact daily logs if they exceed the token budget
+            if (teammatesDir) {
+                const teammateDir = join(teammatesDir, teammate.name);
+                const compacted = await autoCompactForBudget(teammateDir, DAILY_LOG_BUDGET_TOKENS);
+                if (compacted) {
+                    const compactedSet = new Set(compacted.compactedDates);
+                    teammate.dailyLogs = teammate.dailyLogs.filter((log) => !compactedSet.has(log.date));
+                }
+            }
             // Read USER.md for injection into the prompt
             let userProfile;
             if (teammatesDir) {

package/dist/adapters/echo.d.ts

@@ -9,5 +9,7 @@ import type { TaskResult, TeammateConfig } from "../types.js";
 export declare class EchoAdapter implements AgentAdapter {
     readonly name = "echo";
     startSession(teammate: TeammateConfig): Promise<string>;
-    executeTask(_sessionId: string, teammate: TeammateConfig, prompt: string): Promise<TaskResult>;
+    executeTask(_sessionId: string, teammate: TeammateConfig, prompt: string, options?: {
+        raw?: boolean;
+    }): Promise<TaskResult>;
 }

package/dist/adapters/echo.js

@@ -11,8 +11,10 @@ export class EchoAdapter {
     async startSession(teammate) {
         return `echo-${teammate.name}-${nextId++}`;
     }
-    async executeTask(_sessionId, teammate, prompt) {
-        const fullPrompt = buildTeammatePrompt(teammate, prompt);
+    async executeTask(_sessionId, teammate, prompt, options) {
+        const fullPrompt = options?.raw
+            ? prompt
+            : buildTeammatePrompt(teammate, prompt);
         return {
             teammate: teammate.name,
             success: true,

package/dist/banner.js

@@ -78,7 +78,11 @@ export class AnimatedBanner extends Control {
         // Service status rows
         for (const svc of info.services) {
             const isBundledOrConfigured = svc.status === "bundled" || svc.status === "configured";
-            const icon = isBundledOrConfigured ? "● " : svc.status === "not-configured" ? "◐ " : "○ ";
+            const icon = isBundledOrConfigured
+                ? "● "
+                : svc.status === "not-configured"
+                    ? "◐ "
+                    : "○ ";
             const color = isBundledOrConfigured ? tp.success : tp.warning;
             const label = svc.status === "bundled"
                 ? "bundled"

package/dist/cli-args.js

@@ -97,28 +97,28 @@ export async function resolveAdapter(name, opts = {}) {
 }
 // ─── Usage ───────────────────────────────────────────────────────────
 export function printUsage() {
-    console.log(`
-${chalk.bold("@teammates/cli")} — Agent-agnostic teammate orchestrator
-
-${chalk.bold("Usage:")}
-  teammates <agent>          Launch session with an agent
-  teammates codex            Use OpenAI Codex
-  teammates aider            Use Aider
-
-${chalk.bold("Options:")}
-  --model <model>            Override the agent model
-  --dir <path>               Override .teammates/ location
-
-${chalk.bold("Agents:")}
-  claude     Claude Code CLI (requires 'claude' on PATH)
-  codex      OpenAI Codex CLI (requires 'codex' on PATH)
-  aider      Aider CLI (requires 'aider' on PATH)
-  echo       Test adapter — echoes prompts (no external agent)
-
-${chalk.bold("In-session:")}
-  @teammate <task>           Assign directly via @mention
-  <text>                     Auto-route to the best teammate
-  /status                    Session overview
-  /help                      All commands
+    console.log(`
+${chalk.bold("@teammates/cli")} — Agent-agnostic teammate orchestrator
+
+${chalk.bold("Usage:")}
+  teammates <agent>          Launch session with an agent
+  teammates codex            Use OpenAI Codex
+  teammates aider            Use Aider
+
+${chalk.bold("Options:")}
+  --model <model>            Override the agent model
+  --dir <path>               Override .teammates/ location
+
+${chalk.bold("Agents:")}
+  claude     Claude Code CLI (requires 'claude' on PATH)
+  codex      OpenAI Codex CLI (requires 'codex' on PATH)
+  aider      Aider CLI (requires 'aider' on PATH)
+  echo       Test adapter — echoes prompts (no external agent)
+
+${chalk.bold("In-session:")}
+  @teammate <task>           Assign directly via @mention
+  <text>                     Auto-route to the best teammate
+  /status                    Session overview
+  /help                      All commands
 `.trim());
 }

package/dist/cli-args.test.d.ts

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

package/dist/cli-args.test.js

@@ -0,0 +1,125 @@
+import { mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { findTeammatesDir, PKG_VERSION, parseCliArgs, printUsage, } from "./cli-args.js";
+describe("parseCliArgs", () => {
+    it("returns defaults with no arguments", () => {
+        const result = parseCliArgs([]);
+        expect(result).toEqual({
+            showHelp: false,
+            modelOverride: undefined,
+            dirOverride: undefined,
+            adapterName: "echo",
+            agentPassthrough: [],
+        });
+    });
+    it("parses --help flag", () => {
+        const result = parseCliArgs(["--help"]);
+        expect(result.showHelp).toBe(true);
+    });
+    it("parses --model option with value", () => {
+        const result = parseCliArgs(["--model", "gpt-4"]);
+        expect(result.modelOverride).toBe("gpt-4");
+    });
+    it("parses --dir option with value", () => {
+        const result = parseCliArgs(["--dir", "/custom/path"]);
+        expect(result.dirOverride).toBe("/custom/path");
+    });
+    it("extracts adapter name as first positional argument", () => {
+        const result = parseCliArgs(["claude"]);
+        expect(result.adapterName).toBe("claude");
+    });
+    it("passes remaining args as agentPassthrough", () => {
+        const result = parseCliArgs(["claude", "--verbose", "--debug"]);
+        expect(result.adapterName).toBe("claude");
+        expect(result.agentPassthrough).toEqual(["--verbose", "--debug"]);
+    });
+    it("handles all options together", () => {
+        const result = parseCliArgs([
+            "--help",
+            "--model",
+            "sonnet",
+            "--dir",
+            "/tmp/tm",
+            "codex",
+            "--extra",
+        ]);
+        expect(result.showHelp).toBe(true);
+        expect(result.modelOverride).toBe("sonnet");
+        expect(result.dirOverride).toBe("/tmp/tm");
+        expect(result.adapterName).toBe("codex");
+        expect(result.agentPassthrough).toEqual(["--extra"]);
+    });
+    it("does not consume --model when no value follows", () => {
+        const result = parseCliArgs(["--model"]);
+        // getOption finds --model but no value after it, so it's left in args
+        // args.shift() then picks it up as the adapter name
+        expect(result.modelOverride).toBeUndefined();
+        expect(result.adapterName).toBe("--model");
+    });
+    it("does not treat --help value as an option value", () => {
+        const result = parseCliArgs(["--help", "claude"]);
+        expect(result.showHelp).toBe(true);
+        expect(result.adapterName).toBe("claude");
+    });
+});
+// ── PKG_VERSION ────────────────────────────────────────────────────
+describe("PKG_VERSION", () => {
+    it("is a valid semver-like string", () => {
+        expect(PKG_VERSION).toMatch(/^\d+\.\d+\.\d+/);
+    });
+});
+// ── findTeammatesDir ───────────────────────────────────────────────
+describe("findTeammatesDir", () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = join(tmpdir(), `cli-args-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        await mkdir(testDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(testDir, { recursive: true, force: true });
+    });
+    it("returns dirOverride when provided", async () => {
+        const result = await findTeammatesDir("/some/custom/dir");
+        expect(result).toContain("some");
+    });
+    it("returns .teammates dir when it exists under cwd", async () => {
+        const tmDir = join(testDir, ".teammates");
+        await mkdir(tmDir, { recursive: true });
+        // Mock process.cwd to return our test dir
+        const origCwd = process.cwd;
+        process.cwd = () => testDir;
+        try {
+            const result = await findTeammatesDir(undefined);
+            expect(result).toBe(tmDir);
+        }
+        finally {
+            process.cwd = origCwd;
+        }
+    });
+    it("returns null when no .teammates dir exists", async () => {
+        const origCwd = process.cwd;
+        process.cwd = () => testDir;
+        try {
+            const result = await findTeammatesDir(undefined);
+            expect(result).toBeNull();
+        }
+        finally {
+            process.cwd = origCwd;
+        }
+    });
+});
+// ── printUsage ────────────────────────────────────────────────────
+describe("printUsage", () => {
+    it("prints usage text to console", () => {
+        const spy = vi.spyOn(console, "log").mockImplementation(() => { });
+        printUsage();
+        expect(spy).toHaveBeenCalled();
+        const output = spy.mock.calls[0][0];
+        expect(output).toContain("teammates");
+        expect(output).toContain("--model");
+        expect(output).toContain("--dir");
+        spy.mockRestore();
+    });
+});