@teammates/cli 0.1.0 → 0.2.0

package/dist/adapters/copilot.js

@@ -0,0 +1,210 @@
+/**
+ * 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 { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { approveAll, CopilotClient, } from "@github/copilot-sdk";
+import { buildTeammatePrompt } from "../adapter.js";
+import { parseResult } from "./cli-proxy.js";
+// ─── Adapter ─────────────────────────────────────────────────────────
+let nextId = 1;
+export class CopilotAdapter {
+    name = "copilot";
+    /** Team roster — set by the orchestrator so prompts include teammate info. */
+    roster = [];
+    /** Installed services — set by the CLI so prompts include service info. */
+    services = [];
+    options;
+    client = null;
+    sessions = new Map();
+    /** Session files per teammate — persists state across task invocations. */
+    sessionFiles = new Map();
+    /** Base directory for session files. */
+    sessionsDir = "";
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async startSession(teammate) {
+        const id = `copilot-${teammate.name}-${nextId++}`;
+        // Ensure the client is running
+        await this.ensureClient(teammate.cwd);
+        // Create session file inside .teammates/.tmp so the agent can access it
+        if (!this.sessionsDir) {
+            const tmpBase = join(teammate.cwd ?? process.cwd(), ".teammates", ".tmp");
+            this.sessionsDir = join(tmpBase, "sessions");
+            await mkdir(this.sessionsDir, { recursive: true });
+            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) {
+        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) {
+            fullPrompt = buildTeammatePrompt(teammate, prompt, {
+                roster: this.roster,
+                services: this.services,
+                sessionFile,
+            });
+        }
+        else {
+            // Raw agent mode — minimal wrapping
+            const parts = [prompt];
+            const others = this.roster.filter((r) => r.name !== teammate.name);
+            if (others.length > 0) {
+                parts.push("\n\n---\n");
+                parts.push("If part of this task belongs to a specialist, you can hand it off.");
+                parts.push("Your teammates:");
+                for (const t of others) {
+                    const owns = t.ownership.primary.length > 0
+                        ? ` — owns: ${t.ownership.primary.join(", ")}`
+                        : "";
+                    parts.push(`- @${t.name}: ${t.role}${owns}`);
+                }
+                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");
+        }
+        // Create a Copilot session with the teammate prompt as the system message
+        const session = await this.client.createSession({
+            model: this.options.model,
+            systemMessage: {
+                mode: "replace",
+                content: fullPrompt,
+            },
+            onPermissionRequest: approveAll,
+            provider: this.options.provider
+                ? {
+                    type: this.options.provider.type ?? "openai",
+                    baseUrl: this.options.provider.baseUrl,
+                    apiKey: this.options.provider.apiKey,
+                }
+                : undefined,
+            workingDirectory: teammate.cwd ?? process.cwd(),
+        });
+        // Collect the assistant's response silently — the CLI handles rendering.
+        // We do NOT write to stdout here; that would corrupt the consolonia UI.
+        const outputParts = [];
+        session.on("assistant.message_delta", (event) => {
+            const delta = event.data
+                ?.deltaContent;
+            if (delta) {
+                outputParts.push(delta);
+            }
+        });
+        try {
+            const timeout = this.options.timeout ?? 600_000;
+            const reply = await session.sendAndWait({ prompt }, timeout);
+            // Use the final assistant message content, fall back to collected deltas
+            const output = reply?.data?.content ?? outputParts.join("");
+            const teammateNames = this.roster.map((r) => r.name);
+            return parseResult(teammate.name, output, teammateNames, prompt);
+        }
+        finally {
+            // Disconnect the session (preserves data for potential resume)
+            await session.disconnect().catch(() => { });
+        }
+    }
+    async routeTask(task, roster) {
+        await this.ensureClient();
+        const lines = [
+            "You are a task router. Given a task and a list of teammates, reply with ONLY the name of the teammate who should handle it. No explanation, no punctuation — just the name.",
+            "",
+            "Teammates:",
+        ];
+        for (const t of roster) {
+            const owns = t.ownership.primary.length > 0
+                ? ` — owns: ${t.ownership.primary.join(", ")}`
+                : "";
+            lines.push(`- ${t.name}: ${t.role}${owns}`);
+        }
+        lines.push("", `Task: ${task}`);
+        const session = await this.client.createSession({
+            model: this.options.model,
+            onPermissionRequest: approveAll,
+            systemMessage: {
+                mode: "replace",
+                content: lines.join("\n"),
+            },
+        });
+        try {
+            const reply = await session.sendAndWait({ prompt: task }, 30_000);
+            const output = reply?.data?.content?.trim().toLowerCase() ??
+                "";
+            // Match against roster names
+            const rosterNames = roster.map((r) => r.name);
+            for (const name of rosterNames) {
+                if (output === name.toLowerCase() ||
+                    output.endsWith(name.toLowerCase())) {
+                    return name;
+                }
+            }
+            for (const name of rosterNames) {
+                if (output.includes(name.toLowerCase())) {
+                    return name;
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+        finally {
+            await session.disconnect().catch(() => { });
+        }
+    }
+    async destroySession(_sessionId) {
+        // Disconnect all sessions
+        for (const [, session] of this.sessions) {
+            await session.disconnect().catch(() => { });
+        }
+        this.sessions.clear();
+        // Stop the client
+        if (this.client) {
+            await this.client.stop().catch(() => { });
+            this.client = null;
+        }
+    }
+    /**
+     * Ensure the CopilotClient is started.
+     */
+    async ensureClient(cwd) {
+        if (this.client)
+            return;
+        // Suppress Node.js ExperimentalWarning (e.g. SQLite) in the SDK's
+        // CLI subprocess so it doesn't leak into the terminal UI.
+        const env = { ...process.env };
+        const existing = env.NODE_OPTIONS ?? "";
+        if (!existing.includes("--disable-warning=ExperimentalWarning")) {
+            env.NODE_OPTIONS = existing
+                ? `${existing} --disable-warning=ExperimentalWarning`
+                : "--disable-warning=ExperimentalWarning";
+        }
+        this.client = new CopilotClient({
+            cwd: cwd ?? process.cwd(),
+            githubToken: this.options.githubToken,
+            env,
+        });
+        await this.client.start();
+    }
+}

package/dist/adapters/echo.d.ts

@@ -5,9 +5,9 @@
  * Useful for verifying orchestrator wiring, handoff logic, and CLI behavior.
  */
 import type { AgentAdapter } from "../adapter.js";
-import type { TeammateConfig, TaskResult } from "../types.js";
+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): Promise<TaskResult>;
 }

package/dist/adapters/echo.js

@@ -11,13 +11,14 @@ export class EchoAdapter {
     async startSession(teammate) {
         return `echo-${teammate.name}-${nextId++}`;
     }
-    async executeTask(sessionId, teammate, prompt) {
+    async executeTask(_sessionId, teammate, prompt) {
         const fullPrompt = buildTeammatePrompt(teammate, prompt);
         return {
             teammate: teammate.name,
             success: true,
             summary: `[echo] ${teammate.name} received task (${prompt.length} chars)`,
             changedFiles: [],
+            handoffs: [],
             rawOutput: fullPrompt,
         };
     }

package/dist/adapters/echo.test.js

@@ -1,12 +1,14 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { EchoAdapter } from "./echo.js";
 const teammate = {
     name: "beacon",
     role: "Platform engineer.",
     soul: "# Beacon\n\nBeacon owns the recall package.",
-    memories: "",
+    wisdom: "",
     dailyLogs: [],
+    weeklyLogs: [],
     ownership: { primary: [], secondary: [] },
+    routingKeywords: [],
 };
 describe("EchoAdapter", () => {
     it("has name 'echo'", () => {

package/dist/cli-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pure utility functions extracted from cli.ts for testability.
+ */
+/** Convert a Date to a human-readable relative time string. */
+export declare function relativeTime(date: Date): string;
+/** Word-wrap text to maxWidth, returning an array of lines. */
+export declare function wrapLine(text: string, maxWidth: number): string[];
+/**
+ * Find an @mention at the given cursor position in a line.
+ * Returns the partial text after '@', the position of '@', and the text before it,
+ * or null if no valid @mention is found.
+ */
+export declare function findAtMention(line: string, cursor: number): {
+    before: string;
+    partial: string;
+    atPos: number;
+} | null;
+/** Set of recognized image file extensions. */
+export declare const IMAGE_EXTS: Set<string>;
+/** Check if a string looks like an image file path. */
+export declare function isImagePath(text: string): boolean;

package/dist/cli-utils.js

@@ -0,0 +1,74 @@
+/**
+ * Pure utility functions extracted from cli.ts for testability.
+ */
+/** Convert a Date to a human-readable relative time string. */
+export function relativeTime(date) {
+    const diff = Date.now() - date.getTime();
+    const secs = Math.floor(diff / 1000);
+    if (secs < 60)
+        return `${secs}s ago`;
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hrs = Math.floor(mins / 60);
+    return `${hrs}h ago`;
+}
+/** Word-wrap text to maxWidth, returning an array of lines. */
+export function wrapLine(text, maxWidth) {
+    if (text.length <= maxWidth)
+        return [text];
+    const lines = [];
+    let remaining = text;
+    while (remaining.length > maxWidth) {
+        let breakAt = remaining.lastIndexOf(" ", maxWidth);
+        if (breakAt <= 0)
+            breakAt = maxWidth;
+        lines.push(remaining.slice(0, breakAt));
+        remaining = remaining.slice(breakAt + (remaining[breakAt] === " " ? 1 : 0));
+    }
+    if (remaining)
+        lines.push(remaining);
+    return lines;
+}
+/**
+ * Find an @mention at the given cursor position in a line.
+ * Returns the partial text after '@', the position of '@', and the text before it,
+ * or null if no valid @mention is found.
+ */
+export function findAtMention(line, cursor) {
+    // Walk backward from cursor to find the nearest unescaped '@'
+    const left = line.slice(0, cursor);
+    const atPos = left.lastIndexOf("@");
+    if (atPos < 0)
+        return null;
+    // '@' must be at start of line or preceded by whitespace
+    if (atPos > 0 && !/\s/.test(line[atPos - 1]))
+        return null;
+    const partial = left.slice(atPos + 1);
+    // Partial must be a single token (no spaces)
+    if (/\s/.test(partial))
+        return null;
+    return { before: line.slice(0, atPos), partial, atPos };
+}
+/** Set of recognized image file extensions. */
+export const IMAGE_EXTS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".webp",
+    ".svg",
+    ".ico",
+]);
+/** Check if a string looks like an image file path. */
+export function isImagePath(text) {
+    // Must look like a file path (contains slash or backslash, or starts with drive letter)
+    if (!/[/\\]/.test(text) && !/^[a-zA-Z]:/.test(text))
+        return false;
+    // Must not contain newlines
+    if (/\n/.test(text))
+        return false;
+    const ext = text.slice(text.lastIndexOf(".")).toLowerCase();
+    return IMAGE_EXTS.has(ext);
+}

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

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

package/dist/cli-utils.test.js

@@ -0,0 +1,179 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { findAtMention, IMAGE_EXTS, isImagePath, relativeTime, wrapLine, } from "./cli-utils.js";
+// ── relativeTime ────────────────────────────────────────────────────
+describe("relativeTime", () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it("returns seconds ago for < 60s", () => {
+        vi.setSystemTime(new Date("2026-03-15T12:00:30Z"));
+        const date = new Date("2026-03-15T12:00:00Z");
+        expect(relativeTime(date)).toBe("30s ago");
+    });
+    it("returns 0s ago for just now", () => {
+        const now = new Date("2026-03-15T12:00:00Z");
+        vi.setSystemTime(now);
+        expect(relativeTime(now)).toBe("0s ago");
+    });
+    it("returns minutes ago for 1-59 minutes", () => {
+        vi.setSystemTime(new Date("2026-03-15T12:05:00Z"));
+        const date = new Date("2026-03-15T12:00:00Z");
+        expect(relativeTime(date)).toBe("5m ago");
+    });
+    it("returns 59m ago at the boundary", () => {
+        vi.setSystemTime(new Date("2026-03-15T12:59:59Z"));
+        const date = new Date("2026-03-15T12:00:00Z");
+        expect(relativeTime(date)).toBe("59m ago");
+    });
+    it("returns hours ago for >= 60 minutes", () => {
+        vi.setSystemTime(new Date("2026-03-15T15:00:00Z"));
+        const date = new Date("2026-03-15T12:00:00Z");
+        expect(relativeTime(date)).toBe("3h ago");
+    });
+    it("returns large hour counts", () => {
+        vi.setSystemTime(new Date("2026-03-16T12:00:00Z"));
+        const date = new Date("2026-03-15T12:00:00Z");
+        expect(relativeTime(date)).toBe("24h ago");
+    });
+});
+// ── wrapLine ────────────────────────────────────────────────────────
+describe("wrapLine", () => {
+    it("returns the text unchanged if it fits within maxWidth", () => {
+        expect(wrapLine("hello world", 80)).toEqual(["hello world"]);
+    });
+    it("returns single-element array for empty string", () => {
+        expect(wrapLine("", 40)).toEqual([""]);
+    });
+    it("wraps at the last space before maxWidth", () => {
+        const result = wrapLine("hello world foo bar", 11);
+        expect(result).toEqual(["hello world", "foo bar"]);
+    });
+    it("wraps long text into multiple lines", () => {
+        const text = "one two three four five six";
+        const result = wrapLine(text, 10);
+        // "one two" (7) fits, "three" next
+        expect(result.length).toBeGreaterThan(1);
+        for (const line of result) {
+            expect(line.length).toBeLessThanOrEqual(10);
+        }
+    });
+    it("hard-breaks when no space is found", () => {
+        const result = wrapLine("abcdefghij", 5);
+        expect(result).toEqual(["abcde", "fghij"]);
+    });
+    it("handles text exactly at maxWidth", () => {
+        expect(wrapLine("12345", 5)).toEqual(["12345"]);
+    });
+    it("handles maxWidth of 1 with spaces", () => {
+        const result = wrapLine("a b", 1);
+        // Each character should end up on its own line
+        expect(result.length).toBeGreaterThan(1);
+    });
+});
+// ── findAtMention ───────────────────────────────────────────────────
+describe("findAtMention", () => {
+    it("returns null when no @ is present", () => {
+        expect(findAtMention("hello world", 5)).toBeNull();
+    });
+    it("finds @mention at cursor position", () => {
+        const result = findAtMention("@beacon", 4);
+        expect(result).toEqual({ before: "", partial: "bea", atPos: 0 });
+    });
+    it("finds @mention at end of input", () => {
+        const result = findAtMention("@beacon", 7);
+        expect(result).toEqual({ before: "", partial: "beacon", atPos: 0 });
+    });
+    it("finds @mention after text", () => {
+        const result = findAtMention("hello @scribe", 13);
+        expect(result).toEqual({ before: "hello ", partial: "scribe", atPos: 6 });
+    });
+    it("returns null when @ is preceded by non-whitespace", () => {
+        expect(findAtMention("email@example", 13)).toBeNull();
+    });
+    it("returns empty partial when cursor is right after @", () => {
+        const result = findAtMention("hello @", 7);
+        expect(result).toEqual({ before: "hello ", partial: "", atPos: 6 });
+    });
+    it("returns null when partial contains spaces", () => {
+        // "@ foo bar" — after @, there's a space, so partial has whitespace
+        expect(findAtMention("@ foo bar", 9)).toBeNull();
+    });
+    it("finds mention at start of line with cursor mid-word", () => {
+        const result = findAtMention("@sc", 3);
+        expect(result).toEqual({ before: "", partial: "sc", atPos: 0 });
+    });
+    it("finds the last @ when multiple exist", () => {
+        const result = findAtMention("@beacon hello @scribe", 21);
+        expect(result).toEqual({
+            before: "@beacon hello ",
+            partial: "scribe",
+            atPos: 14,
+        });
+    });
+});
+// ── isImagePath ─────────────────────────────────────────────────────
+describe("isImagePath", () => {
+    it("recognizes Unix-style image paths", () => {
+        expect(isImagePath("/home/user/photo.png")).toBe(true);
+        expect(isImagePath("/tmp/image.jpg")).toBe(true);
+        expect(isImagePath("/tmp/image.jpeg")).toBe(true);
+        expect(isImagePath("/tmp/image.gif")).toBe(true);
+        expect(isImagePath("/tmp/image.bmp")).toBe(true);
+        expect(isImagePath("/tmp/image.webp")).toBe(true);
+        expect(isImagePath("/tmp/image.svg")).toBe(true);
+        expect(isImagePath("/tmp/image.ico")).toBe(true);
+    });
+    it("recognizes Windows-style image paths", () => {
+        expect(isImagePath("C:\\Users\\me\\photo.png")).toBe(true);
+        expect(isImagePath("D:\\images\\test.jpg")).toBe(true);
+    });
+    it("recognizes drive-letter paths without backslash", () => {
+        expect(isImagePath("C:photo.png")).toBe(true);
+    });
+    it("is case-insensitive for extensions", () => {
+        expect(isImagePath("/tmp/photo.PNG")).toBe(true);
+        expect(isImagePath("/tmp/photo.Jpg")).toBe(true);
+    });
+    it("rejects non-image extensions", () => {
+        expect(isImagePath("/tmp/file.txt")).toBe(false);
+        expect(isImagePath("/tmp/file.ts")).toBe(false);
+        expect(isImagePath("/tmp/file.pdf")).toBe(false);
+    });
+    it("rejects strings without path separators or drive letters", () => {
+        expect(isImagePath("photo.png")).toBe(false);
+        expect(isImagePath("image.jpg")).toBe(false);
+    });
+    it("rejects strings with newlines", () => {
+        expect(isImagePath("/tmp/photo.png\nextra")).toBe(false);
+    });
+    it("rejects empty string", () => {
+        expect(isImagePath("")).toBe(false);
+    });
+    it("rejects path with no extension", () => {
+        expect(isImagePath("/tmp/noext")).toBe(false);
+    });
+});
+// ── IMAGE_EXTS ──────────────────────────────────────────────────────
+describe("IMAGE_EXTS", () => {
+    it("contains expected extensions", () => {
+        const expected = [
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".bmp",
+            ".webp",
+            ".svg",
+            ".ico",
+        ];
+        for (const ext of expected) {
+            expect(IMAGE_EXTS.has(ext)).toBe(true);
+        }
+    });
+    it("has exactly 8 entries", () => {
+        expect(IMAGE_EXTS.size).toBe(8);
+    });
+});