@lawrence369/loop-cli 0.1.0

package/dist/core/engine.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Engine abstraction — unified interface for Claude, Gemini, and Codex CLIs.
+ *
+ * Ported from iterloop's engine.ts with adaptations for loop-cli:
+ * - Brand `color` property on each engine
+ * - Timeout parameter on RunOptions
+ * - ESM imports with .js extensions
+ */
+import { type PtySession, type PtySessionOptions } from "../agent/pty-session.js";
+export type { PtySession, PtySessionOptions };
+export type EngineName = "claude" | "gemini" | "codex";
+export declare const ENGINE_NAMES: EngineName[];
+export interface RunOptions {
+    cwd?: string;
+    verbose?: boolean;
+    onData?: (chunk: string) => void;
+    onStatus?: (status: string) => void;
+    passthroughArgs?: string[];
+    timeout?: number;
+}
+export interface InteractiveOptions {
+    cwd?: string;
+    args?: string[];
+    cols?: number;
+    rows?: number;
+    env?: Record<string, string>;
+    onData?: (data: string) => void;
+    onExit?: (exitCode: number) => void;
+    passthroughArgs?: string[];
+}
+export interface Engine {
+    name: EngineName;
+    label: string;
+    color: (s: string) => string;
+    checkVersion(): string;
+    run(prompt: string, opts: RunOptions): Promise<string>;
+    interactive(opts: InteractiveOptions): PtySession;
+}
+export declare function createEngine(name: EngineName): Engine;
+//# sourceMappingURL=engine.d.ts.map

package/dist/core/engine.js

@@ -0,0 +1,288 @@
+/**
+ * Engine abstraction — unified interface for Claude, Gemini, and Codex CLIs.
+ *
+ * Ported from iterloop's engine.ts with adaptations for loop-cli:
+ * - Brand `color` property on each engine
+ * - Timeout parameter on RunOptions
+ * - ESM imports with .js extensions
+ */
+import { spawn, execFileSync } from "node:child_process";
+import { stripAnsi } from "../utils/ansi.js";
+import { createPtySession } from "../agent/pty-session.js";
+import { claude as claudeColor, gemini as geminiColor, codex as codexColor } from "../ui/colors.js";
+const DEFAULT_TIMEOUT = 3_600_000; // 1 hour
+export const ENGINE_NAMES = ["claude", "gemini", "codex"];
+// ── Claude ───────────────────────────────────────────
+function createClaude() {
+    return {
+        name: "claude",
+        label: "Claude",
+        color: claudeColor,
+        checkVersion() {
+            return execFileSync("claude", ["--version"], { encoding: "utf-8" }).trim();
+        },
+        run(prompt, opts) {
+            // Use stream-json when streaming callbacks are provided (executor mode)
+            if (opts.onData || opts.onStatus) {
+                return spawnClaudeStream(prompt, opts);
+            }
+            return spawnEngine("claude", ["-p", prompt, ...(opts.passthroughArgs ?? [])], opts);
+        },
+        interactive(opts) {
+            return createPtySession({
+                cmd: "claude",
+                args: [...(opts.passthroughArgs ?? [])],
+                cwd: opts.cwd ?? process.cwd(),
+                env: opts.env,
+                engineName: "claude",
+                onData: opts.onData,
+                onExit: opts.onExit,
+            });
+        },
+    };
+}
+// ── Gemini ───────────────────────────────────────────
+function createGemini() {
+    return {
+        name: "gemini",
+        label: "Gemini",
+        color: geminiColor,
+        checkVersion() {
+            return execFileSync("gemini", ["--version"], { encoding: "utf-8" }).trim();
+        },
+        run(prompt, opts) {
+            return spawnEngine("gemini", ["-p", prompt, ...(opts.passthroughArgs ?? [])], opts);
+        },
+        interactive(opts) {
+            return createPtySession({
+                cmd: "gemini",
+                args: [...(opts.passthroughArgs ?? [])],
+                cwd: opts.cwd ?? process.cwd(),
+                env: opts.env,
+                engineName: "gemini",
+                onData: opts.onData,
+                onExit: opts.onExit,
+            });
+        },
+    };
+}
+// ── Codex ────────────────────────────────────────────
+function createCodex() {
+    return {
+        name: "codex",
+        label: "Codex",
+        color: codexColor,
+        checkVersion() {
+            return execFileSync("codex", ["--version"], { encoding: "utf-8" }).trim();
+        },
+        run(prompt, opts) {
+            const args = ["exec", "--full-auto", "--skip-git-repo-check"];
+            if (opts.cwd) {
+                args.push("-C", opts.cwd);
+            }
+            args.push(...(opts.passthroughArgs ?? []), prompt);
+            return spawnEngine("codex", args, opts);
+        },
+        interactive(opts) {
+            return createPtySession({
+                cmd: "codex",
+                args: [...(opts.passthroughArgs ?? [])],
+                cwd: opts.cwd ?? process.cwd(),
+                env: opts.env,
+                engineName: "codex",
+                onData: opts.onData,
+                onExit: opts.onExit,
+            });
+        },
+    };
+}
+// ── Factory ──────────────────────────────────────────
+export function createEngine(name) {
+    switch (name) {
+        case "claude":
+            return createClaude();
+        case "gemini":
+            return createGemini();
+        case "codex":
+            return createCodex();
+    }
+}
+// ── Shared spawn helper ──────────────────────────────
+function spawnEngine(cmd, args, opts) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args, {
+            cwd: opts.cwd ?? process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, FORCE_COLOR: "0" },
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeoutMs = opts.timeout ?? DEFAULT_TIMEOUT;
+        const timer = setTimeout(() => {
+            proc.kill("SIGTERM");
+            reject(new Error(`${cmd} timed out (${Math.round(timeoutMs / 60_000)} minute limit)`));
+        }, timeoutMs);
+        proc.stdout.on("data", (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            if (opts.onData) {
+                opts.onData(text);
+            }
+            else if (opts.verbose) {
+                process.stdout.write(text);
+            }
+        });
+        proc.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            if (opts.verbose) {
+                process.stderr.write(text);
+            }
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`${cmd} exited with code ${code}\n${stderr}`));
+            }
+            else {
+                resolve(stripAnsi(stdout).trim());
+            }
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+// ── Claude stream-json helpers ───────────────────────
+function summarizeToolInput(name, input) {
+    if (input.file_path)
+        return `${name} ${input.file_path}`;
+    if (input.pattern)
+        return `${name} ${input.pattern}`;
+    if (input.command) {
+        const cmd = String(input.command);
+        return `${name} ${cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd}`;
+    }
+    if (input.query)
+        return `${name} ${input.query}`;
+    return name;
+}
+function spawnClaudeStream(prompt, opts) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--include-partial-messages",
+            "--verbose",
+            ...(opts.passthroughArgs ?? []),
+        ];
+        const proc = spawn("claude", args, {
+            cwd: opts.cwd ?? process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, FORCE_COLOR: "0" },
+        });
+        let resultText = "";
+        let rawStdout = "";
+        let stderr = "";
+        let lineBuffer = "";
+        const timeoutMs = opts.timeout ?? DEFAULT_TIMEOUT;
+        const timer = setTimeout(() => {
+            proc.kill("SIGTERM");
+            reject(new Error(`Claude CLI timed out (${Math.round(timeoutMs / 60_000)} minute limit)`));
+        }, timeoutMs);
+        proc.stdout.on("data", (chunk) => {
+            const text = chunk.toString();
+            rawStdout += text;
+            lineBuffer += text;
+            // Process complete JSON lines
+            let nlIdx;
+            while ((nlIdx = lineBuffer.indexOf("\n")) !== -1) {
+                const line = lineBuffer.slice(0, nlIdx).trim();
+                lineBuffer = lineBuffer.slice(nlIdx + 1);
+                if (!line)
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    handleStreamEvent(event, opts);
+                }
+                catch {
+                    // Non-JSON line — forward as plain text
+                    opts.onData?.(line + "\n");
+                }
+            }
+        });
+        proc.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            if (opts.verbose) {
+                process.stderr.write(text);
+            }
+        });
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            if (code !== 0) {
+                reject(new Error(`Claude exited with code ${code}\n${stderr}`));
+            }
+            else {
+                // Use parsed result if available, fall back to raw stdout
+                resolve(resultText || stripAnsi(rawStdout).trim());
+            }
+        });
+        proc.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        function handleStreamEvent(event, runOpts) {
+            switch (event.type) {
+                case "system":
+                    runOpts.onStatus?.("session started");
+                    break;
+                // Claude CLI wraps API streaming events inside {"type":"stream_event","event":{...}}
+                case "stream_event": {
+                    const inner = event.event;
+                    if (!inner)
+                        break;
+                    if (inner.type === "content_block_start") {
+                        const block = inner.content_block;
+                        if (block?.type === "tool_use" && block.name) {
+                            runOpts.onStatus?.(block.name);
+                        }
+                        else if (block?.type === "thinking") {
+                            runOpts.onStatus?.("Thinking...");
+                        }
+                    }
+                    else if (inner.type === "content_block_delta") {
+                        const delta = inner.delta;
+                        if (delta?.type === "text_delta" && delta.text) {
+                            runOpts.onData?.(delta.text);
+                        }
+                        // thinking_delta — keep status as "Thinking..."
+                    }
+                    break;
+                }
+                case "assistant": {
+                    // Complete assistant message — extract tool use info for status
+                    const content = event.message?.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === "tool_use" && block.name) {
+                                runOpts.onStatus?.(summarizeToolInput(block.name, block.input ?? {}));
+                            }
+                        }
+                    }
+                    break;
+                }
+                case "result": {
+                    if (typeof event.result === "string") {
+                        resultText = event.result;
+                    }
+                    break;
+                }
+            }
+        }
+    });
+}
+//# sourceMappingURL=engine.js.map

package/dist/core/loop.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Main iteration loop — orchestrates executor/reviewer cycles.
+ *
+ * Ported from iterloop's loop.ts with:
+ * - scoring.ts for approval logic (not inline check)
+ * - protocol.ts for message creation/parsing
+ * - Shared-plan integration (import from plan/shared-plan.ts)
+ * - Configurable threshold
+ */
+import type { Engine } from "./engine.js";
+import type { ExecutionMode } from "./conversation.js";
+import { type LoopMessage } from "./protocol.js";
+export interface LoopOptions {
+    task: string;
+    maxIterations: number;
+    executor: Engine;
+    reviewer: Engine;
+    cwd: string;
+    verbose: boolean;
+    mode: {
+        current: ExecutionMode;
+    };
+    passthroughArgs?: string[];
+    threshold: number;
+}
+export interface LoopResult {
+    iterations: number;
+    approved: boolean;
+    finalOutput: string;
+    history: LoopMessage[];
+}
+export declare function runLoop(options: LoopOptions): Promise<LoopResult>;
+//# sourceMappingURL=loop.d.ts.map

package/dist/core/loop.js

@@ -0,0 +1,209 @@
+/**
+ * Main iteration loop — orchestrates executor/reviewer cycles.
+ *
+ * Ported from iterloop's loop.ts with:
+ * - scoring.ts for approval logic (not inline check)
+ * - protocol.ts for message creation/parsing
+ * - Shared-plan integration (import from plan/shared-plan.ts)
+ * - Configurable threshold
+ */
+import { runConversation } from "./conversation.js";
+import { createExecutorMessage, parseReviewerOutput, formatForReviewer, } from "./protocol.js";
+import { evaluateReview } from "./scoring.js";
+import { bold, dim, success, warn, brandColor } from "../ui/colors.js";
+const NO_OP_PLAN = {
+    initSharedPlan: () => { },
+    updateSharedPlan: () => { },
+    getExecutorContext: () => "",
+    getReviewerContext: () => "",
+};
+// Lazy-loaded promise — awaited before first use in runLoop()
+let _planModulePromise = null;
+async function loadPlanModule() {
+    if (!_planModulePromise) {
+        _planModulePromise = (async () => {
+            try {
+                const planPath = ["../plan", "shared-plan.js"].join("/");
+                const mod = (await import(planPath));
+                return {
+                    initSharedPlan: typeof mod.initSharedPlan === "function"
+                        ? mod.initSharedPlan : NO_OP_PLAN.initSharedPlan,
+                    updateSharedPlan: typeof mod.updateSharedPlan === "function"
+                        ? mod.updateSharedPlan : NO_OP_PLAN.updateSharedPlan,
+                    getExecutorContext: typeof mod.getExecutorContext === "function"
+                        ? mod.getExecutorContext : NO_OP_PLAN.getExecutorContext,
+                    getReviewerContext: typeof mod.getReviewerContext === "function"
+                        ? mod.getReviewerContext : NO_OP_PLAN.getReviewerContext,
+                };
+            }
+            catch {
+                return NO_OP_PLAN;
+            }
+        })();
+    }
+    return _planModulePromise;
+}
+// ── Helpers ──────────────────────────────────────────
+function elapsed(startMs) {
+    const sec = ((Date.now() - startMs) / 1000).toFixed(1);
+    return dim(`(${sec}s)`);
+}
+function reviewerHeader(engine) {
+    const color = engine.color;
+    return color(`  \u250C\u2500 \u25A0 ${engine.label} (reviewer) ${"\u2500".repeat(Math.max(0, 44 - engine.label.length))}\u2510`);
+}
+function reviewerFooter(engine, timeStr) {
+    const color = engine.color;
+    return color(`  \u2514${"\u2500".repeat(42)} \u2713 done ${timeStr} \u2500\u2518`);
+}
+// ── Main loop ────────────────────────────────────────
+export async function runLoop(options) {
+    const { task, maxIterations, executor, reviewer, cwd, verbose, mode, passthroughArgs, threshold, } = options;
+    const revColor = brandColor(reviewer.name);
+    const history = [];
+    const scoringConfig = {
+        threshold,
+        requireExplicitApproval: false,
+    };
+    // Load shared plan module (awaited — no race condition)
+    const plan = await loadPlanModule();
+    plan.initSharedPlan(cwd, task);
+    let executorOutput = "";
+    let reviewerFeedback = "";
+    for (let i = 1; i <= maxIterations; i++) {
+        console.log(bold(`\n  ${"\u2550".repeat(12)} Iteration ${i} / ${maxIterations} ${"\u2550".repeat(12)}\n`));
+        // ── Build executor prompt ──
+        let initialPrompt;
+        if (i === 1) {
+            initialPrompt = task;
+        }
+        else {
+            const executorContext = plan.getExecutorContext(cwd);
+            initialPrompt = [
+                "Please revise your previous work based on the following review feedback.",
+                "",
+                ...(executorContext ? [executorContext, ""] : []),
+                "## Original Task",
+                task,
+                "",
+                "## Your Previous Output",
+                executorOutput,
+                "",
+                `## Review Feedback from ${reviewer.label}`,
+                reviewerFeedback,
+                "",
+                "Please make corrections based on the feedback and output the complete revised result.",
+            ].join("\n");
+        }
+        // ── Multi-turn conversation with executor ──
+        const executorStartMs = Date.now();
+        const conversation = await runConversation({
+            engine: executor,
+            initialPrompt,
+            cwd,
+            verbose,
+            mode,
+            passthroughArgs,
+        });
+        executorOutput = conversation.finalOutput;
+        const executorDurationMs = Date.now() - executorStartMs;
+        // Create structured executor message
+        const executorMsg = createExecutorMessage({
+            iteration: i,
+            engine: executor.name,
+            originalTask: task,
+            context: reviewerFeedback,
+            outputText: executorOutput,
+            durationMs: executorDurationMs,
+            bytesReceived: conversation.bytes_received,
+        });
+        history.push(executorMsg);
+        // ── Reviewer ──
+        const reviewerContext = plan.getReviewerContext(cwd);
+        const reviewPrompt = [
+            "You are a code review expert. Please review the following task completion.",
+            "",
+            ...(reviewerContext ? [reviewerContext, ""] : []),
+            "## Original Task",
+            task,
+            "",
+            formatForReviewer(executorMsg),
+            "",
+            "Please provide:",
+            "1. Score (1-10, 10 being perfect)",
+            "2. Issues found",
+            "3. Specific correction suggestions",
+            `4. If score >= ${threshold}, output "APPROVED" on the last line`,
+        ].join("\n");
+        console.log("");
+        console.log(reviewerHeader(reviewer));
+        console.log(revColor("  \u2502"));
+        const revStart = Date.now();
+        reviewerFeedback = await reviewer.run(reviewPrompt, {
+            cwd,
+            verbose,
+            onData(chunk) {
+                const lines = chunk.split("\n");
+                for (let j = 0; j < lines.length; j++) {
+                    const line = lines[j];
+                    if (j < lines.length - 1) {
+                        process.stdout.write(`${revColor("  \u2502")}  ${line}\n`);
+                    }
+                    else if (line.length > 0) {
+                        process.stdout.write(`${revColor("  \u2502")}  ${line}\n`);
+                    }
+                }
+            },
+        });
+        console.log(revColor("  \u2502"));
+        console.log(reviewerFooter(reviewer, elapsed(revStart)));
+        // Parse structured reviewer output
+        const reviewerMsg = parseReviewerOutput(reviewerFeedback, {
+            iteration: i,
+            engine: reviewer.name,
+            originalTask: task,
+            durationMs: Date.now() - revStart,
+            bytesReceived: Buffer.byteLength(reviewerFeedback),
+        });
+        history.push(reviewerMsg);
+        // Evaluate review using scoring module
+        const scoringResult = evaluateReview(reviewerMsg.review, scoringConfig);
+        // Update shared plan with iteration data
+        plan.updateSharedPlan(cwd, {
+            iteration: i,
+            timestamp: new Date().toISOString(),
+            executor: executor.name,
+            reviewer: reviewer.name,
+            executorSummary: executorOutput.slice(0, 500),
+            reviewerScore: reviewerMsg.review?.score ?? 0,
+            reviewerApproved: scoringResult.approved,
+            reviewerFeedback: reviewerFeedback.slice(0, 500),
+        }, executorMsg.output.files_changed);
+        // ── Check approval ──
+        if (scoringResult.approved) {
+            console.log(success(bold(`\n  \u2713 ${reviewer.label} approved! ${scoringResult.reason}. Completed after iteration ${i}.\n`)));
+            return {
+                iterations: i,
+                approved: true,
+                finalOutput: executorOutput,
+                history,
+            };
+        }
+        if (i === maxIterations) {
+            console.log(warn(`\n  \u26A0 Reached max iterations (${maxIterations}). ${scoringResult.reason}\n`));
+        }
+        else {
+            console.log(dim(`\n  \u2192 ${scoringResult.reason}. Proceeding to iteration ${i + 1}...\n`));
+        }
+    }
+    console.log(bold(`\n  ${"\u2550".repeat(12)} Final Result ${"\u2550".repeat(12)}\n`));
+    console.log(executorOutput);
+    console.log("");
+    return {
+        iterations: maxIterations,
+        approved: false,
+        finalOutput: executorOutput,
+        history,
+    };
+}
+//# sourceMappingURL=loop.js.map

package/dist/core/protocol.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Structured communication protocol for loop iterations.
+ *
+ * Ported from iterloop's protocol.ts with the protocol name changed
+ * from "iterloop-v1" to "loop-v1".
+ */
+import type { EngineName } from "./engine.js";
+export interface LoopMessage {
+    protocol: "loop-v1";
+    timestamp: string;
+    iteration: number;
+    role: "executor" | "reviewer";
+    engine: EngineName;
+    task: {
+        original: string;
+        context: string;
+    };
+    output: {
+        text: string;
+        files_changed: string[];
+        commands_executed: string[];
+        status: "completed" | "needs_revision" | "error";
+    };
+    review?: {
+        score: number;
+        issues: string[];
+        suggestions: string[];
+        approved: boolean;
+    };
+    metadata: {
+        duration_ms: number;
+        bytes_received: number;
+        model?: string;
+    };
+}
+/** Create an executor message from session output. */
+export declare function createExecutorMessage(params: {
+    iteration: number;
+    engine: EngineName;
+    originalTask: string;
+    context: string;
+    outputText: string;
+    durationMs: number;
+    bytesReceived: number;
+}): LoopMessage;
+/** Parse reviewer output into a structured review. */
+export declare function parseReviewerOutput(reviewText: string, params: {
+    iteration: number;
+    engine: EngineName;
+    originalTask: string;
+    durationMs: number;
+    bytesReceived: number;
+}): LoopMessage;
+/** Serialize a message to JSON string. */
+export declare function serializeMessage(msg: LoopMessage): string;
+/** Deserialize a JSON string to a message. */
+export declare function deserializeMessage(json: string): LoopMessage;
+/** Format an executor message for inclusion in the reviewer prompt. */
+export declare function formatForReviewer(msg: LoopMessage): string;
+//# sourceMappingURL=protocol.d.ts.map