flanders 0.1.0 → 0.3.0

package/lib/commands/InstallModelProbe.d.ts

@@ -0,0 +1,11 @@
+import type { ScriptContext } from "../contexts";
+export type ModelProbeResult = Readonly<{
+    kind: "list";
+    models: readonly string[];
+}> | Readonly<{
+    kind: "no-list";
+}> | Readonly<{
+    kind: "not-started";
+    reason: string;
+}>;
+export declare function probeModelList(script: ScriptContext): Promise<ModelProbeResult>;

package/lib/commands/InstallModelProbe.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeModelList = probeModelList;
+const COMMAND_NOT_FOUND_MARKERS = ["not found", "not recognized", "no such file"];
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+function isCommandNotFound(combinedOutput) {
+    const lower = combinedOutput.toLowerCase();
+    return COMMAND_NOT_FOUND_MARKERS.some(marker => lower.includes(marker));
+}
+function probeModelList(script) {
+    return new Promise(resolve => {
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let settled = false;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        const notStarted = (spawnMessage) => {
+            const stderr = stderrChunks.join("");
+            const stdout = stdoutChunks.join("");
+            const reason = stderr !== "" ? stderr : stdout !== "" ? stdout : (spawnMessage !== null && spawnMessage !== void 0 ? spawnMessage : "");
+            settle({ kind: "not-started", reason });
+        };
+        let proc;
+        try {
+            proc = script.spawn("codex", ["debug", "models"], { stdio: "pipe" });
+        }
+        catch (e) {
+            notStarted(errorMessage(e));
+            return;
+        }
+        const capture = (chunks) => (chunk) => {
+            chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+        };
+        if (proc.stdout) {
+            proc.stdout.on("data", capture(stdoutChunks));
+        }
+        if (proc.stderr) {
+            proc.stderr.on("data", capture(stderrChunks));
+        }
+        proc.on("error", (e) => {
+            notStarted(errorMessage(e));
+        });
+        proc.on("exit", (code) => {
+            const stdout = stdoutChunks.join("");
+            const stderr = stderrChunks.join("");
+            if (code === 127 || isCommandNotFound(stderr + stdout)) {
+                notStarted(null);
+                return;
+            }
+            if (code !== 0) {
+                settle({ kind: "no-list" });
+                return;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(stdout);
+            }
+            catch {
+                settle({ kind: "no-list" });
+                return;
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                settle({ kind: "no-list" });
+                return;
+            }
+            const models = parsed.models;
+            if (!Array.isArray(models)) {
+                settle({ kind: "no-list" });
+                return;
+            }
+            const slugs = [];
+            for (const entry of models) {
+                if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+                    settle({ kind: "no-list" });
+                    return;
+                }
+                const record = entry;
+                if (typeof record.slug !== "string" || typeof record.visibility !== "string") {
+                    settle({ kind: "no-list" });
+                    return;
+                }
+                if (record.visibility === "list") {
+                    slugs.push(record.slug);
+                }
+            }
+            if (slugs.length === 0) {
+                settle({ kind: "no-list" });
+                return;
+            }
+            settle({ kind: "list", models: slugs });
+        });
+    });
+}

package/lib/contexts.d.ts

@@ -3,7 +3,7 @@ export type SpawnedReadable = {
     on(event: "data", listener: (chunk: Buffer | string) => void): void;
 };
 export type SpawnedProcess = {
-    on(event: "exit", listener: (code: number | null) => void): void;
+    on(event: "exit", listener: (code: number | null, signal: string | null) => void): void;
     on(event: "error", listener: (e: unknown) => void): void;
     kill(signal: "SIGINT" | "SIGTERM"): void;
     stdout?: SpawnedReadable;
@@ -13,9 +13,6 @@ export type SpawnedProcess = {
         end(): void;
     }>;
 };
-export interface ClaudeContext {
-    spawn(command: string, args: readonly string[], options: SpawnOptions): SpawnedProcess;
-}
 export interface ScriptContext {
     spawn(command: string, args: readonly string[], options: SpawnOptions): SpawnedProcess;
 }
@@ -27,6 +24,7 @@ export type FsDirEntry = Readonly<{
 export interface FsContext {
     readFile(path: string): Promise<string>;
     writeFile(path: string, content: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
     readdir(path: string): Promise<readonly FsDirEntry[]>;
     stat(path: string): Promise<Readonly<{
         size: number;
@@ -50,6 +48,9 @@ export interface TimeContext {
     now(): number;
     setTimeout(handler: () => void, ms: number): TimeoutHandle;
 }
+export interface RandomContext {
+    random(): number;
+}
 export type ChoiceOption = Readonly<{
     label: string;
     description?: string;

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 export { Flanders } from "./Flanders";
 export type { FlandersContexts, FlandersOptions } from "./Flanders";
-export type { AskAnswer, AskChoiceOptions, AskContext, ChoiceOption, ClaudeContext, ScriptContext, FsContext, FsDirEntry, OutputContext, TimeContext, TimeoutHandle, SpawnedProcess, SpawnedReadable } from "./contexts";
-export type { ClaudeEvent, ClaudeContentBlock, ClaudeControlRequestBody, ClaudeDelta, ClaudeResult, ClaudeRunOptions, PermissionRequest, PermissionResponse } from "./Claude";
-export type { PlatformContext } from "./Workspace";
+export type { FlandersConfig } from "./workspace/FlandersConfig";
+export type { AskAnswer, AskChoiceOptions, AskContext, ChoiceOption, ScriptContext, FsContext, FsDirEntry, OutputContext, TimeContext, TimeoutHandle, SpawnedProcess, SpawnedReadable } from "./contexts";
+export type { AiSessionResult, AiSessionOptions, AiSessionContexts } from "./ai/AiSession";
+export type { ToolAdapter, ToolAdapterInvokeArgs, ToolAdapterUsageCallback, ToolEvent, ToolEventDone, ToolEventError, ToolEventOutput, ToolEventRateLimit, ToolEventSession, ToolName } from "./ai/ToolAdapter";
+export type { PlatformContext } from "./workspace/Workspace";

package/lib/{PlanFile.d.ts → plan/PlanFile.d.ts}

@@ -1,4 +1,4 @@
-import type { FsContext } from "./contexts";
+import type { FsContext } from "../contexts";
 export type TaskMetrics = Readonly<{
     it: number;
     ot: number;
@@ -12,6 +12,10 @@ export type PlanTask = Readonly<{
     done: boolean;
     metrics: TaskMetrics;
 }>;
+export type TaskLinkedPaths = Readonly<{
+    contracts: readonly string[];
+    rules: readonly string[];
+}>;
 export type PlanParseResult = Readonly<{
     tasks: readonly PlanTask[];
     malformed: readonly Readonly<{
@@ -21,7 +25,9 @@ export type PlanParseResult = Readonly<{
     lineCount: number;
     size: number;
 }>;
+export declare const TASK_LINE: RegExp;
 export declare function parsePlan(content: string): PlanParseResult;
+export declare function parseLinkedPaths(content: string, taskLineNumber: number): TaskLinkedPaths;
 export declare class PlanFile {
     readonly path: string;
     private _content;
@@ -33,6 +39,7 @@ export declare class PlanFile {
     updateMetrics(lineNumber: number, metrics: TaskMetrics): Promise<void>;
     markDone(lineNumber: number, metrics: TaskMetrics): Promise<void>;
     markOpen(lineNumber: number, metrics: TaskMetrics): Promise<void>;
+    linkedPaths(task: PlanTask): TaskLinkedPaths;
     planTotals(): TaskMetrics;
     private _rewriteTaskLine;
 }

package/lib/{PlanFile.js → plan/PlanFile.js}

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlanFile = void 0;
+exports.PlanFile = exports.TASK_LINE = void 0;
 exports.parsePlan = parsePlan;
-const TASK_LINE = /^(\s*[-*+]\s+)\[([ xX])\](\{[^}]*\})(\s.*)?$/;
-const MALFORMED_TASK_LINE = /^\s*[-*+]\s+\[([^\]]*)\]/;
+exports.parseLinkedPaths = parseLinkedPaths;
+exports.TASK_LINE = /^(\s*[-*+]\s+)\[([ xX])\](\{[^}]*\})(\s.*)?$/;
+const MALFORMED_TASK_LINE = /^\s*[-*+]\s+\[[^\]]*\]\{/;
 const HEADING_NUMBER = /^#{1,6}\s+(\d+(?:\.\d+)*)\b/;
 function validateMetrics(jsonStr) {
     let parsed;
@@ -49,7 +50,7 @@ function parsePlan(content) {
         if (headingMatch) {
             currentNumber = headingMatch[1];
         }
-        const match = TASK_LINE.exec(raw);
+        const match = exports.TASK_LINE.exec(raw);
         if (match) {
             const checkbox = match[2];
             if (checkbox !== " " && checkbox !== "x") {
@@ -87,6 +88,41 @@ function parsePlan(content) {
         size: content.length
     };
 }
+const BACKTICK_PATH = /`([^`]+)`/g;
+function extractPathsFromLine(text) {
+    const paths = [];
+    let m;
+    while ((m = BACKTICK_PATH.exec(text)) !== null) {
+        paths.push(m[1]);
+    }
+    return paths;
+}
+function taskBodyLines(content, taskLineNumber) {
+    const lines = content.split(/\r?\n/);
+    const body = [];
+    for (let i = taskLineNumber; i < lines.length; i++) {
+        const line = lines[i];
+        if (exports.TASK_LINE.test(line))
+            break;
+        body.push(line);
+    }
+    return body;
+}
+function parseLinkedPaths(content, taskLineNumber) {
+    const body = taskBodyLines(content, taskLineNumber);
+    let contracts = [];
+    let rules = [];
+    for (const line of body) {
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith("Linked contracts:")) {
+            contracts = extractPathsFromLine(trimmed.slice("Linked contracts:".length));
+        }
+        else if (trimmed.startsWith("Linked rules:")) {
+            rules = extractPathsFromLine(trimmed.slice("Linked rules:".length));
+        }
+    }
+    return { contracts, rules };
+}
 class PlanFile {
     constructor(path, _content, _fs) {
         this.path = path;
@@ -117,6 +153,9 @@ class PlanFile {
     async markOpen(lineNumber, metrics) {
         return this._rewriteTaskLine(lineNumber, metrics, "open");
     }
+    linkedPaths(task) {
+        return parseLinkedPaths(this._content, task.line);
+    }
     planTotals() {
         const { tasks } = parsePlan(this._content);
         let it = 0, ot = 0, t = 0;
@@ -137,7 +176,7 @@ class PlanFile {
         if (raw === undefined) {
             throw new Error(`Plan line ${lineNumber} not found in ${this.path}`);
         }
-        const match = TASK_LINE.exec(raw);
+        const match = exports.TASK_LINE.exec(raw);
         if (!match) {
             throw new Error(`Plan line ${lineNumber} is not a task line: ${raw}`);
         }

package/lib/prompts/prompts.d.ts

@@ -0,0 +1,48 @@
+export declare const enum Placeholders {
+    PLAN_PATH = "<PLAN_PATH>",
+    TASK_LINE = "<TASK_LINE>",
+    TASK_TITLE = "<TASK_TITLE>",
+    BUILD_SCRIPT_PATH = "<BUILD_SCRIPT_PATH>",
+    TEST_SCRIPT_PATH = "<TEST_SCRIPT_PATH>",
+    ERROR_LOG_PATH = "<ERROR_LOG_PATH>",
+    ITERATION = "<ITERATION>",
+    CONTRACT_LIST = "<CONTRACT_LIST>",
+    RULE_LIST = "<RULE_LIST>",
+    BEHAVIOR_RULE_LIST = "<BEHAVIOR_RULE_LIST>"
+}
+export interface ReviewerMethodologySurface {
+    changeSetIntro: string;
+    specRef: string;
+    ownerChanges: string;
+    ownerProducedNoDiff: string;
+    critRef: string;
+    critRefShort: string;
+    critRefShortPlural: string;
+    passObject: string;
+    errorLogInline: string;
+    emptyChangeSetCitation: string;
+    readOnlyParagraph: string;
+    failCondition1: string;
+    critProtocolName: string;
+    nextWorker: string;
+    critProtocolHeading: string;
+    ownerChangesEvidence: string;
+    taxonomy: string;
+    reviewProtocolIntro: string;
+    ownerChangesShort: string;
+    errorLogPath: string;
+    nextWorkerActor: string;
+    errorLogPlain: string;
+}
+export declare function buildReviewerMethodology(s: ReviewerMethodologySurface): {
+    changeSet: string;
+    audit: string;
+};
+export declare const reviewerMethodologyCore: string;
+export declare const prompts: {
+    detectBuildAndTest: string;
+    worker: string;
+    reviewer: string;
+    prep: string;
+    previousIterationBriefing: string;
+};