flanders 0.1.0 → 0.3.0

package/lib/workspace/SpecDiscovery.d.ts

@@ -0,0 +1,12 @@
+import type { ScriptContext, TimeContext } from "../contexts";
+export type SpecLists = Readonly<{
+    contracts: readonly string[];
+    rules: readonly string[];
+    flanders: readonly string[];
+}>;
+export declare function classifySpecPaths(paths: readonly string[]): {
+    contracts: string[];
+    rules: string[];
+    flanders: string[];
+};
+export declare function discoverSpecs(script: ScriptContext, time: TimeContext, projectRoot: string): Promise<SpecLists>;

package/lib/workspace/SpecDiscovery.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySpecPaths = classifySpecPaths;
+exports.discoverSpecs = discoverSpecs;
+const Git_1 = require("../system/Git");
+function classifySpecPaths(paths) {
+    const contracts = [];
+    const rules = [];
+    const flanders = [];
+    for (const filePath of paths) {
+        const segments = filePath.split("/");
+        const docsIndex = segments.indexOf(".docs");
+        if (docsIndex === -1) {
+            continue;
+        }
+        if (segments.length <= docsIndex + 2) {
+            continue;
+        }
+        const kind = segments[docsIndex + 1];
+        if (kind === "contracts") {
+            contracts.push(filePath);
+        }
+        else if (kind === "rules") {
+            rules.push(filePath);
+        }
+        else if (kind === "flanders") {
+            flanders.push(filePath);
+        }
+    }
+    return { contracts, rules, flanders };
+}
+async function discoverSpecs(script, time, projectRoot) {
+    const files = await (0, Git_1.listNonIgnoredFiles)(script, time, projectRoot);
+    const { contracts, rules, flanders } = classifySpecPaths(files);
+    const ignored = await (0, Git_1.listIgnoredPaths)(script, time, projectRoot, [...contracts, ...rules, ...flanders]);
+    const survivingContracts = contracts.filter(p => !ignored.has(p)).sort();
+    const survivingRules = rules.filter(p => !ignored.has(p)).sort();
+    const survivingFlanders = flanders.filter(p => !ignored.has(p)).sort();
+    return { contracts: survivingContracts, rules: survivingRules, flanders: survivingFlanders };
+}

package/lib/{Workspace.d.ts → workspace/Workspace.d.ts}

@@ -1,4 +1,4 @@
-import type { FsContext } from "./contexts";
+import type { FsContext } from "../contexts";
 export type WorkspacePaths = Readonly<{
     root: string;
     buildScript: string;
@@ -9,6 +9,8 @@ export type WorkspacePaths = Readonly<{
     buildLog(iter: number): string;
     testLog(iter: number): string;
     reviewerLog(iter: number): string;
+    reviewerOutputLog(iter: number, reviewerIndex: number): string;
+    reviewerErrorLog(reviewerIndex: number): string;
 }>;
 export interface PlatformContext {
     isWindows(): boolean;
@@ -21,12 +23,18 @@ export declare class Workspace {
     private _disposed;
     private _preserve;
     private _root;
+    private _reviewerRoots;
     constructor(_fs: FsContext, _platform: PlatformContext);
     preserveOnDispose(): void;
-    setup(): Promise<WorkspacePaths>;
+    setup(reviewerCount: number): Promise<WorkspacePaths>;
     paths(): WorkspacePaths;
     private _paths;
+    errorLogExists(): Promise<boolean>;
+    readErrorLog(): Promise<string>;
     writeErrorLog(content: string): Promise<void>;
     clearErrorLog(): Promise<void>;
+    reviewerErrorLogExists(reviewerIndex: number): Promise<boolean>;
+    readReviewerErrorLog(reviewerIndex: number): Promise<string>;
+    clearReviewerErrorLog(reviewerIndex: number): Promise<void>;
     dispose(): Promise<void>;
 }

package/lib/{Workspace.js → workspace/Workspace.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Workspace = void 0;
-const fsUtils_1 = require("./fsUtils");
+const fsUtils_1 = require("../system/fsUtils");
 class Workspace {
     constructor(_fs, _platform) {
         this._fs = _fs;
@@ -9,13 +9,14 @@ class Workspace {
         this._disposed = false;
         this._preserve = false;
         this._root = null;
+        this._reviewerRoots = [];
     }
     preserveOnDispose() {
         if (this._disposed)
             return;
         this._preserve = true;
     }
-    async setup() {
+    async setup(reviewerCount) {
         if (this._disposed) {
             throw new Error("Workspace disposed");
         }
@@ -24,15 +25,19 @@ class Workspace {
         }
         const prefix = (0, fsUtils_1.joinPath)(this._platform.tmpdir(), "flanders-");
         this._root = await this._fs.mkdtemp(prefix);
-        return this._paths(this._root);
+        for (let i = 0; i < reviewerCount; i++) {
+            const dir = await this._fs.mkdtemp(prefix);
+            this._reviewerRoots.push(dir);
+        }
+        return this._paths(this._root, this._reviewerRoots);
     }
     paths() {
         if (!this._root) {
             throw new Error("Workspace not set up");
         }
-        return this._paths(this._root);
+        return this._paths(this._root, this._reviewerRoots);
     }
-    _paths(root) {
+    _paths(root, reviewerRoots) {
         const isWindows = this._platform.isWindows();
         return {
             root,
@@ -43,9 +48,22 @@ class Workspace {
             workerLog(iter) { return (0, fsUtils_1.joinPath)(root, `worker.${iter}.log`); },
             buildLog(iter) { return (0, fsUtils_1.joinPath)(root, `build.${iter}.log`); },
             testLog(iter) { return (0, fsUtils_1.joinPath)(root, `test.${iter}.log`); },
-            reviewerLog(iter) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.log`); }
+            reviewerLog(iter) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.log`); },
+            reviewerOutputLog(iter, reviewerIndex) { return (0, fsUtils_1.joinPath)(root, `reviewer.${iter}.${reviewerIndex}.log`); },
+            reviewerErrorLog(reviewerIndex) { return (0, fsUtils_1.joinPath)(reviewerRoots[reviewerIndex - 1], "error.log"); }
         };
     }
+    async errorLogExists() {
+        const paths = this.paths();
+        return await this._fs.exists(paths.errorLog);
+    }
+    async readErrorLog() {
+        const paths = this.paths();
+        if (!await this._fs.exists(paths.errorLog)) {
+            return "";
+        }
+        return await this._fs.readFile(paths.errorLog);
+    }
     async writeErrorLog(content) {
         const paths = this.paths();
         await this._fs.writeFile(paths.errorLog, content);
@@ -56,14 +74,42 @@ class Workspace {
             await this._fs.rm(paths.errorLog, { force: true });
         }
     }
+    async reviewerErrorLogExists(reviewerIndex) {
+        const paths = this.paths();
+        return await this._fs.exists(paths.reviewerErrorLog(reviewerIndex));
+    }
+    async readReviewerErrorLog(reviewerIndex) {
+        const paths = this.paths();
+        const path = paths.reviewerErrorLog(reviewerIndex);
+        if (!await this._fs.exists(path)) {
+            return "";
+        }
+        return await this._fs.readFile(path);
+    }
+    async clearReviewerErrorLog(reviewerIndex) {
+        const paths = this.paths();
+        const path = paths.reviewerErrorLog(reviewerIndex);
+        if (await this._fs.exists(path)) {
+            await this._fs.rm(path, { force: true });
+        }
+    }
     async dispose() {
         if (this._disposed) {
             return;
         }
         this._disposed = true;
         const root = this._root;
+        const reviewerRoots = this._reviewerRoots;
         this._root = null;
+        this._reviewerRoots = [];
         if (root && !this._preserve) {
+            for (let i = reviewerRoots.length - 1; i >= 0; i--) {
+                try {
+                    await this._fs.rm(reviewerRoots[i], { recursive: true, force: true });
+                }
+                catch {
+                }
+            }
             try {
                 await this._fs.rm(root, { recursive: true, force: true });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flanders",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Stubborn and smart plan implementation looper using AI",
   "main": "lib/",
   "types": "lib/types",
@@ -22,7 +22,7 @@
     "watch": "npm run clean && npx tsc -p tsconfig.json -watch",
     "build": "npm run clean && npx tsc -p tsconfig.build.json",
     "build-debug": "npm run clean && npx tsc -p tsconfig.json",
-    "test": "npm run build-debug && npx aaa"
+    "test": "npm run build-debug && npx aaa --folder lib --include-files \"\\.test\\.js$\" --exclude-files node_modules --coverage-exclude node_modules"
   },
   "author": "Llorx",
   "license": "MIT",
@@ -36,6 +36,7 @@
   "homepage": "https://github.com/Llorx/flanders#readme",
   "devDependencies": {
     "@types/node": "^22.7.8",
+    "@xterm/headless": "^6.0.0",
     "arrange-act-assert": "^2.11.1",
     "typescript": "^6.0.3"
   }

package/lib/Claude.d.ts

@@ -1,129 +0,0 @@
-import type { ClaudeContext, TimeContext } from "./contexts";
-export type ClaudeResult = Readonly<{
-    text: string;
-    sessionId: string | null;
-    inputTokens: number;
-    outputTokens: number;
-}>;
-export type ClaudeContentBlock = Readonly<{
-    type?: string;
-    text?: string;
-    thinking?: string;
-    name?: string;
-    id?: string;
-    input?: Readonly<Record<string, unknown>>;
-    tool_use_id?: string;
-    content?: string | ReadonlyArray<Readonly<{
-        type?: string;
-        text?: string;
-    }>>;
-    is_error?: boolean;
-}>;
-export type ClaudeDelta = Readonly<{
-    type?: string;
-    text?: string;
-    partial_json?: string;
-}>;
-export type ClaudeControlRequestBody = Readonly<{
-    subtype?: string;
-    request_id?: string;
-    tool_name?: string;
-    input?: unknown;
-    tool_input?: unknown;
-}>;
-export type ClaudeEvent = Readonly<{
-    type?: string;
-    subtype?: string;
-    is_error?: boolean;
-    api_error_status?: number | null;
-    session_id?: string;
-    index?: number;
-    request_id?: string;
-    request?: ClaudeControlRequestBody;
-    message?: Readonly<{
-        role?: string;
-        content?: ReadonlyArray<ClaudeContentBlock>;
-        usage?: Readonly<{
-            input_tokens?: number;
-            output_tokens?: number;
-            cache_creation_input_tokens?: number;
-            cache_read_input_tokens?: number;
-        }>;
-    }>;
-    content_block?: ClaudeContentBlock;
-    delta?: ClaudeDelta;
-    event?: ClaudeEvent;
-    error?: Readonly<{
-        message?: string;
-    }>;
-    result?: string;
-    usage?: Readonly<{
-        input_tokens?: number;
-        output_tokens?: number;
-        cache_creation_input_tokens?: number;
-        cache_read_input_tokens?: number;
-    }>;
-    rate_limit_info?: Readonly<{
-        status?: string;
-        resetsAt?: number;
-        rateLimitType?: string;
-        isUsingOverage?: boolean;
-        overageStatus?: string;
-        overageResetsAt?: number;
-        utilization?: number;
-        surpassedThreshold?: number;
-    }>;
-}>;
-export type PermissionRequest = Readonly<{
-    request_id: string;
-    tool_name: string;
-    tool_input: unknown;
-}>;
-export type PermissionResponse = Readonly<{
-    behavior: "allow";
-    updatedInput?: unknown;
-    updated_permissions?: readonly unknown[];
-}> | Readonly<{
-    behavior: "deny";
-    message: string;
-    interrupt?: boolean;
-}>;
-export type ClaudeRunOptions = Readonly<{
-    prompt: string;
-    cwd?: string;
-    initialSessionId?: string | null;
-    forkFromSessionId?: string | null;
-    onEvent?(event: ClaudeEvent): void;
-    onStderr?(chunk: string): void;
-    onPermissionRequest?(req: PermissionRequest): Promise<PermissionResponse>;
-    onLongWaitStart?(kind: "rate-limit", endTimeMs: number): void;
-    onLongWaitEnd?(): void;
-}>;
-export declare class NonRetryableError extends Error {
-    constructor(message: string);
-}
-export declare class Claude {
-    readonly options: ClaudeRunOptions;
-    private _context;
-    private _time;
-    private _disposed;
-    private _process;
-    private _waitAbort;
-    private _runPromise;
-    private _sessionId;
-    private _forkFromSessionId;
-    private _killTimer;
-    private _transientAttempt;
-    constructor(options: ClaudeRunOptions, _context: ClaudeContext, _time: TimeContext);
-    result(): Promise<ClaudeResult>;
-    sendUserMessage(content: string): void;
-    sendControlResponse(requestId: string, response: PermissionResponse): void;
-    endSession(): void;
-    private _writeStdin;
-    private _run;
-    private _runOnce;
-    private _attachStreamParser;
-    private _scheduleWait;
-    private _handleControlRequest;
-    dispose(): Promise<void>;
-}