flanders 0.0.2 → 0.2.0

package/lib/ai/CodexAdapter.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAdapter = void 0;
+exports.formatCodexCommand = formatCodexCommand;
+const COMMAND_INLINE_MAX = 120;
+const RATE_LIMIT_SUBSTRINGS = [
+    "out of credits",
+    "refill",
+    "usage limit",
+    "rate limit",
+    "rate-limit",
+    "rate_limit",
+    "quota",
+    "too many requests"
+];
+const RATE_LIMIT_429_RE = /\b429\b/;
+const EIGHT_MINUTES_MS = 8 * 60000;
+const TWELVE_MINUTES_MS = 12 * 60000;
+const FIVE_XX_RE = /\b5\d{2}\b/;
+const STATUS_408_RE = /\b408\b/;
+const STATUS_425_RE = /\b425\b/;
+const TRANSPORT_SUBSTRINGS = [
+    "timeout",
+    "timed out",
+    "connection reset",
+    "connection refused",
+    "socket hang up",
+    "temporarily unavailable",
+    "service unavailable",
+    "gateway",
+    "network",
+    "econnreset",
+    "econnrefused",
+    "enotfound",
+    "etimedout",
+    "eai_again"
+];
+function formatCodexCommand(command) {
+    if (!command)
+        return "";
+    const firstLine = command.split("\n")[0];
+    if (firstLine.length > COMMAND_INLINE_MAX) {
+        return firstLine.slice(0, COMMAND_INLINE_MAX - 3) + "...";
+    }
+    return firstLine;
+}
+function isRateLimitMessage(message) {
+    const lower = message.trim().toLowerCase();
+    for (const sub of RATE_LIMIT_SUBSTRINGS) {
+        if (lower.includes(sub))
+            return true;
+    }
+    return RATE_LIMIT_429_RE.test(message.trim());
+}
+function isRetryableHttpStatus(message) {
+    const trimmed = message.trim();
+    if (FIVE_XX_RE.test(trimmed))
+        return true;
+    if (STATUS_408_RE.test(trimmed))
+        return true;
+    if (STATUS_425_RE.test(trimmed))
+        return true;
+    return false;
+}
+function isRetryableTransport(message) {
+    const lower = message.trim().toLowerCase();
+    for (const sub of TRANSPORT_SUBSTRINGS) {
+        if (lower.includes(sub))
+            return true;
+    }
+    return false;
+}
+class CodexAdapter {
+    constructor(_contexts) {
+        this._contexts = _contexts;
+    }
+    invoke(args) {
+        const iter = new CodexAdapterIterator(args, this._contexts);
+        return {
+            [Symbol.asyncIterator]() {
+                return iter;
+            }
+        };
+    }
+}
+exports.CodexAdapter = CodexAdapter;
+class CodexAdapterIterator {
+    constructor(_args, _contexts) {
+        this._args = _args;
+        this._contexts = _contexts;
+        this._proc = null;
+        this._capturedSessionId = null;
+        this._queue = [];
+        this._done = false;
+        this._waitResolve = null;
+        this._abortListener = null;
+        this._exitPromise = null;
+        this._sawTurnCompleted = false;
+        this._receivedAnyEvent = false;
+        this._fallbackAttempted = false;
+        this._usedResumeOrFork = false;
+        this._start(false);
+    }
+    _start(useExecFallback) {
+        var _a, _b, _c;
+        const isResume = !useExecFallback && !!this._args.resumeSessionId;
+        const isFork = !useExecFallback && !!this._args.forkParentSessionId;
+        this._usedResumeOrFork = isResume || isFork;
+        const argv = this._buildArgv(isResume, isFork);
+        const spawnOptions = { stdio: "pipe" };
+        const proc = this._contexts.script.spawn("codex", argv, spawnOptions);
+        this._proc = proc;
+        (_a = proc.stdin) === null || _a === void 0 ? void 0 : _a.write(this._args.prompt);
+        (_b = proc.stdin) === null || _b === void 0 ? void 0 : _b.end();
+        let exitResolve = null;
+        this._exitPromise = new Promise(resolve => { exitResolve = resolve; });
+        let buffer = "";
+        (_c = proc.stdout) === null || _c === void 0 ? void 0 : _c.on("data", (chunk) => {
+            buffer += String(chunk);
+            for (;;) {
+                const nl = buffer.indexOf("\n");
+                if (nl < 0)
+                    break;
+                const line = buffer.slice(0, nl).replace(/\r$/, "");
+                buffer = buffer.slice(nl + 1);
+                if (line) {
+                    this._handleLine(line);
+                }
+            }
+        });
+        proc.on("error", (e) => {
+            if (this._done) {
+                exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+                return;
+            }
+            this._done = true;
+            const err = e instanceof Error ? e : new Error(String(e));
+            if (err.code === "ENOENT") {
+                this._queue.push({ type: "error", retryable: false, message: "codex binary not found" });
+            }
+            else {
+                this._queue.push({ type: "error", retryable: false, message: err.message });
+            }
+            this._wake();
+            exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+        });
+        proc.on("exit", (code, signal) => {
+            if (this._done) {
+                exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+                return;
+            }
+            if (this._usedResumeOrFork && !this._receivedAnyEvent && !this._fallbackAttempted) {
+                this._fallbackAttempted = true;
+                this._queue.push({
+                    type: "output",
+                    title: "Continuity lost",
+                    subtitle: "",
+                    details: "codex resume/fork unavailable in installed CLI"
+                });
+                this._cleanup();
+                this._sawTurnCompleted = false;
+                this._receivedAnyEvent = false;
+                this._usedResumeOrFork = false;
+                exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+                this._start(true);
+                this._wake();
+                return;
+            }
+            if (this._sawTurnCompleted) {
+                this._queue.push({ type: "done" });
+            }
+            else if (signal) {
+                this._queue.push({
+                    type: "error",
+                    retryable: true,
+                    message: `codex terminated by signal ${signal}`
+                });
+            }
+            else {
+                this._queue.push({
+                    type: "error",
+                    retryable: true,
+                    message: `codex exited unexpectedly (code ${code} signal ${signal})`
+                });
+            }
+            this._done = true;
+            this._wake();
+            exitResolve === null || exitResolve === void 0 ? void 0 : exitResolve();
+        });
+        this._abortListener = () => {
+            if (this._proc) {
+                this._proc.kill("SIGINT");
+            }
+            this._done = true;
+            this._wake();
+        };
+        if (this._args.abortSignal.aborted) {
+            this._abortListener();
+        }
+        else {
+            this._args.abortSignal.addEventListener("abort", this._abortListener, { once: true });
+        }
+    }
+    _buildArgv(isResume, isFork) {
+        const argv = [];
+        if (isResume) {
+            argv.push("resume", this._args.resumeSessionId);
+        }
+        else if (isFork) {
+            argv.push("fork", this._args.forkParentSessionId);
+        }
+        else {
+            argv.push("exec");
+        }
+        argv.push("--json");
+        argv.push("-c", "approval_policy=never");
+        argv.push("-c", "sandbox_mode=danger-full-access");
+        if (this._args.model) {
+            argv.push("-m", this._args.model);
+        }
+        if (this._args.effort) {
+            argv.push("-c", `model_reasoning_effort=${this._args.effort}`);
+        }
+        argv.push("-");
+        return argv;
+    }
+    _handleLine(line) {
+        var _a, _b, _c;
+        if (this._done)
+            return;
+        let parsed = null;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!parsed)
+            return;
+        this._receivedAnyEvent = true;
+        if (parsed.thread_id && parsed.thread_id !== this._capturedSessionId) {
+            this._capturedSessionId = parsed.thread_id;
+            this._queue.push({ type: "session", id: parsed.thread_id });
+        }
+        if (parsed.type === "item.completed" && parsed.item) {
+            this._handleItemCompleted(parsed.item);
+        }
+        else if (parsed.type === "turn.completed") {
+            this._sawTurnCompleted = true;
+            if (parsed.usage && this._args.onUsage) {
+                this._args.onUsage({
+                    inputTokens: (_a = parsed.usage.input_tokens) !== null && _a !== void 0 ? _a : 0,
+                    outputTokens: (_b = parsed.usage.output_tokens) !== null && _b !== void 0 ? _b : 0
+                });
+            }
+        }
+        else if (parsed.type === "error") {
+            this._handleFailure(typeof parsed.message === "string" ? parsed.message : "unknown error");
+        }
+        else if (parsed.type === "turn.failed") {
+            this._handleFailure(typeof ((_c = parsed.error) === null || _c === void 0 ? void 0 : _c.message) === "string" ? parsed.error.message : "unknown error");
+        }
+        this._wake();
+    }
+    _handleItemCompleted(item) {
+        if (item.type === "agent_message") {
+            this._queue.push({
+                type: "output",
+                title: "Assistant",
+                subtitle: "",
+                details: typeof item.text === "string" ? item.text : ""
+            });
+        }
+        else if (item.type === "command_execution") {
+            this._queue.push({
+                type: "output",
+                title: "command",
+                subtitle: formatCodexCommand(item.command),
+                details: typeof item.aggregated_output === "string" ? item.aggregated_output : ""
+            });
+        }
+        else if (item.type === "reasoning") {
+            this._queue.push({
+                type: "output",
+                title: "Thinking",
+                subtitle: "",
+                details: typeof item.text === "string" ? item.text : ""
+            });
+        }
+    }
+    _handleFailure(message) {
+        if (isRateLimitMessage(message)) {
+            const r = EIGHT_MINUTES_MS + Math.round(this._contexts.random.random() * (TWELVE_MINUTES_MS - EIGHT_MINUTES_MS));
+            this._queue.push({
+                type: "rate_limit",
+                waitUntilMs: this._contexts.time.now() + r
+            });
+        }
+        else if (isRetryableHttpStatus(message)) {
+            this._queue.push({ type: "error", retryable: true, message });
+        }
+        else if (isRetryableTransport(message)) {
+            this._queue.push({ type: "error", retryable: true, message });
+        }
+        else {
+            this._queue.push({ type: "error", retryable: false, message });
+        }
+        this._done = true;
+    }
+    _wake() {
+        if (this._waitResolve) {
+            const resolve = this._waitResolve;
+            this._waitResolve = null;
+            resolve();
+        }
+    }
+    _wait() {
+        return new Promise(resolve => {
+            this._waitResolve = resolve;
+        });
+    }
+    async next() {
+        for (;;) {
+            if (this._queue.length > 0) {
+                return { value: this._queue.shift(), done: false };
+            }
+            if (this._done && this._queue.length === 0) {
+                this._cleanup();
+                if (this._exitPromise) {
+                    await this._exitPromise;
+                }
+                return { value: undefined, done: true };
+            }
+            await this._wait();
+        }
+    }
+    async return() {
+        this._done = true;
+        this._cleanup();
+        if (this._proc) {
+            this._proc.kill("SIGINT");
+            if (this._exitPromise) {
+                await this._exitPromise;
+            }
+        }
+        return { value: undefined, done: true };
+    }
+    _cleanup() {
+        if (this._abortListener) {
+            this._args.abortSignal.removeEventListener("abort", this._abortListener);
+            this._abortListener = null;
+        }
+    }
+}

package/lib/ai/ToolAdapter.d.ts

@@ -0,0 +1,52 @@
+export type ToolEventOutput = Readonly<{
+    type: "output";
+    title: string;
+    subtitle: string;
+    details: string;
+}>;
+export type ToolEventSession = Readonly<{
+    type: "session";
+    id: string;
+}>;
+export type ToolEventError = Readonly<{
+    type: "error";
+    retryable: boolean;
+    message: string;
+}>;
+export type ToolEventRateLimit = Readonly<{
+    type: "rate_limit";
+    waitUntilMs: number;
+}>;
+export type ToolEventDone = Readonly<{
+    type: "done";
+}>;
+export type ToolEvent = ToolEventOutput | ToolEventSession | ToolEventError | ToolEventRateLimit | ToolEventDone;
+export type ToolAdapterUsageCallback = (usage: Readonly<{
+    inputTokens: number;
+    outputTokens: number;
+}>) => void;
+type ToolAdapterInvokeArgsBase = Readonly<{
+    prompt: string;
+    model: string;
+    effort: string;
+    abortSignal: AbortSignal;
+    onUsage?: ToolAdapterUsageCallback;
+}>;
+export type ToolAdapterInvokeArgsFresh = ToolAdapterInvokeArgsBase & Readonly<{
+    resumeSessionId?: undefined;
+    forkParentSessionId?: undefined;
+}>;
+export type ToolAdapterInvokeArgsResume = ToolAdapterInvokeArgsBase & Readonly<{
+    resumeSessionId: string;
+    forkParentSessionId?: undefined;
+}>;
+export type ToolAdapterInvokeArgsFork = ToolAdapterInvokeArgsBase & Readonly<{
+    resumeSessionId?: undefined;
+    forkParentSessionId: string;
+}>;
+export type ToolAdapterInvokeArgs = ToolAdapterInvokeArgsFresh | ToolAdapterInvokeArgsResume | ToolAdapterInvokeArgsFork;
+export interface ToolAdapter {
+    invoke(args: ToolAdapterInvokeArgs): AsyncIterable<ToolEvent>;
+}
+export type ToolName = "claude" | "codex";
+export {};

package/lib/ai/ToolAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cli.js

@@ -41,37 +41,27 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 const Flanders_1 = require("./Flanders");
-const spawnContext = {
-    spawn(command, args, options) {
-        const child = (0, child_process_1.spawn)(command, [...args], options);
-        const proc = {
-            on(event, listener) {
-                child.on(event, listener);
-            },
-            kill(signal) {
-                child.kill(signal);
-            },
-            stdout: child.stdout ? {
-                on(event, listener) {
-                    child.stdout.on(event, listener);
-                }
-            } : undefined,
-            stderr: child.stderr ? {
-                on(event, listener) {
-                    child.stderr.on(event, listener);
-                }
-            } : undefined,
-            stdin: child.stdin ? {
-                write(chunk) {
-                    child.stdin.write(chunk);
-                },
-                end() {
-                    child.stdin.end();
-                }
-            } : undefined
-        };
-        return proc;
-    }
+const ShellScriptContext_1 = require("./system/ShellScriptContext");
+const TerminalSizeSource_1 = require("./ui/TerminalSizeSource");
+const rawSpawn = (command, args, options) => {
+    var _a;
+    const child = (0, child_process_1.spawn)(command, [...args], options);
+    const raw = {
+        pid: (_a = child.pid) !== null && _a !== void 0 ? _a : 0,
+        stdout: child.stdout,
+        stderr: child.stderr,
+        stdin: child.stdin,
+        on(event, listener) {
+            child.on(event, listener);
+        },
+        kill(signal) {
+            child.kill(signal);
+        }
+    };
+    return raw;
+};
+const killPrimitive = (pid, signal) => {
+    process.kill(pid, signal);
 };
 const fsContext = {
     async readFile(p) {
@@ -81,6 +71,9 @@ const fsContext = {
         await fs_1.promises.mkdir(path.dirname(p), { recursive: true });
         await fs_1.promises.writeFile(p, content, "utf8");
     },
+    async rename(oldP, newP) {
+        await fs_1.promises.rename(oldP, newP);
+    },
     async readdir(p) {
         const entries = await fs_1.promises.readdir(p, { withFileTypes: true });
         return entries.map(e => ({
@@ -132,6 +125,32 @@ const timeContext = {
         };
     }
 };
+const randomContext = {
+    random() {
+        return Math.random();
+    }
+};
+const RESIZE_POLL_MS = 200;
+const readTerminalSize = () => {
+    var _a, _b;
+    const stream = process.stdout;
+    const handle = stream._handle;
+    if (!handle || typeof handle.getWindowSize !== "function") {
+        return null;
+    }
+    const size = [0, 0];
+    const err = handle.getWindowSize(size);
+    const cols = (_a = size[0]) !== null && _a !== void 0 ? _a : 0;
+    const rows = (_b = size[1]) !== null && _b !== void 0 ? _b : 0;
+    if (err || cols <= 0) {
+        return null;
+    }
+    return { columns: cols, rows };
+};
+const terminalSize = new TerminalSizeSource_1.TerminalSizeSource(readTerminalSize, listener => {
+    process.stdout.on("resize", listener);
+    return () => { process.stdout.off("resize", listener); };
+}, timeContext, RESIZE_POLL_MS);
 const outputContext = {
     write(text) {
         process.stdout.write(text);
@@ -140,14 +159,13 @@ const outputContext = {
         process.stderr.write(text);
     },
     columns() {
-        return process.stdout.columns || 80;
+        return terminalSize.columns();
     },
     rows() {
-        return process.stdout.rows || 24;
+        return terminalSize.rows();
     },
     onResize(listener) {
-        process.stdout.on("resize", listener);
-        return () => { process.stdout.off("resize", listener); };
+        return terminalSize.onResize(listener);
     }
 };
 const platformContext = {
@@ -161,6 +179,7 @@ const platformContext = {
         return os.homedir();
     }
 };
+const spawnContext = new ShellScriptContext_1.ShellScriptContext(rawSpawn, killPrimitive, platformContext);
 const ask = (() => {
     let rl = null;
     const ensure = () => {
@@ -297,6 +316,7 @@ const flanders = new Flanders_1.Flanders(process.argv.slice(2), { projectRoot: p
     script: spawnContext,
     fs: fsContext,
     time: timeContext,
+    random: randomContext,
     platform: platformContext,
     ask: ask.context,
     output: outputContext
@@ -311,6 +331,7 @@ const end = async () => {
     outputContext.write("Shutting down...\n");
     try {
         await flanders.dispose();
+        terminalSize.dispose();
     }
     catch (e) {
         outputContext.writeError(`${e instanceof Error ? (_a = e.stack) !== null && _a !== void 0 ? _a : e.message : String(e)}\n`);

package/lib/commands/Implement.d.ts

@@ -1,14 +1,15 @@
-import type { AskContext, ClaudeContext, FsContext, OutputContext, ScriptContext, TimeContext } from "../contexts";
+import type { FsContext, OutputContext, RandomContext, ScriptContext, TimeContext } from "../contexts";
+import type { FlandersConfig } from "../workspace/FlandersConfig";
 import type { Activity } from "../ui/BottomBlock";
-import { PlatformContext } from "../Workspace";
+import { PlatformContext } from "../workspace/Workspace";
 export type { Activity };
 export type ImplementContexts = Readonly<{
-    claude: ClaudeContext;
+    claude: ScriptContext;
     script: ScriptContext;
     fs: FsContext;
     time: TimeContext;
+    random: RandomContext;
     platform: PlatformContext;
-    ask: AskContext;
     output: OutputContext;
 }>;
 export type ImplementOptions = Readonly<{
@@ -18,8 +19,10 @@ export declare class Implement {
     private _options;
     private _contexts;
     private _disposed;
+    private _config;
     private _contractList;
     private _ruleList;
+    private _behaviorRuleList;
     private _workspace;
     private _block;
     private _buffered;
@@ -27,6 +30,8 @@ export declare class Implement {
     private _currentPrepSessionId;
     private _activeSession;
     private _activeScript;
+    private _activeReviewerSessions;
+    private _reviewerStates;
     private _currentIndexLabel;
     private _currentIteration;
     private _currentTask;
@@ -34,27 +39,36 @@ export declare class Implement {
     private _taskRateLimitMs;
     private _taskRateLimitStartedAt;
     private _taskTokens;
+    private _restingFooterKind;
     private _runPromise;
+    get config(): FlandersConfig | null;
     constructor(rawArgs: readonly string[], _options: ImplementOptions, _contexts: ImplementContexts);
     result(): Promise<number>;
     private _run;
     private _selectPlan;
-    private _askOutput;
-    private _promptPlanChoice;
     private _detectBuildAndTest;
     private _setActivity;
     private _activeSeconds;
     private _persistMetrics;
     private _updateMetrics;
+    private _reviewerMatchesWorker;
+    private _prepActive;
+    private _gitOutputContext;
     private _runTask;
     private _prepStage;
     private _workerStage;
+    private _appendLinkedContent;
     private _buildStage;
     private _testStage;
+    private _setReviewerState;
+    private _renderReviewingFooter;
     private _reviewerStage;
-    private _parseReviewVerdict;
+    private _runOneReviewerToVerdict;
     private _formatPathList;
-    private _runClaude;
+    private _getAdapter;
+    private _defaultRunAiCallbacks;
+    private _runAi;
+    private _runAiWith;
     private _runScript;
     private _writeLog;
     private _writeErrorLog;