@lawrence369/loop-cli 0.1.0

package/dist/bus/subscriber.js

@@ -0,0 +1,187 @@
+import { randomBytes } from "node:crypto";
+import { isProcessAlive } from "../utils/process.js";
+/**
+ * Manages subscriber registration, lifecycle, and metadata.
+ *
+ * Subscriber IDs follow the format `{agentType}:{randomId}`,
+ * e.g. "claude:abc12345".
+ */
+export class SubscriberManager {
+    store;
+    agents = new Map();
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * Load agent data from disk into memory.
+     */
+    async load() {
+        this.agents = await this.store.loadAgents();
+    }
+    /**
+     * Persist agent data to disk.
+     */
+    async save() {
+        await this.store.saveAgents(this.agents);
+    }
+    /**
+     * Register a new agent on the bus.
+     * Returns the generated subscriber ID.
+     */
+    async register(agentType, metadata = {}) {
+        await this.load();
+        const sessionId = randomBytes(4).toString("hex");
+        const subscriberId = `${agentType}:${sessionId}`;
+        const now = new Date().toISOString();
+        // Generate a unique nickname
+        const nickname = metadata.nickname || this.generateNickname(agentType);
+        const agentMeta = {
+            agent_type: agentType,
+            nickname,
+            status: "active",
+            joined_at: now,
+            last_seen: now,
+            pid: metadata.pid ?? process.pid,
+            tty: metadata.tty,
+            tmux_pane: metadata.tmux_pane,
+            launch_mode: metadata.launch_mode ?? "",
+            activity_state: metadata.activity_state ?? "starting",
+            last_activity: metadata.last_activity,
+        };
+        this.agents.set(subscriberId, agentMeta);
+        // Ensure queue directory exists
+        await this.store.ensureQueue(subscriberId);
+        await this.save();
+        return subscriberId;
+    }
+    /**
+     * Unregister an agent, marking it as inactive.
+     */
+    async unregister(subscriberId) {
+        await this.load();
+        const meta = this.agents.get(subscriberId);
+        if (!meta)
+            return;
+        meta.status = "inactive";
+        meta.last_seen = new Date().toISOString();
+        await this.save();
+    }
+    /**
+     * Rename a subscriber's nickname.
+     */
+    async rename(subscriberId, nickname) {
+        await this.load();
+        const meta = this.agents.get(subscriberId);
+        if (!meta) {
+            throw new Error(`Subscriber "${subscriberId}" not found`);
+        }
+        // Check for nickname conflicts
+        for (const [id, other] of this.agents) {
+            if (id !== subscriberId && other.nickname === nickname && other.status === "active") {
+                throw new Error(`Nickname "${nickname}" is already in use by ${id}`);
+            }
+        }
+        meta.nickname = nickname;
+        await this.save();
+    }
+    /**
+     * Update specific metadata fields for a subscriber.
+     */
+    async updateMetadata(subscriberId, updates) {
+        await this.load();
+        const meta = this.agents.get(subscriberId);
+        if (!meta) {
+            throw new Error(`Subscriber "${subscriberId}" not found`);
+        }
+        if (updates.status !== undefined)
+            meta.status = updates.status;
+        if (updates.last_seen !== undefined)
+            meta.last_seen = updates.last_seen;
+        if (updates.pid !== undefined)
+            meta.pid = updates.pid;
+        if (updates.tty !== undefined)
+            meta.tty = updates.tty;
+        if (updates.tmux_pane !== undefined)
+            meta.tmux_pane = updates.tmux_pane;
+        if (updates.launch_mode !== undefined)
+            meta.launch_mode = updates.launch_mode;
+        if (updates.activity_state !== undefined)
+            meta.activity_state = updates.activity_state;
+        if (updates.last_activity !== undefined)
+            meta.last_activity = updates.last_activity;
+        if (updates.nickname !== undefined)
+            meta.nickname = updates.nickname;
+        await this.save();
+    }
+    /**
+     * Clean up subscribers whose processes are no longer alive.
+     * Returns the list of subscriber IDs that were marked inactive.
+     */
+    async cleanupInactive() {
+        await this.load();
+        const cleaned = [];
+        for (const [id, meta] of this.agents) {
+            if (meta.status !== "active")
+                continue;
+            // If the agent has a PID, check if it's still alive
+            if (meta.pid > 0 && !isProcessAlive(meta.pid)) {
+                meta.status = "inactive";
+                meta.last_seen = new Date().toISOString();
+                cleaned.push(id);
+            }
+        }
+        if (cleaned.length > 0) {
+            await this.save();
+        }
+        return cleaned;
+    }
+    /**
+     * List all agents (both active and inactive).
+     */
+    async list() {
+        await this.load();
+        return new Map(this.agents);
+    }
+    /**
+     * Get metadata for a specific subscriber.
+     */
+    async get(subscriberId) {
+        await this.load();
+        return this.agents.get(subscriberId);
+    }
+    /**
+     * Generate a unique auto-nickname for the given agent type.
+     * Format: {prefix}-{N} where N is the lowest unused integer.
+     */
+    generateNickname(agentType) {
+        const prefix = this.nicknamePrefix(agentType);
+        const usedNicknames = new Set();
+        for (const meta of this.agents.values()) {
+            if (meta.status === "active" && meta.nickname) {
+                usedNicknames.add(meta.nickname);
+            }
+        }
+        let idx = 1;
+        while (usedNicknames.has(`${prefix}-${idx}`)) {
+            idx++;
+        }
+        return `${prefix}-${idx}`;
+    }
+    /**
+     * Get the nickname prefix for a given agent type.
+     */
+    nicknamePrefix(agentType) {
+        switch (agentType) {
+            case "claude":
+            case "claude-code":
+                return "claude";
+            case "gemini":
+                return "gemini";
+            case "codex":
+                return "codex";
+            default:
+                return agentType || "agent";
+        }
+    }
+}
+//# sourceMappingURL=subscriber.js.map

package/dist/config/index.d.ts

@@ -0,0 +1,8 @@
+import { type LoopConfig } from "./schema.js";
+export { type LoopConfig, type EngineName, type ExecutionMode, DEFAULT_CONFIG, validateConfig } from "./schema.js";
+/**
+ * Load configuration with cascade:
+ * DEFAULT_CONFIG -> ~/.loop/config.json -> <cwd>/.loop/config.json -> env vars
+ */
+export declare function loadConfig(cwd?: string): Promise<LoopConfig>;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.js

@@ -0,0 +1,72 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { DEFAULT_CONFIG, validateConfig, } from "./schema.js";
+export { DEFAULT_CONFIG, validateConfig } from "./schema.js";
+function loadJsonSafe(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (typeof parsed === "object" && parsed !== null) {
+            return parsed;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+function applyEnvOverrides(config) {
+    const result = { ...config };
+    const executor = process.env.LOOP_EXECUTOR;
+    if (executor === "claude" || executor === "gemini" || executor === "codex") {
+        result.defaultExecutor = executor;
+    }
+    const reviewer = process.env.LOOP_REVIEWER;
+    if (reviewer === "claude" || reviewer === "gemini" || reviewer === "codex") {
+        result.defaultReviewer = reviewer;
+    }
+    const iterations = process.env.LOOP_ITERATIONS;
+    if (iterations) {
+        const n = parseInt(iterations, 10);
+        if (!isNaN(n) && n >= 1 && n <= 20) {
+            result.maxIterations = n;
+        }
+    }
+    const threshold = process.env.LOOP_THRESHOLD;
+    if (threshold) {
+        const n = parseInt(threshold, 10);
+        if (!isNaN(n) && n >= 1 && n <= 10) {
+            result.threshold = n;
+        }
+    }
+    const mode = process.env.LOOP_MODE;
+    if (mode === "auto" || mode === "manual") {
+        result.mode = mode;
+    }
+    return result;
+}
+/**
+ * Load configuration with cascade:
+ * DEFAULT_CONFIG -> ~/.loop/config.json -> <cwd>/.loop/config.json -> env vars
+ */
+export async function loadConfig(cwd) {
+    // Start with defaults
+    let merged = { ...DEFAULT_CONFIG };
+    // Layer 1: Global config (~/.loop/config.json)
+    const globalPath = join(homedir(), ".loop", "config.json");
+    const globalConfig = loadJsonSafe(globalPath);
+    merged = { ...merged, ...globalConfig };
+    // Layer 2: Project config (<cwd>/.loop/config.json)
+    if (cwd) {
+        const projectPath = join(cwd, ".loop", "config.json");
+        const projectConfig = loadJsonSafe(projectPath);
+        merged = { ...merged, ...projectConfig };
+    }
+    // Validate and normalize
+    let config = validateConfig(merged);
+    // Layer 3: Environment variable overrides
+    config = applyEnvOverrides(config);
+    return config;
+}
+//# sourceMappingURL=index.js.map

package/dist/config/schema.d.ts

@@ -0,0 +1,18 @@
+export type EngineName = "claude" | "gemini" | "codex";
+export type ExecutionMode = "auto" | "manual";
+export type LaunchMode = "terminal" | "tmux" | "iterm2" | "pty" | "auto";
+export interface LoopConfig {
+    defaultExecutor: EngineName;
+    defaultReviewer: EngineName;
+    maxIterations: number;
+    threshold: number;
+    mode: ExecutionMode;
+    launchMode: LaunchMode;
+    autoResume: boolean;
+    skillsDir?: string;
+    verbose: boolean;
+}
+export declare const ENGINE_NAMES: readonly EngineName[];
+export declare const DEFAULT_CONFIG: LoopConfig;
+export declare function validateConfig(raw: unknown): LoopConfig;
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.js

@@ -0,0 +1,58 @@
+export const ENGINE_NAMES = ["claude", "gemini", "codex"];
+export const DEFAULT_CONFIG = {
+    defaultExecutor: "claude",
+    defaultReviewer: "gemini",
+    maxIterations: 3,
+    threshold: 9,
+    mode: "manual",
+    launchMode: "auto",
+    autoResume: false,
+    verbose: false,
+};
+function isEngineName(value) {
+    return typeof value === "string" && ENGINE_NAMES.includes(value);
+}
+function isExecutionMode(value) {
+    return value === "auto" || value === "manual";
+}
+function isLaunchMode(value) {
+    return (value === "terminal" ||
+        value === "tmux" ||
+        value === "iterm2" ||
+        value === "pty" ||
+        value === "auto");
+}
+export function validateConfig(raw) {
+    if (typeof raw !== "object" || raw === null) {
+        return { ...DEFAULT_CONFIG };
+    }
+    const obj = raw;
+    return {
+        defaultExecutor: isEngineName(obj.defaultExecutor)
+            ? obj.defaultExecutor
+            : DEFAULT_CONFIG.defaultExecutor,
+        defaultReviewer: isEngineName(obj.defaultReviewer)
+            ? obj.defaultReviewer
+            : DEFAULT_CONFIG.defaultReviewer,
+        maxIterations: typeof obj.maxIterations === "number" &&
+            obj.maxIterations >= 1 &&
+            obj.maxIterations <= 20
+            ? obj.maxIterations
+            : DEFAULT_CONFIG.maxIterations,
+        threshold: typeof obj.threshold === "number" &&
+            obj.threshold >= 1 &&
+            obj.threshold <= 10
+            ? obj.threshold
+            : DEFAULT_CONFIG.threshold,
+        mode: isExecutionMode(obj.mode) ? obj.mode : DEFAULT_CONFIG.mode,
+        launchMode: isLaunchMode(obj.launchMode)
+            ? obj.launchMode
+            : DEFAULT_CONFIG.launchMode,
+        autoResume: typeof obj.autoResume === "boolean"
+            ? obj.autoResume
+            : DEFAULT_CONFIG.autoResume,
+        skillsDir: typeof obj.skillsDir === "string" ? obj.skillsDir : undefined,
+        verbose: typeof obj.verbose === "boolean" ? obj.verbose : DEFAULT_CONFIG.verbose,
+    };
+}
+//# sourceMappingURL=schema.js.map

package/dist/core/conversation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Multi-turn conversation session with an AI engine.
+ *
+ * Ported from iterloop's conversation.ts. Runs an interactive PTY session
+ * with idle detection, mode toggling, and user-controlled continuation.
+ */
+import type { Engine } from "./engine.js";
+export type ExecutionMode = "auto" | "manual";
+export interface ConversationOptions {
+    engine: Engine;
+    initialPrompt: string;
+    cwd: string;
+    verbose: boolean;
+    mode: {
+        current: ExecutionMode;
+    };
+    passthroughArgs?: string[];
+}
+export interface ConversationResult {
+    finalOutput: string;
+    duration_ms: number;
+    bytes_received: number;
+}
+/**
+ * Run a multi-turn conversation with an AI engine.
+ *
+ * In **auto** mode the PTY session runs to completion (idle detection / silence
+ * timeout) and returns immediately.
+ *
+ * In **manual** mode the user is prompted after each turn to continue, switch
+ * modes, or submit for review.
+ */
+export declare function runConversation(opts: ConversationOptions): Promise<ConversationResult>;
+//# sourceMappingURL=conversation.d.ts.map

package/dist/core/conversation.js

@@ -0,0 +1,289 @@
+/**
+ * Multi-turn conversation session with an AI engine.
+ *
+ * Ported from iterloop's conversation.ts. Runs an interactive PTY session
+ * with idle detection, mode toggling, and user-controlled continuation.
+ */
+import { dim, formatBytes, brandColor } from "../ui/colors.js";
+// ── Idle detection constants ─────────────────────────
+/** Time to wait after detecting idle prompt before auto-proceeding (ms) */
+const IDLE_DEBOUNCE_MS = 2000;
+/** Silence timeout: no output for this long = likely idle (ms) */
+const SILENCE_TIMEOUT_AUTO_MS = 30_000; // auto mode: 30s (executor may run long ops)
+const SILENCE_TIMEOUT_MANUAL_MS = 5_000; // manual mode: 5s
+/** Global PTY session timeout (ms) — prevents hanging forever */
+const PTY_GLOBAL_TIMEOUT_MS = 3_600_000; // 1 hour
+const TERMINAL_RESET = "\x1b[0m\x1b[?25h\x1b[?2026l\x1b[?1049l\x1b[?1047l\x1b[?47l";
+// ── Renderer (inline, minimal) ───────────────────────
+class PtyRenderer {
+    color;
+    engineLabel;
+    receivedBytes = 0;
+    started = false;
+    endedWithLineBreak = true;
+    constructor(engineName, engineLabel) {
+        this.color = brandColor(engineName);
+        this.engineLabel = engineLabel;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        const header = this.color(`  \u250C\u2500 \u25A0 ${this.engineLabel} (executor) ${"\u2500".repeat(Math.max(0, 44 - this.engineLabel.length))}\u2510`);
+        console.log(header);
+        console.log(this.color("  \u2502"));
+        this.endedWithLineBreak = true;
+    }
+    write(data) {
+        if (!this.started)
+            return;
+        this.receivedBytes += Buffer.byteLength(data);
+        process.stdout.write(data);
+        this.endedWithLineBreak = /(?:\r\n|\r|\n)$/.test(data);
+    }
+    stop(stats) {
+        if (!this.started)
+            return;
+        this.started = false;
+        // Restore common terminal modes in case the CLI was killed mid-TUI
+        process.stdout.write(TERMINAL_RESET);
+        if (!this.endedWithLineBreak) {
+            process.stdout.write("\r\n");
+        }
+        console.log(this.color("  \u2502"));
+        const statsText = `\u2713 done ${dim(`(${stats.elapsed}, ${stats.bytes})`)}`;
+        const footer = this.color(`  \u2514${"\u2500".repeat(42)}`) +
+            ` ${statsText} ` +
+            this.color("\u2500\u2518");
+        console.log(footer);
+    }
+    get totalBytes() {
+        return this.receivedBytes;
+    }
+}
+function startKeystrokeHandler(opts) {
+    const { session, mode, onDone, onCancel } = opts;
+    const isTTY = !!process.stdin.isTTY;
+    if (isTTY)
+        process.stdin.setRawMode(true);
+    process.stdin.resume();
+    let lastCtrlC = 0;
+    function onData(data) {
+        if (!session.isAlive)
+            return;
+        const str = typeof data === "string" ? data : data.toString("utf8");
+        // Shift+Tab → toggle mode
+        if (str === "\x1b[Z") {
+            mode.current = mode.current === "auto" ? "manual" : "auto";
+            return;
+        }
+        // Ctrl+D → done
+        if (str === "\x04") {
+            onDone();
+            return;
+        }
+        // Ctrl+C → double-press = cancel, single = forward
+        if (str === "\x03") {
+            const now = Date.now();
+            if (now - lastCtrlC < 500) {
+                onCancel();
+                return;
+            }
+            lastCtrlC = now;
+            session.write(str);
+            return;
+        }
+        session.write(str);
+    }
+    process.stdin.on("data", onData);
+    return () => {
+        process.stdin.removeListener("data", onData);
+        if (isTTY)
+            process.stdin.setRawMode(false);
+        process.stdin.pause();
+    };
+}
+// ── PTY-based interactive session ────────────────────
+async function runPtySession(engine, initialPrompt, opts) {
+    const globalStart = Date.now();
+    // Set up renderer before spawning the PTY so the first frame is not missed
+    const renderer = new PtyRenderer(engine.name, engine.label);
+    renderer.start();
+    // Create PTY session via engine.interactive()
+    const session = engine.interactive({
+        cwd: opts.cwd,
+        passthroughArgs: opts.passthroughArgs,
+        onData(data) {
+            renderer.write(data);
+        },
+    });
+    return new Promise((resolve, reject) => {
+        let done = false;
+        let idleTimer = null;
+        let silenceTimer = null;
+        let globalTimer = null;
+        let promptSent = false;
+        function stopRenderer() {
+            const elapsed = `${((Date.now() - globalStart) / 1000).toFixed(1)}s`;
+            renderer.stop({ elapsed, bytes: formatBytes(renderer.totalBytes) });
+        }
+        function finish() {
+            if (done)
+                return;
+            done = true;
+            // Clean up timers
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (silenceTimer)
+                clearTimeout(silenceTimer);
+            if (globalTimer)
+                clearTimeout(globalTimer);
+            // Stop keystroke forwarding
+            cleanupKeystrokes();
+            // Kill session if still alive
+            session.kill();
+            // Stop renderer (prints footer)
+            stopRenderer();
+            // Capture clean output for reviewer
+            const output = session.getCleanOutput();
+            const durationMs = Date.now() - globalStart;
+            resolve({ output, bytes: renderer.totalBytes, durationMs });
+        }
+        function cancel(message = "Cancelled by user") {
+            if (done)
+                return;
+            done = true;
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            if (silenceTimer)
+                clearTimeout(silenceTimer);
+            if (globalTimer)
+                clearTimeout(globalTimer);
+            cleanupKeystrokes();
+            session.kill();
+            stopRenderer();
+            reject(new Error(message));
+        }
+        // Global timeout — prevent PTY session from hanging forever
+        globalTimer = setTimeout(() => {
+            if (!done) {
+                cancel("PTY session timed out (1 hour limit)");
+            }
+        }, PTY_GLOBAL_TIMEOUT_MS);
+        // Start keystroke forwarding (raw mode -> PTY)
+        const cleanupKeystrokes = startKeystrokeHandler({
+            session,
+            mode: opts.mode,
+            onDone: finish,
+            onCancel: cancel,
+        });
+        // ── Idle detection ──
+        function resetSilenceTimer() {
+            if (silenceTimer)
+                clearTimeout(silenceTimer);
+            if (done)
+                return;
+            const silenceTimeoutMs = opts.mode.current === "auto"
+                ? SILENCE_TIMEOUT_AUTO_MS
+                : SILENCE_TIMEOUT_MANUAL_MS;
+            silenceTimer = setTimeout(() => {
+                if (done || !promptSent)
+                    return;
+                // Silence = CLI likely idle, proceed for both modes
+                finish();
+            }, silenceTimeoutMs);
+        }
+        // On PTY idle event (prompt detected)
+        session.on("idle", () => {
+            if (done)
+                return;
+            if (!promptSent) {
+                // First idle = CLI is ready for input, send the task
+                promptSent = true;
+                session.sendLine(initialPrompt);
+                resetSilenceTimer();
+                return;
+            }
+            // Subsequent idle = CLI finished responding
+            // Both modes: finish PTY session with debounce
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => {
+                if (!done)
+                    finish();
+            }, IDLE_DEBOUNCE_MS);
+        });
+        // Reset silence timer on each output chunk
+        session.on("pty-data", () => {
+            resetSilenceTimer();
+            // Cancel idle debounce if more output arrives
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
+        });
+        // Handle PTY process exit
+        session.on("exit", () => {
+            if (!done) {
+                // Small delay to collect any final output
+                setTimeout(() => finish(), 200);
+            }
+        });
+        // Fallback: if no idle event fires within 10s, send prompt anyway
+        setTimeout(() => {
+            if (!promptSent && !done) {
+                promptSent = true;
+                session.sendLine(initialPrompt);
+                resetSilenceTimer();
+            }
+        }, 10_000);
+        // Handle terminal resize
+        const onResize = () => {
+            if (!done && session.isAlive) {
+                const cols = process.stdout.columns || 80;
+                const rows = process.stdout.rows || 24;
+                session.resize(cols, rows);
+            }
+        };
+        process.stdout.on("resize", onResize);
+        // Clean up resize handler on session exit
+        session.on("exit", () => {
+            process.stdout.removeListener("resize", onResize);
+        });
+    });
+}
+// ── Main conversation loop ───────────────────────────
+/**
+ * Run a multi-turn conversation with an AI engine.
+ *
+ * In **auto** mode the PTY session runs to completion (idle detection / silence
+ * timeout) and returns immediately.
+ *
+ * In **manual** mode the user is prompted after each turn to continue, switch
+ * modes, or submit for review.
+ */
+export async function runConversation(opts) {
+    const { engine, initialPrompt, cwd, verbose, mode, passthroughArgs } = opts;
+    if (mode.current === "manual") {
+        console.log(dim("  Ctrl+D to submit for review, double Ctrl+C to abort\n"));
+    }
+    // Run first interactive PTY session
+    const { output, bytes, durationMs } = await runPtySession(engine, initialPrompt, { cwd, verbose, mode, passthroughArgs });
+    // Auto mode: done, submit to reviewer
+    if (mode.current === "auto") {
+        return {
+            finalOutput: output,
+            duration_ms: durationMs,
+            bytes_received: bytes,
+        };
+    }
+    // Manual mode: the user can continue interacting or submit
+    // For now, return the first session output. Full multi-turn manual flow
+    // (promptUser loop) is handled at a higher layer.
+    return {
+        finalOutput: output,
+        duration_ms: durationMs,
+        bytes_received: bytes,
+    };
+}
+//# sourceMappingURL=conversation.js.map