@lsctech/polaris 0.1.0

package/dist/loop/status.test.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const status_js_1 = require("./status.js");
+function makeTestDir() {
+    const dir = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `polaris-status-test-${Date.now()}`);
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_child_process_1.execFileSync)("git", ["init"], { cwd: dir });
+    (0, node_child_process_1.execFileSync)("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+    (0, node_child_process_1.execFileSync)("git", ["config", "user.name", "Test"], { cwd: dir });
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, "README.md"), "test\n");
+    (0, node_child_process_1.execFileSync)("git", ["add", "."], { cwd: dir });
+    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", "init"], { cwd: dir });
+    return dir;
+}
+function writeState(dir, state) {
+    const stateFile = (0, node_path_1.join)(dir, ".polaris", "runs", "current-state.json");
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(dir, ".polaris", "runs"), { recursive: true });
+    (0, node_fs_1.writeFileSync)(stateFile, JSON.stringify(state, null, 2));
+    return stateFile;
+}
+function shaOf(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function writePacket(dir, packet) {
+    const bootstrapDir = (0, node_path_1.join)(dir, ".polaris", "bootstrap");
+    (0, node_fs_1.mkdirSync)(bootstrapDir, { recursive: true });
+    const filename = `${packet.run_id}-2026-01-01T00-00-00-000Z.json`;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(bootstrapDir, filename), JSON.stringify(packet, null, 2));
+}
+const baseState = {
+    schema_version: "1.0",
+    run_id: "pol-5-session-1",
+    cluster_id: "POL-5",
+    session_type: "implement",
+    active_child: "POL-26",
+    completed_children: ["POL-23", "POL-24", "POL-25"],
+    open_children: ["POL-26", "POL-27"],
+    step_cursor: "implement-child",
+    context_budget: { children_completed: 3, max_children_per_session: 3 },
+    status: "running",
+    next_open_child: "POL-26",
+};
+(0, vitest_1.describe)("runLoopStatus", () => {
+    let testDir;
+    (0, vitest_1.beforeEach)(() => {
+        testDir = makeTestDir();
+    });
+    (0, vitest_1.afterEach)(() => {
+        (0, node_fs_1.rmSync)(testDir, { recursive: true, force: true });
+    });
+    (0, vitest_1.it)("prints human-readable status from state file", () => {
+        const stateFile = writeState(testDir, baseState);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = orig;
+        }
+        const output = logs.join("\n");
+        (0, vitest_1.expect)(output).toContain("Polaris Loop Status");
+        (0, vitest_1.expect)(output).toContain("pol-5-session-1");
+        (0, vitest_1.expect)(output).toContain("POL-5");
+        (0, vitest_1.expect)(output).toContain("implement");
+        (0, vitest_1.expect)(output).toContain("POL-26");
+        (0, vitest_1.expect)(output).toContain("POL-23, POL-24, POL-25");
+        (0, vitest_1.expect)(output).toContain("Blocked:         none");
+    });
+    (0, vitest_1.it)("emits JSON output with --json flag", () => {
+        const stateFile = writeState(testDir, baseState);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile, json: true });
+        }
+        finally {
+            console.log = orig;
+        }
+        const parsed = JSON.parse(logs.join("\n"));
+        (0, vitest_1.expect)(parsed.run_id).toBe("pol-5-session-1");
+        (0, vitest_1.expect)(parsed.completed_children).toEqual(["POL-23", "POL-24", "POL-25"]);
+        (0, vitest_1.expect)(parsed.open_children).toEqual(["POL-26", "POL-27"]);
+        (0, vitest_1.expect)(parsed.deadlock).toBe(false);
+    });
+    (0, vitest_1.it)("reports bootstrap packet as fresh when SHA matches", () => {
+        const stateFile = writeState(testDir, baseState);
+        const stateContent = JSON.stringify(baseState, null, 2);
+        const sha = shaOf(stateContent);
+        const packet = {
+            run_id: "pol-5-session-1",
+            skill: "bootstrap-run",
+            branch: "main",
+            base_commit_sha: "abc123",
+            last_completed_step: "checkpoint",
+            last_completed_child: "POL-25",
+            next_step: "03-execute-child",
+            open_children: ["POL-26", "POL-27"],
+            artifact_pointers: {
+                current_state: stateFile,
+                telemetry: "/tmp/telemetry.jsonl",
+            },
+            context_budget: { children_completed: 3, files_touched_total: 0, stop_threshold_remaining: 0 },
+            current_state_sha: sha,
+            resume_instructions: "Run polaris loop resume",
+        };
+        writePacket(testDir, packet);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = orig;
+        }
+        (0, vitest_1.expect)(logs.join("\n")).toContain("(fresh)");
+        (0, vitest_1.expect)(logs.join("\n")).toContain("matches current-state.json ✓");
+    });
+    (0, vitest_1.it)("reports bootstrap packet as stale when SHA mismatches", () => {
+        const stateFile = writeState(testDir, baseState);
+        const packet = {
+            run_id: "pol-5-session-1",
+            skill: "bootstrap-run",
+            branch: "main",
+            base_commit_sha: "abc123",
+            last_completed_step: "checkpoint",
+            last_completed_child: "POL-25",
+            next_step: "03-execute-child",
+            open_children: ["POL-26", "POL-27"],
+            artifact_pointers: {
+                current_state: stateFile,
+                telemetry: "/tmp/telemetry.jsonl",
+            },
+            context_budget: { children_completed: 3, files_touched_total: 0, stop_threshold_remaining: 0 },
+            current_state_sha: "wrongsha",
+            resume_instructions: "Run polaris loop resume",
+        };
+        writePacket(testDir, packet);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = orig;
+        }
+        (0, vitest_1.expect)(logs.join("\n")).toContain("stale");
+        (0, vitest_1.expect)(logs.join("\n")).toContain("MISMATCH");
+    });
+    (0, vitest_1.it)("detects deadlock when all open children are blocked", () => {
+        const deadlockState = {
+            ...baseState,
+            open_children: ["POL-26"],
+            blocked_children: ["POL-26"],
+        };
+        const stateFile = writeState(testDir, deadlockState);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = orig;
+        }
+        (0, vitest_1.expect)(logs.join("\n")).toContain("DEADLOCK DETECTED");
+        (0, vitest_1.expect)(logs.join("\n")).toContain("POL-26 — blocked");
+        (0, vitest_1.expect)(logs.join("\n")).toContain("polaris loop resume");
+    });
+    (0, vitest_1.it)("reports no deadlock when only some children are blocked", () => {
+        const partialBlockState = {
+            ...baseState,
+            open_children: ["POL-26", "POL-27"],
+            blocked_children: ["POL-27"],
+        };
+        const stateFile = writeState(testDir, partialBlockState);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile });
+        }
+        finally {
+            console.log = orig;
+        }
+        (0, vitest_1.expect)(logs.join("\n")).not.toContain("DEADLOCK DETECTED");
+    });
+    (0, vitest_1.it)("exits with error when state file is missing", () => {
+        const exitSpy = vitest_1.vi.spyOn(process, "exit").mockImplementation(() => {
+            throw new Error("process.exit called");
+        });
+        const errSpy = vitest_1.vi.spyOn(console, "error").mockImplementation(() => { });
+        try {
+            (0, vitest_1.expect)(() => (0, status_js_1.runLoopStatus)({
+                repoRoot: testDir,
+                stateFile: (0, node_path_1.join)(testDir, "nonexistent.json"),
+            })).toThrow();
+            (0, vitest_1.expect)(errSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("cannot read state file"));
+        }
+        finally {
+            exitSpy.mockRestore();
+            errSpy.mockRestore();
+        }
+    });
+    (0, vitest_1.it)("includes deadlock info in JSON output", () => {
+        const deadlockState = {
+            ...baseState,
+            open_children: ["POL-26"],
+            blocked_children: ["POL-26"],
+        };
+        const stateFile = writeState(testDir, deadlockState);
+        const logs = [];
+        const orig = console.log;
+        console.log = (...args) => logs.push(args.map(String).join(" "));
+        try {
+            (0, status_js_1.runLoopStatus)({ repoRoot: testDir, stateFile, json: true });
+        }
+        finally {
+            console.log = orig;
+        }
+        const parsed = JSON.parse(logs.join("\n"));
+        (0, vitest_1.expect)(parsed.deadlock).toBe(true);
+        (0, vitest_1.expect)(parsed.blocked_children).toEqual(["POL-26"]);
+    });
+});

package/dist/loop/wait.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoopWait = runLoopWait;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const checkpoint_js_1 = require("./checkpoint.js");
+function runLoopWait(options) {
+    const timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;
+    const pollIntervalMs = options.pollIntervalMs ?? 5_000;
+    let state;
+    try {
+        state = (0, checkpoint_js_1.readState)(options.stateFile);
+    }
+    catch (err) {
+        process.stderr.write(`Error: cannot read state file: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    }
+    const childId = options.childId ?? state.active_child;
+    if (!childId) {
+        process.stdout.write(JSON.stringify({ status: "no-active-child" }) + "\n");
+        return;
+    }
+    const meta = state.open_children_meta?.[childId];
+    const rawResultPath = meta?.dispatch_record?.expected_result_path ?? meta?.result_file;
+    if (!rawResultPath) {
+        process.stderr.write(`Error: no expected_result_path found for child ${childId}\n`);
+        process.exit(1);
+    }
+    const resultPath = (0, node_path_1.isAbsolute)(rawResultPath)
+        ? rawResultPath
+        : (0, node_path_1.resolve)(options.repoRoot, rawResultPath);
+    if ((0, node_fs_1.existsSync)(resultPath)) {
+        process.stdout.write(JSON.stringify({ status: "result-ready", child_id: childId, result_path: resultPath }) + "\n");
+        return;
+    }
+    process.stderr.write(`Waiting for result file: ${resultPath}\n`);
+    process.stderr.write(`Child: ${childId} | Timeout: ${timeoutMs}ms\n`);
+    const deadline = Date.now() + timeoutMs;
+    let watcher;
+    let pollTimer;
+    let resolved = false;
+    function succeed() {
+        if (resolved)
+            return;
+        resolved = true;
+        watcher?.close();
+        if (pollTimer)
+            clearInterval(pollTimer);
+        process.stdout.write(JSON.stringify({ status: "result-ready", child_id: childId, result_path: resultPath }) + "\n");
+        process.exit(0);
+    }
+    function checkTimeout() {
+        if (resolved)
+            return;
+        resolved = true;
+        watcher?.close();
+        if (pollTimer)
+            clearInterval(pollTimer);
+        process.stderr.write(`Timeout: result file not found after ${timeoutMs}ms\n`);
+        process.stdout.write(JSON.stringify({ status: "timeout", child_id: childId, result_path: resultPath }) + "\n");
+        process.exit(1);
+    }
+    pollTimer = setInterval(() => {
+        if (Date.now() > deadline) {
+            checkTimeout();
+            return;
+        }
+        if ((0, node_fs_1.existsSync)(resultPath)) {
+            succeed();
+        }
+    }, pollIntervalMs);
+    // fs.watch for faster detection
+    try {
+        const resultDir = (0, node_path_1.dirname)(resultPath);
+        const resultFile = (0, node_path_1.basename)(resultPath);
+        watcher = (0, node_fs_1.watch)(resultDir, (eventType, filename) => {
+            if (filename === resultFile && (0, node_fs_1.existsSync)(resultPath)) {
+                succeed();
+            }
+        });
+    }
+    catch {
+        // fs.watch unavailable — poll fallback is active
+    }
+    setTimeout(checkTimeout, timeoutMs);
+}