swarm-code 0.1.0

package/dist/ui/banner.js

@@ -0,0 +1,42 @@
+/**
+ * Startup banner — the first thing users see when running swarm.
+ */
+import { getLogLevel, isJsonMode, logKeyValue } from "./log.js";
+import { bold, coral, cyan, dim, isTTY, symbols, termWidth } from "./theme.js";
+const VERSION = "0.1.0";
+/** Render the swarm startup banner. */
+export function renderBanner(config) {
+    if (isJsonMode() || getLogLevel() === "quiet")
+        return;
+    const w = Math.max(Math.min(termWidth(), 60), 24);
+    if (isTTY) {
+        const title = " swarm ";
+        const version = ` v${VERSION} `;
+        const padLen = Math.max(0, w - title.length - version.length - 4);
+        const leftPad = symbols.horizontal.repeat(Math.floor(padLen / 2));
+        const rightPad = symbols.horizontal.repeat(Math.ceil(padLen / 2));
+        process.stderr.write("\n");
+        process.stderr.write(`  ${cyan(`${symbols.topLeft}${leftPad}`)}${bold(coral(title))}${dim(version)}${cyan(`${rightPad}${symbols.topRight}`)}\n`);
+        process.stderr.write(`  ${cyan(symbols.vertLine)}${" ".repeat(Math.max(0, w - 2))}${cyan(symbols.vertLine)}\n`);
+    }
+    else {
+        process.stderr.write(`\nswarm v${VERSION}\n`);
+    }
+    logKeyValue("Directory", config.dir);
+    logKeyValue("Model", `${config.model} ${dim(`(${config.provider})`)}`);
+    logKeyValue("Agent", config.agent);
+    logKeyValue("Routing", config.routing);
+    if (config.memorySize !== undefined && config.memorySize > 0) {
+        logKeyValue("Memory", `${config.memorySize} episodes`);
+    }
+    if (config.dryRun) {
+        logKeyValue("Mode", bold("DRY RUN"));
+    }
+    if (isTTY) {
+        process.stderr.write(`  ${cyan(symbols.vertLine)}${" ".repeat(Math.max(0, w - 2))}${cyan(symbols.vertLine)}\n`);
+        process.stderr.write(`  ${cyan(symbols.bottomLeft)}${cyan(symbols.horizontal.repeat(Math.max(0, w - 2)))}${cyan(symbols.bottomRight)}\n`);
+    }
+    // Query on its own line, slightly emphasized
+    process.stderr.write(`\n  ${dim(symbols.arrow)} ${config.query}\n\n`);
+}
+//# sourceMappingURL=banner.js.map

package/dist/ui/dashboard.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Live thread status dashboard — shows running/queued/completed threads.
+ *
+ * Inspired by Claude Code's collapsed tool results: shows concise status
+ * per thread, color-coded by phase, with elapsed time and file counts.
+ * Uses in-place terminal updates for a live-updating display.
+ */
+/**
+ * Thread dashboard — manages a live-updating display of thread states.
+ * Renders below the spinner line using ANSI cursor movement.
+ */
+export declare class ThreadDashboard {
+    private threads;
+    private pendingTimers;
+    private lastLineCount;
+    private enabled;
+    constructor();
+    /** Update a thread's status. */
+    update(id: string, phase: string, detail?: string, extra?: {
+        task?: string;
+        agent?: string;
+        model?: string;
+        filesChanged?: number;
+    }): void;
+    /** Remove a thread from the dashboard (when done). */
+    complete(id: string, phase: string, detail?: string): void;
+    /** Clear all dashboard output and cancel pending timers. */
+    clear(): void;
+    private render;
+    private clearLines;
+    private buildLines;
+    private formatPhase;
+}

package/dist/ui/dashboard.js

@@ -0,0 +1,151 @@
+/**
+ * Live thread status dashboard — shows running/queued/completed threads.
+ *
+ * Inspired by Claude Code's collapsed tool results: shows concise status
+ * per thread, color-coded by phase, with elapsed time and file counts.
+ * Uses in-place terminal updates for a live-updating display.
+ */
+import { getLogLevel, isJsonMode } from "./log.js";
+import { coral, cyan, dim, green, isTTY, red, stripAnsi, symbols, termWidth, truncate, yellow } from "./theme.js";
+/**
+ * Thread dashboard — manages a live-updating display of thread states.
+ * Renders below the spinner line using ANSI cursor movement.
+ */
+export class ThreadDashboard {
+    threads = new Map();
+    pendingTimers = new Set();
+    lastLineCount = 0;
+    enabled;
+    constructor() {
+        this.enabled = isTTY && !isJsonMode() && getLogLevel() !== "quiet";
+    }
+    /** Update a thread's status. */
+    update(id, phase, detail, extra) {
+        const existing = this.threads.get(id);
+        if (existing) {
+            existing.phase = phase;
+            if (detail)
+                existing.detail = detail;
+            if (extra?.filesChanged !== undefined)
+                existing.filesChanged = extra.filesChanged;
+        }
+        else {
+            this.threads.set(id, {
+                id,
+                task: extra?.task || "",
+                phase,
+                agent: extra?.agent || "",
+                model: extra?.model || "",
+                startedAt: Date.now(),
+                filesChanged: extra?.filesChanged,
+                detail,
+            });
+        }
+        this.render();
+    }
+    /** Remove a thread from the dashboard (when done). */
+    complete(id, phase, detail) {
+        const existing = this.threads.get(id);
+        if (existing) {
+            existing.phase = phase;
+            if (detail)
+                existing.detail = detail;
+        }
+        this.render();
+        // Remove completed/failed threads after a brief display
+        const timer = setTimeout(() => {
+            this.pendingTimers.delete(timer);
+            this.threads.delete(id);
+            this.render();
+        }, 1500);
+        this.pendingTimers.add(timer);
+    }
+    /** Clear all dashboard output and cancel pending timers. */
+    clear() {
+        for (const timer of this.pendingTimers)
+            clearTimeout(timer);
+        this.pendingTimers.clear();
+        if (!this.enabled)
+            return;
+        this.clearLines();
+        this.threads.clear();
+        this.lastLineCount = 0;
+    }
+    render() {
+        if (!this.enabled)
+            return;
+        // Clear previous output
+        this.clearLines();
+        const lines = this.buildLines();
+        if (lines.length === 0) {
+            this.lastLineCount = 0;
+            return;
+        }
+        // Write new lines
+        process.stderr.write(`${lines.join("\n")}\n`);
+        this.lastLineCount = lines.length;
+    }
+    clearLines() {
+        if (this.lastLineCount <= 0)
+            return;
+        // Move up and clear each line
+        for (let i = 0; i < this.lastLineCount; i++) {
+            process.stderr.write("\x1b[1A\x1b[K");
+        }
+    }
+    buildLines() {
+        const w = Math.min(termWidth(), 80);
+        const lines = [];
+        const now = Date.now();
+        for (const [, t] of this.threads) {
+            const elapsed = ((now - t.startedAt) / 1000).toFixed(1);
+            const tag = dim(t.id.slice(0, 8));
+            const phase = this.formatPhase(t.phase);
+            const time = dim(`${elapsed}s`);
+            const task = t.task ? truncate(t.task, 40) : "";
+            const detail = t.detail ? dim(t.detail) : "";
+            let line;
+            if (t.phase === "completed") {
+                const files = t.filesChanged !== undefined ? dim(`${t.filesChanged} files`) : "";
+                line = `    ${tag}  ${phase}  ${time}  ${files}  ${detail}`;
+            }
+            else if (t.phase === "failed" || t.phase === "cancelled") {
+                line = `    ${tag}  ${phase}  ${time}  ${detail}`;
+            }
+            else {
+                line = `    ${tag}  ${phase}  ${time}  ${dim(task)}`;
+            }
+            // Truncate to terminal width
+            if (stripAnsi(line).length > w) {
+                line = line.slice(0, w + (line.length - stripAnsi(line).length) - 1);
+            }
+            lines.push(line);
+        }
+        return lines;
+    }
+    formatPhase(phase) {
+        switch (phase) {
+            case "queued":
+                return dim("queued");
+            case "creating_worktree":
+                return cyan("creating worktree");
+            case "agent_running":
+                return coral("running agent");
+            case "capturing_diff":
+                return cyan("capturing diff");
+            case "compressing":
+                return dim("compressing");
+            case "completed":
+                return green(`${symbols.check} completed`);
+            case "failed":
+                return red(`${symbols.cross} failed`);
+            case "cancelled":
+                return yellow("cancelled");
+            case "retrying":
+                return yellow("retrying");
+            default:
+                return dim(phase);
+        }
+    }
+}
+//# sourceMappingURL=dashboard.js.map

package/dist/ui/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * UI module — barrel export for all UI components.
+ */
+export * from "./banner.js";
+export * from "./dashboard.js";
+export * from "./log.js";
+export * from "./onboarding.js";
+export * from "./spinner.js";
+export * from "./summary.js";
+export * from "./theme.js";

package/dist/ui/index.js

@@ -0,0 +1,11 @@
+/**
+ * UI module — barrel export for all UI components.
+ */
+export * from "./banner.js";
+export * from "./dashboard.js";
+export * from "./log.js";
+export * from "./onboarding.js";
+export * from "./spinner.js";
+export * from "./summary.js";
+export * from "./theme.js";
+//# sourceMappingURL=index.js.map

package/dist/ui/log.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Structured logging — consistent formatting for all terminal output.
+ *
+ * All swarm-code output flows through these functions to ensure consistent
+ * formatting, TTY-awareness, and proper stdout/stderr separation.
+ *
+ * Convention: progress/status → stderr, final answer → stdout.
+ */
+export type LogLevel = "quiet" | "normal" | "verbose";
+export declare function setLogLevel(level: LogLevel): void;
+export declare function setJsonMode(enabled: boolean): void;
+export declare function getLogLevel(): LogLevel;
+export declare function isJsonMode(): boolean;
+/** Standard info line. */
+export declare function logInfo(message: string): void;
+/** Success line with checkmark. */
+export declare function logSuccess(message: string): void;
+/** Warning line — always shown (never suppressed by quiet or JSON mode). */
+export declare function logWarn(message: string): void;
+/** Error line — always shown (never suppressed by quiet or JSON mode). */
+export declare function logError(message: string, hint?: string): void;
+/** Verbose-only line — only shown with --verbose. */
+export declare function logVerbose(message: string): void;
+/** Debug/dim secondary information. */
+export declare function logDim(message: string): void;
+/** Section header. */
+export declare function logHeader(message: string): void;
+/** Horizontal rule separator. */
+export declare function logSeparator(): void;
+/** Key-value pair (for config display). */
+export declare function logKeyValue(key: string, value: string, keyWidth?: number): void;
+/** Thread progress line with color-coded phase. */
+export declare function logThread(threadId: string, phase: string, detail?: string): void;
+/** Router/memory verbose info. */
+export declare function logRouter(message: string): void;
+/** Write the final answer to stdout. */
+export declare function logAnswer(answer: string): void;
+/** Write structured JSON output. */
+export declare function logJson(data: Record<string, unknown>): void;

package/dist/ui/log.js

@@ -0,0 +1,126 @@
+/**
+ * Structured logging — consistent formatting for all terminal output.
+ *
+ * All swarm-code output flows through these functions to ensure consistent
+ * formatting, TTY-awareness, and proper stdout/stderr separation.
+ *
+ * Convention: progress/status → stderr, final answer → stdout.
+ */
+import { bold, cyan, dim, gray, green, hr, magenta, red, symbols, yellow } from "./theme.js";
+let _level = "normal";
+let _jsonMode = false;
+export function setLogLevel(level) {
+    _level = level;
+}
+export function setJsonMode(enabled) {
+    _jsonMode = enabled;
+}
+export function getLogLevel() {
+    return _level;
+}
+export function isJsonMode() {
+    return _jsonMode;
+}
+// ── Core log functions ──────────────────────────────────────────────────────
+/** Standard info line. */
+export function logInfo(message) {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    process.stderr.write(`  ${cyan(symbols.info)} ${message}\n`);
+}
+/** Success line with checkmark. */
+export function logSuccess(message) {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    process.stderr.write(`  ${green(symbols.check)} ${message}\n`);
+}
+/** Warning line — always shown (never suppressed by quiet or JSON mode). */
+export function logWarn(message) {
+    if (_jsonMode) {
+        process.stderr.write(`warning: ${message}\n`);
+        return;
+    }
+    process.stderr.write(`  ${yellow(symbols.warn)} ${message}\n`);
+}
+/** Error line — always shown (never suppressed by quiet or JSON mode). */
+export function logError(message, hint) {
+    if (_jsonMode) {
+        process.stderr.write(`error: ${message}${hint ? ` (${hint})` : ""}\n`);
+        return;
+    }
+    process.stderr.write(`  ${red(symbols.cross)} ${message}\n`);
+    if (hint) {
+        process.stderr.write(`    ${dim(hint)}\n`);
+    }
+}
+/** Verbose-only line — only shown with --verbose. */
+export function logVerbose(message) {
+    if (_level !== "verbose" || _jsonMode)
+        return;
+    process.stderr.write(`  ${gray(message)}\n`);
+}
+/** Debug/dim secondary information. */
+export function logDim(message) {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    process.stderr.write(`  ${dim(message)}\n`);
+}
+/** Section header. */
+export function logHeader(message) {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    process.stderr.write(`\n  ${bold(cyan(message))}\n`);
+}
+/** Horizontal rule separator. */
+export function logSeparator() {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    process.stderr.write(`  ${hr()}\n`);
+}
+/** Key-value pair (for config display). */
+export function logKeyValue(key, value, keyWidth = 12) {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    const paddedKey = key.padEnd(keyWidth);
+    process.stderr.write(`  ${dim(paddedKey)} ${value}\n`);
+}
+/** Thread progress line with color-coded phase. */
+export function logThread(threadId, phase, detail) {
+    if (_level === "quiet" || _jsonMode)
+        return;
+    const tag = dim(`[${threadId.slice(0, 8)}]`);
+    const phaseColor = PHASE_COLORS[phase] || ((s) => s);
+    const suffix = detail ? dim(` ${detail}`) : "";
+    process.stderr.write(`  ${tag} ${phaseColor(phase)}${suffix}\n`);
+}
+/** Router/memory verbose info. */
+export function logRouter(message) {
+    if (_level !== "verbose" || _jsonMode)
+        return;
+    process.stderr.write(`  ${magenta(symbols.arrow)} ${dim(message)}\n`);
+}
+/** Write the final answer to stdout. */
+export function logAnswer(answer) {
+    if (_jsonMode)
+        return;
+    process.stdout.write(answer);
+    if (!answer.endsWith("\n"))
+        process.stdout.write("\n");
+}
+/** Write structured JSON output. */
+export function logJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+// ── Phase color mapping ────────────────────────────────────────────────────
+const PHASE_COLORS = {
+    queued: dim,
+    creating_worktree: cyan,
+    agent_running: bold,
+    capturing_diff: cyan,
+    compressing: dim,
+    completed: green,
+    failed: red,
+    cancelled: yellow,
+    retrying: yellow,
+};
+//# sourceMappingURL=log.js.map

package/dist/ui/onboarding.d.ts

@@ -0,0 +1,14 @@
+/**
+ * First-run onboarding — welcome screen + interactive agent setup wizard.
+ *
+ * Two-column layout: left has greeting + swarm mesh art + version info,
+ * right has tips + environment checks. Then an interactive wizard to:
+ *   1. Pick default coding agent from detected backends
+ *   2. Configure API keys for required providers
+ *   3. Choose default model
+ *   4. Save preferences to ~/.swarm/config.yaml
+ *
+ * Triggered once on first `swarm --dir` invocation. Saves ~/.swarm/.initialized marker.
+ */
+export declare function isFirstRun(): boolean;
+export declare function runOnboarding(): Promise<void>;