@teammates/cli 0.1.0 → 0.2.0

package/dist/console/startup.js

@@ -0,0 +1,138 @@
+/**
+ * Animated startup sequence for the teammates CLI.
+ *
+ * Phase 1: Reveals "teammates" letter by letter in block font, left-aligned.
+ * Phase 2: Replaces with compact "TM" block logo + stats panel to the right.
+ */
+import chalk from "chalk";
+// ── Timing helpers ────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function write(text) {
+    process.stdout.write(text);
+}
+// ── Block font glyphs (2 rows tall) ─────────────────────────────
+//
+// Each glyph is [topLine, bottomLine]. Uses Unicode half-blocks
+// (▀ ▄ █ ▐ ▌) for a clean, compact large-text look.
+const GLYPHS = {
+    t: ["▀█▀", " █ "],
+    e: ["█▀▀", "██▄"],
+    a: ["▄▀█", "█▀█"],
+    m: ["█▀▄▀█", "█ ▀ █"],
+    s: ["█▀", "▄█"],
+};
+/** Build the two-line title from a word using the block font. */
+export function buildTitle(word) {
+    const top = [];
+    const bot = [];
+    for (const ch of word) {
+        const g = GLYPHS[ch.toLowerCase()];
+        if (g) {
+            top.push(g[0]);
+            bot.push(g[1]);
+        }
+    }
+    return [top.join(" "), bot.join(" ")];
+}
+export async function playStartup(info) {
+    const termWidth = process.stdout.columns || 100;
+    const word = "teammates";
+    const indent = "  ";
+    // Hide cursor during animation
+    write("\x1b[?25l");
+    console.log();
+    // Phase 1: reveal full "teammates" title letter by letter, left-aligned
+    // Reserve two lines for the title area
+    write(`${indent}\n${indent}\n`);
+    write("\x1b[2A"); // move back up
+    let builtTop = "";
+    let builtBot = "";
+    for (const ch of word) {
+        const g = GLYPHS[ch.toLowerCase()];
+        if (!g)
+            continue;
+        if (builtTop.length > 0) {
+            builtTop += " ";
+            builtBot += " ";
+        }
+        builtTop += g[0];
+        builtBot += g[1];
+        write(`\r${indent}${chalk.cyan(builtTop)}`);
+        write(`\n\r${indent}${chalk.cyan(builtBot)}`);
+        write("\x1b[1A");
+        await sleep(60);
+    }
+    // Pause on the full title
+    await sleep(1000);
+    // Roll out version to the right of the logo on the bottom row
+    const versionTag = chalk.gray(` v${info.version}`);
+    write(`\n\r${indent}${chalk.cyan(builtBot)}${versionTag}`);
+    write("\x1b[1A"); // back to top line
+    await sleep(2000);
+    // Phase 2: Replace title with compact TM + stats
+    // Erase the two title lines and rewrite
+    write("\r\x1b[K"); // erase top line
+    write("\n\r\x1b[K"); // erase bottom line
+    write("\x1b[1A"); // back to top
+    const [tmTop, tmBot] = buildTitle("tm");
+    const tmWidth = tmTop.length; // "▀█▀ █▀▄▀█" = 9 chars
+    const gap = "   ";
+    // Build info lines to sit to the right of TM
+    const rightLine1 = chalk.white(info.adapterName) +
+        chalk.gray(` · ${info.teammateCount} teammate${info.teammateCount === 1 ? "" : "s"}`) +
+        chalk.gray(` · v${info.version}`);
+    const rightLine2 = chalk.gray(info.cwd);
+    const rightLine3 = info.recallInstalled
+        ? chalk.green("● recall") + chalk.gray(" installed")
+        : chalk.yellow("○ recall") + chalk.gray(" not installed");
+    // TM row 1 + first stat
+    write(`${indent + chalk.cyan(tmTop) + gap + rightLine1}\n`);
+    await sleep(40);
+    // TM row 2 + second stat
+    write(`${indent + chalk.cyan(tmBot) + gap + rightLine2}\n`);
+    await sleep(40);
+    // Blank TM area + third stat
+    write(`${indent + " ".repeat(tmWidth) + gap + rightLine3}\n`);
+    await sleep(80);
+    // Phase 3: roster
+    if (info.teammates.length > 0) {
+        console.log();
+        for (const t of info.teammates) {
+            const line = chalk.gray("  ") +
+                chalk.cyan("●") +
+                chalk.cyan(` @${t.name}`.padEnd(14)) +
+                chalk.gray(t.role);
+            console.log(line);
+            await sleep(40);
+        }
+    }
+    await sleep(80);
+    // Phase 4: quick reference
+    console.log();
+    console.log(chalk.gray("─".repeat(termWidth)));
+    const col1 = [
+        ["@mention", "assign to teammate"],
+        ["text", "auto-route task"],
+        ["/queue", "view task queue"],
+    ];
+    const col2 = [
+        ["/status", "session overview"],
+        ["/debug", "raw agent output"],
+        ["/log", "last task output"],
+    ];
+    const col3 = [
+        ["/install", "add a service"],
+        ["/help", "all commands"],
+        ["/exit", "exit session"],
+    ];
+    for (let i = 0; i < col1.length; i++) {
+        const c1 = chalk.cyan(col1[i][0].padEnd(12)) + chalk.gray(col1[i][1].padEnd(22));
+        const c2 = chalk.cyan(col2[i][0].padEnd(12)) + chalk.gray(col2[i][1].padEnd(22));
+        const c3 = chalk.cyan(col3[i][0].padEnd(12)) + chalk.gray(col3[i][1]);
+        console.log(`  ${c1}${c2}${c3}`);
+        await sleep(30);
+    }
+    console.log();
+}

package/dist/console/startup.test.d.ts

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

package/dist/console/startup.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { buildTitle } from "./startup.js";
+describe("buildTitle", () => {
+    it("produces two-line output for known characters", () => {
+        const [top, bot] = buildTitle("team");
+        // "t", "e", "a", "m" are all known glyphs
+        expect(top.length).toBeGreaterThan(0);
+        expect(bot.length).toBeGreaterThan(0);
+        // Should contain glyph fragments
+        expect(top).toContain("▀");
+        expect(bot).toContain("█");
+    });
+    it("renders a single character", () => {
+        const [top, bot] = buildTitle("t");
+        expect(top).toBe("▀█▀");
+        expect(bot).toBe(" █ ");
+    });
+    it("renders a multi-character word with spaces between glyphs", () => {
+        const [top, bot] = buildTitle("te");
+        // "t" top = "▀█▀", "e" top = "█▀▀" => joined with space
+        expect(top).toBe("▀█▀ █▀▀");
+        expect(bot).toBe(" █  ██▄");
+    });
+    it("returns empty strings for an empty input", () => {
+        const [top, bot] = buildTitle("");
+        expect(top).toBe("");
+        expect(bot).toBe("");
+    });
+    it("skips unknown characters", () => {
+        const [top, bot] = buildTitle("z");
+        // "z" is not in the GLYPHS map
+        expect(top).toBe("");
+        expect(bot).toBe("");
+    });
+    it("handles mixed known and unknown characters", () => {
+        const [top, bot] = buildTitle("txe");
+        // "x" is unknown, so only "t" and "e" glyphs appear
+        expect(top).toBe("▀█▀ █▀▀");
+        expect(bot).toBe(" █  ██▄");
+    });
+});

package/dist/console/wordwheel.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Wordwheel — autocomplete dropdown engine for readline REPLs.
+ *
+ * Manages a list of completion candidates, keyboard navigation (up/down/tab),
+ * and renders them via a Dropdown instance.
+ *
+ * The Wordwheel doesn't know about specific completions — you provide
+ * an ItemProvider callback that returns candidates for the current input.
+ */
+import type { Interface as ReadlineInterface } from "node:readline";
+import type { Dropdown } from "./dropdown.js";
+export interface WordwheelItem {
+    /** Left column display text (e.g. command name, ~14 chars). */
+    label: string;
+    /** Right column description text. */
+    description: string;
+    /** Full line content to set when this item is accepted. */
+    completion: string;
+}
+export interface WordwheelOptions {
+    /** Readline interface. */
+    rl: ReadlineInterface;
+    /** Dropdown to render into. */
+    dropdown: Dropdown;
+    /** Returns completion items for the current line/cursor state. */
+    getItems: (line: string, cursor: number) => WordwheelItem[];
+    /**
+     * Format a highlighted item line.
+     * Default: "▸ " + bold label + description
+     */
+    formatHighlighted?: (item: WordwheelItem) => string;
+    /**
+     * Format a normal item line.
+     * Default: "  " + label + description
+     */
+    formatNormal?: (item: WordwheelItem) => string;
+}
+export declare class Wordwheel {
+    items: WordwheelItem[];
+    index: number;
+    private rl;
+    private dropdown;
+    private getItems;
+    private formatHighlighted;
+    private formatNormal;
+    constructor(options: WordwheelOptions);
+    /** Recompute items based on current readline state. */
+    update(): void;
+    /** Render the current items to the dropdown. */
+    render(): void;
+    /** Clear items and dropdown. */
+    clear(): void;
+    /** Move selection down. Returns true if handled. */
+    moveDown(): boolean;
+    /** Move selection up. Returns true if handled. */
+    moveUp(): boolean;
+    /**
+     * Accept the currently highlighted item.
+     * Sets the readline line to the item's completion text.
+     * Returns the accepted item, or null if nothing was selected.
+     */
+    accept(): WordwheelItem | null;
+    /**
+     * Handle a key event. Returns true if the key was consumed.
+     * Call this from your _ttyWrite override before passing to readline.
+     */
+    handleKey(key: {
+        name?: string;
+    } | undefined): boolean;
+    /**
+     * Handle Enter key — accepts highlighted item into the line
+     * but does NOT consume the key (caller should still pass to readline).
+     */
+    handleEnter(): void;
+}

package/dist/console/wordwheel.js

@@ -0,0 +1,123 @@
+/**
+ * Wordwheel — autocomplete dropdown engine for readline REPLs.
+ *
+ * Manages a list of completion candidates, keyboard navigation (up/down/tab),
+ * and renders them via a Dropdown instance.
+ *
+ * The Wordwheel doesn't know about specific completions — you provide
+ * an ItemProvider callback that returns candidates for the current input.
+ */
+export class Wordwheel {
+    items = [];
+    index = -1;
+    rl;
+    dropdown;
+    getItems;
+    formatHighlighted;
+    formatNormal;
+    constructor(options) {
+        this.rl = options.rl;
+        this.dropdown = options.dropdown;
+        this.getItems = options.getItems;
+        this.formatHighlighted =
+            options.formatHighlighted ??
+                ((item) => `▸ ${item.label.padEnd(14)}${item.description}`);
+        this.formatNormal =
+            options.formatNormal ??
+                ((item) => `  ${item.label.padEnd(14)}${item.description}`);
+    }
+    /** Recompute items based on current readline state. */
+    update() {
+        this.dropdown.clear();
+        const line = this.rl.line ?? "";
+        const cursor = this.rl.cursor ?? 0;
+        this.items = this.getItems(line, cursor);
+        if (this.items.length > 0) {
+            this.index = Math.min(this.index, this.items.length - 1);
+            this.render();
+        }
+        else {
+            this.index = -1;
+        }
+    }
+    /** Render the current items to the dropdown. */
+    render() {
+        const lines = this.items.map((item, i) => i === this.index ? this.formatHighlighted(item) : this.formatNormal(item));
+        this.dropdown.render(lines);
+    }
+    /** Clear items and dropdown. */
+    clear() {
+        this.dropdown.clear();
+        this.items = [];
+        this.index = -1;
+    }
+    /** Move selection down. Returns true if handled. */
+    moveDown() {
+        if (this.items.length === 0)
+            return false;
+        this.index = Math.min(this.index + 1, this.items.length - 1);
+        this.render();
+        return true;
+    }
+    /** Move selection up. Returns true if handled. */
+    moveUp() {
+        if (this.items.length === 0)
+            return false;
+        this.index = Math.max(this.index - 1, -1);
+        this.render();
+        return true;
+    }
+    /**
+     * Accept the currently highlighted item.
+     * Sets the readline line to the item's completion text.
+     * Returns the accepted item, or null if nothing was selected.
+     */
+    accept() {
+        if (this.index < 0 || this.index >= this.items.length)
+            return null;
+        const item = this.items[this.index];
+        this.clear();
+        this.rl.line = item.completion;
+        this.rl.cursor = item.completion.length;
+        this.rl._refreshLine();
+        // Recompute for next level of completion
+        this.update();
+        return item;
+    }
+    /**
+     * Handle a key event. Returns true if the key was consumed.
+     * Call this from your _ttyWrite override before passing to readline.
+     */
+    handleKey(key) {
+        if (!key || this.items.length === 0)
+            return false;
+        if (key.name === "down") {
+            this.moveDown();
+            return true;
+        }
+        if (key.name === "up") {
+            this.moveUp();
+            return true;
+        }
+        if (key.name === "tab" && this.index >= 0) {
+            this.accept();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Handle Enter key — accepts highlighted item into the line
+     * but does NOT consume the key (caller should still pass to readline).
+     */
+    handleEnter() {
+        if (this.items.length > 0 && this.index >= 0) {
+            const item = this.items[this.index];
+            if (item) {
+                this.rl.line = item.completion;
+                this.rl.cursor = item.completion.length;
+            }
+        }
+        this.clear();
+        this.rl._refreshLine();
+    }
+}

package/dist/dropdown.js

@@ -7,24 +7,7 @@
  *   3. We adjust prevRows so the NEXT _refreshLine's moveCursor(0, -prevRows)
  *      moves the cursor back up past the dropdown lines to the prompt
  */
-/** Truncate a string with ANSI codes to `max` visible characters. */
-function truncateAnsi(str, max) {
-    let visible = 0;
-    let i = 0;
-    while (i < str.length && visible < max) {
-        if (str[i] === "\x1b") {
-            // Skip ANSI sequence
-            const end = str.indexOf("m", i);
-            if (end !== -1) {
-                i = end + 1;
-                continue;
-            }
-        }
-        visible++;
-        i++;
-    }
-    return str.slice(0, i);
-}
+import { esc, stripAnsi, truncateAnsi } from "@teammates/consolonia";
 export class Dropdown {
     rl;
     lines = [];
@@ -62,15 +45,15 @@ export class Dropdown {
                 const cols = this.out.columns || 120;
                 let buf = "";
                 for (const line of this.lines) {
-                    buf += "\n" + truncateAnsi(line, cols - 1);
+                    buf += `\n${truncateAnsi(line, cols - 1)}`;
                 }
                 this.out.write(buf);
                 // 3. Move cursor back up to the prompt line and restore column.
                 //    Don't touch prevRows — cursor IS on the prompt line after this.
                 const n = this.lines.length;
-                this.out.write(`\x1b[${n}A`);
+                this.out.write(esc.moveUp(n));
                 const promptText = this.rl._prompt ?? "";
-                const promptLen = promptText.replace(/\x1b\[[0-9;]*m/g, "").length;
+                const promptLen = stripAnsi(promptText).length;
                 const cursor = this.rl.cursor ?? 0;
                 this.out.write(`\x1b[${promptLen + cursor + 1}G`);
             }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export type { TeammateConfig, DailyLog, OwnershipRules, SandboxLevel, HandoffEnvelope, TaskResult, TaskAssignment, OrchestratorEvent, } from "./types.js";
-export type { AgentAdapter, RosterEntry, InstalledService } from "./adapter.js";
+export type { AgentAdapter, InstalledService, RosterEntry } from "./adapter.js";
 export { buildTeammatePrompt, formatHandoffContext } from "./adapter.js";
-export { Registry } from "./registry.js";
-export { Orchestrator, type OrchestratorConfig, type TeammateStatus, } from "./orchestrator.js";
+export { type AgentPreset, CliProxyAdapter, type CliProxyOptions, PRESETS, } from "./adapters/cli-proxy.js";
 export { EchoAdapter } from "./adapters/echo.js";
-export { CliProxyAdapter, PRESETS, type AgentPreset, type CliProxyOptions, } from "./adapters/cli-proxy.js";
+export { Orchestrator, type OrchestratorConfig, type TeammateStatus, } from "./orchestrator.js";
+export { Registry } from "./registry.js";
+export type { DailyLog, HandoffEnvelope, OrchestratorEvent, OwnershipRules, SandboxLevel, TaskAssignment, TaskResult, TeammateConfig, } from "./types.js";

package/dist/index.js

@@ -1,6 +1,6 @@
 // Public API for @teammates/cli
 export { buildTeammatePrompt, formatHandoffContext } from "./adapter.js";
-export { Registry } from "./registry.js";
-export { Orchestrator, } from "./orchestrator.js";
-export { EchoAdapter } from "./adapters/echo.js";
 export { CliProxyAdapter, PRESETS, } from "./adapters/cli-proxy.js";
+export { EchoAdapter } from "./adapters/echo.js";
+export { Orchestrator, } from "./orchestrator.js";
+export { Registry } from "./registry.js";

package/dist/onboard.d.ts

@@ -12,6 +12,30 @@
  * Returns the list of files that were copied.
  */
 export declare function copyTemplateFiles(teammatesDir: string): Promise<string[]>;
+/**
+ * Import teammates from another project's .teammates/ dir.
+ *
+ * Only copies SOUL.md and WISDOM.md per teammate (identity + wisdom carry over).
+ * Creates an empty memory/ dir for each (fresh start — no daily logs or typed memories).
+ * Also copies USER.md if present. Framework files (CROSS-TEAM.md, README.md, etc.)
+ * are project-specific and NOT copied — they get created fresh from the template.
+ *
+ * Skips teammates that already exist in the target (idempotent).
+ * Returns { teammates: string[], files: string[] }.
+ */
+export declare function importTeammates(sourceDir: string, targetDir: string): Promise<{
+    teammates: string[];
+    files: string[];
+}>;
+/**
+ * Build the adaptation prompt for a single imported teammate.
+ * Tells the agent to update ownership patterns, file paths, and boundaries
+ * for the new codebase while preserving identity, principles, and wisdom.
+ *
+ * @param teammatesDir - The .teammates/ directory in the target project
+ * @param teammateName - The name of the teammate to adapt
+ */
+export declare function buildAdaptationPrompt(teammatesDir: string, teammateName: string): Promise<string>;
 /**
  * Load ONBOARDING.md from the project dir, package root, or built-in fallback.
  */