@lsctech/polaris 0.1.0

package/dist/loop/ledger.test.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const vitest_1 = require("vitest");
+const ledger_js_1 = require("./ledger.js");
+const tempDirs = [];
+(0, vitest_1.afterEach)(() => {
+    for (const dir of tempDirs.splice(0)) {
+        (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    }
+});
+function makeTempDir() {
+    const dir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "polaris-ledger-"));
+    tempDirs.push(dir);
+    return dir;
+}
+function ledgerPath() {
+    return (0, node_path_1.join)(makeTempDir(), "nested", "ledger.jsonl");
+}
+function event(overrides = {}) {
+    return {
+        schema_version: 1,
+        event_id: `event-${Math.random().toString(36).slice(2)}`,
+        event: "run-started",
+        run_id: "run-1",
+        run_type: "implement",
+        cluster_id: "POL-151",
+        issue_id: "POL-153",
+        branch: "feature/pol-151",
+        status: "running",
+        completed_children: [],
+        open_children: ["POL-153"],
+        next_child: "POL-153",
+        last_commit: null,
+        pr_url: null,
+        timestamp: "2026-05-28T03:16:13.194Z",
+        ...overrides,
+    };
+}
+(0, vitest_1.describe)("LedgerWriter", () => {
+    (0, vitest_1.it)("defaults to the global Polaris ledger path", () => {
+        (0, vitest_1.expect)(ledger_js_1.DEFAULT_LEDGER_PATH).toBe(".polaris/runs/ledger.jsonl");
+    });
+    (0, vitest_1.it)("appends one JSONL line to the configured ledger file", () => {
+        const path = ledgerPath();
+        const writer = new ledger_js_1.LedgerWriter(path);
+        const entry = event();
+        writer.append(entry);
+        const lines = (0, node_fs_1.readFileSync)(path, "utf-8").trim().split("\n");
+        (0, vitest_1.expect)(lines).toHaveLength(1);
+        (0, vitest_1.expect)(JSON.parse(lines[0])).toEqual(entry);
+    });
+    (0, vitest_1.it)("readAll parses all ledger events", () => {
+        const writer = new ledger_js_1.LedgerWriter(ledgerPath());
+        const first = event({ event_id: "1", run_id: "run-1" });
+        const second = event({ event_id: "2", run_id: "run-2", cluster_id: "POL-200" });
+        writer.append(first);
+        writer.append(second);
+        (0, vitest_1.expect)(writer.readAll()).toEqual([first, second]);
+    });
+    (0, vitest_1.it)("queryByIssue returns events for a matching cluster_id", () => {
+        const writer = new ledger_js_1.LedgerWriter(ledgerPath());
+        const matching = event({ event_id: "1", cluster_id: "POL-151" });
+        const other = event({ event_id: "2", cluster_id: "POL-200" });
+        writer.append(matching);
+        writer.append(other);
+        (0, vitest_1.expect)(writer.queryByIssue("POL-151")).toEqual([matching]);
+    });
+    (0, vitest_1.it)("queryOpenRuns returns the latest event per run_id when status is not complete or finalized", () => {
+        const writer = new ledger_js_1.LedgerWriter(ledgerPath());
+        const staleOpen = event({ event_id: "1", run_id: "run-open", status: "running" });
+        const latestOpen = event({
+            event_id: "2",
+            event: "run-paused",
+            run_id: "run-open",
+            status: "paused",
+            pause_reason: "handoff",
+        });
+        const complete = event({
+            event_id: "3",
+            event: "run-complete",
+            run_id: "run-complete",
+            status: "complete",
+            open_children: [],
+            next_child: null,
+        });
+        const finalized = event({
+            event_id: "4",
+            event: "finalized",
+            run_id: "run-finalized",
+            status: "finalized",
+            finalize_result: { ok: true },
+        });
+        writer.append(staleOpen);
+        writer.append(latestOpen);
+        writer.append(complete);
+        writer.append(finalized);
+        (0, vitest_1.expect)(writer.queryOpenRuns()).toEqual([latestOpen]);
+    });
+    (0, vitest_1.it)("returns empty arrays when the ledger file does not exist", () => {
+        const writer = new ledger_js_1.LedgerWriter(ledgerPath());
+        (0, vitest_1.expect)(writer.readAll()).toEqual([]);
+        (0, vitest_1.expect)(writer.queryByIssue("POL-151")).toEqual([]);
+        (0, vitest_1.expect)(writer.queryOpenRuns()).toEqual([]);
+    });
+    (0, vitest_1.it)("keeps concurrent appends as complete JSONL lines without lost events", async () => {
+        const path = ledgerPath();
+        const writers = Array.from({ length: 25 }, () => new ledger_js_1.LedgerWriter(path));
+        const entries = writers.map((_, index) => event({
+            event_id: `event-${index}`,
+            run_id: `run-${index}`,
+            cluster_id: index % 2 === 0 ? "POL-151" : "POL-200",
+        }));
+        await Promise.all(entries.map((entry, index) => new Promise((resolve) => {
+            setImmediate(() => {
+                writers[index].append(entry);
+                resolve();
+            });
+        })));
+        const lines = (0, node_fs_1.readFileSync)(path, "utf-8").trim().split("\n");
+        const parsed = lines.map((line) => JSON.parse(line));
+        (0, vitest_1.expect)(parsed).toHaveLength(entries.length);
+        (0, vitest_1.expect)(new Set(parsed.map((entry) => entry.event_id))).toEqual(new Set(entries.map((entry) => entry.event_id)));
+    });
+});

package/dist/loop/lifecycle-dispatch.js

@@ -0,0 +1,348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLifecycleProvider = resolveLifecycleProvider;
+exports.dispatchLifecyclePhase = dispatchLifecyclePhase;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../cognition/index.js");
+const worker_packet_js_1 = require("./worker-packet.js");
+function appendTelemetry(telemetryFile, event) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(telemetryFile), { recursive: true });
+    (0, node_fs_1.appendFileSync)(telemetryFile, JSON.stringify(event) + "\n", "utf-8");
+}
+function roleForPhase(phase) {
+    return phase === "startup" ? "startup" : "finalize";
+}
+function executionRoleForPhase(phase) {
+    return phase === "startup" ? "startup" : "finalizer";
+}
+function firstConfiguredProvider(execution) {
+    return (execution.rotation?.[0] ??
+        Object.keys(execution.providers ?? {})[0] ??
+        "default");
+}
+function materializeRoleProvider(execution, roleName, roleConfig) {
+    const provider = roleConfig?.provider ?? firstConfiguredProvider(execution);
+    if (!roleConfig?.command) {
+        return provider;
+    }
+    // Create a new provider key to avoid mutating shared config
+    const newProviderKey = `${provider}#${roleName}`;
+    const existingConfig = execution.providers?.[provider] ?? {};
+    execution.providers = {
+        ...(execution.providers ?? {}),
+        [newProviderKey]: {
+            ...existingConfig,
+            command: roleConfig.command,
+            args: roleConfig.args,
+        },
+    };
+    return newProviderKey;
+}
+function resolveLifecycleProvider(config, phase) {
+    const execution = config.execution;
+    const roleName = executionRoleForPhase(phase);
+    const roles = execution.roles ?? {};
+    const roleConfig = roles[roleName];
+    const provider = materializeRoleProvider(execution, roleName, roleConfig);
+    return {
+        adapter: roleConfig?.adapter ?? execution.adapter ?? "terminal-cli",
+        provider,
+        model: roleConfig?.model,
+    };
+}
+function resultPath(options) {
+    if (options.resultFile) {
+        return options.resultFile;
+    }
+    return (0, node_path_1.join)((0, node_path_1.dirname)(options.telemetryFile), `${options.phase}-result-${(0, node_crypto_1.randomUUID)()}.json`);
+}
+function compilePacket(options, sealedResultFile, model) {
+    const base = {
+        runId: options.runId,
+        clusterId: options.clusterId,
+        branch: options.branch,
+        stateFile: options.stateFile,
+        telemetryFile: options.telemetryFile,
+        resultFile: sealedResultFile,
+    };
+    const packet = options.phase === "startup"
+        ? (0, worker_packet_js_1.compileStartupPacket)(base)
+        : (0, worker_packet_js_1.compileFinalizePacket)({
+            ...base,
+            targetBranch: options.config.finalize?.targetBranch,
+        });
+    return {
+        ...packet,
+        context: {
+            ...(packet.context ?? {}),
+            model,
+        },
+    };
+}
+function parseResultFile(path) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        return { ok: false, error: "missing_result", message: `Sealed lifecycle result file is missing: ${path}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(path, "utf-8"));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: "malformed_result", message: `Sealed lifecycle result file is malformed JSON: ${msg}` };
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return { ok: false, error: "malformed_result", message: "Sealed lifecycle result file must contain a JSON object" };
+    }
+    return { ok: true, value: parsed };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function readBoolean(value) {
+    return value === true;
+}
+function readStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : [];
+}
+function resolveRepoRoot(options) {
+    if (options.repoRoot) {
+        return options.repoRoot;
+    }
+    let current = (0, node_path_1.dirname)(options.stateFile);
+    while (true) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(current, ".git")) || (0, node_fs_1.existsSync)((0, node_path_1.join)(current, "package.json"))) {
+            return current;
+        }
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            return (0, node_path_1.dirname)(options.stateFile);
+        }
+        current = parent;
+    }
+}
+function deriveCognitionArchiveOptions(result, repoRoot) {
+    const candidate = isRecord(result.cognition_archive)
+        ? result.cognition_archive
+        : isRecord(result.cognition_reconcile)
+            ? result.cognition_reconcile
+            : result;
+    const reconcileId = readString(candidate.reconcile_id) ?? readString(candidate.reconcileId);
+    const runId = readString(result.run_id) ?? readString(candidate.run_id) ?? readString(candidate.runId);
+    const notesConsumed = readStringArray(candidate.notes_consumed
+        ?? candidate.notesConsumed
+        ?? candidate.note_paths
+        ?? candidate.notePaths
+        ?? candidate.consumed_notes);
+    if (!reconcileId || !runId || notesConsumed.length === 0) {
+        return null;
+    }
+    const status = readString(candidate.archive_status)
+        ?? readString(candidate.reconcile_status)
+        ?? readString(candidate.result)
+        ?? readString(candidate.status);
+    return {
+        repoRoot,
+        reconcileId,
+        runId,
+        notesConsumed,
+        polarisMdUpdated: readBoolean(candidate.polaris_md_updated ?? candidate.polarisMdUpdated),
+        summaryMdUpdated: readBoolean(candidate.summary_md_updated ?? candidate.summaryMdUpdated),
+        reconciledAt: readString(candidate.reconciled_at) ?? readString(candidate.reconciledAt),
+        status: candidate.rejected === true
+            || candidate.applied === false
+            || candidate.accepted === false
+            || status === "rejected"
+            ? "rejected"
+            : "applied",
+        rejectionReason: readString(candidate.reason)
+            ?? readString(candidate.rejection_reason)
+            ?? readString(candidate.error_message),
+        result,
+    };
+}
+function validateLifecycleResult(result, packet) {
+    if (result["run_id"] !== packet.run_id) {
+        return {
+            ok: false,
+            error: "mismatched_result",
+            message: `Lifecycle result run_id mismatch: expected ${packet.run_id}, got ${String(result["run_id"])}`,
+        };
+    }
+    const returnedRole = result["role"];
+    if (returnedRole !== undefined && returnedRole !== packet.worker_role) {
+        return {
+            ok: false,
+            error: "mismatched_result",
+            message: `Lifecycle result role mismatch: expected ${packet.worker_role}, got ${String(returnedRole)}`,
+        };
+    }
+    if (result["status"] !== "success") {
+        return {
+            ok: false,
+            error: "failed_result",
+            message: `Lifecycle result status is not success: ${String(result["status"])}`,
+        };
+    }
+    return { ok: true };
+}
+async function dispatchLifecyclePhase(options) {
+    const role = roleForPhase(options.phase);
+    const resolved = resolveLifecycleProvider(options.config, options.phase);
+    const sealedResultFile = resultPath(options);
+    const packet = compilePacket(options, sealedResultFile, resolved.model);
+    appendTelemetry(options.telemetryFile, {
+        event: "lifecycle-dispatched",
+        run_id: options.runId,
+        cluster_id: options.clusterId,
+        role,
+        phase: options.phase,
+        adapter: resolved.adapter,
+        provider: resolved.provider,
+        model: resolved.model ?? null,
+        result_file: sealedResultFile,
+        timestamp: new Date().toISOString(),
+    });
+    let dispatchResult;
+    try {
+        // Use the resolved adapter instead of options.adapter
+        const adapterToUse = options.adapter; // Note: resolved.adapter is the name string, not the adapter instance
+        dispatchResult = await adapterToUse.dispatch(packet, {
+            provider: resolved.provider,
+            dryRun: options.dryRun,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        appendTelemetry(options.telemetryFile, {
+            event: "lifecycle-result-rejected",
+            run_id: options.runId,
+            role,
+            error: "adapter_error",
+            message: `Adapter threw exception: ${message}`,
+            timestamp: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            role,
+            provider: resolved.provider,
+            model: resolved.model,
+            resultFile: sealedResultFile,
+            error: "adapter_error",
+            message: `Adapter threw exception: ${message}`,
+        };
+    }
+    if (dispatchResult.exit_code !== 0) {
+        const message = dispatchResult.summary ?? `Lifecycle ${role} dispatch exited with code ${dispatchResult.exit_code}`;
+        appendTelemetry(options.telemetryFile, {
+            event: "lifecycle-result-rejected",
+            run_id: options.runId,
+            role,
+            error: "adapter_error",
+            message,
+            timestamp: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            role,
+            provider: resolved.provider,
+            model: resolved.model,
+            resultFile: sealedResultFile,
+            error: "adapter_error",
+            message,
+        };
+    }
+    const parsed = parseResultFile(sealedResultFile);
+    if (!parsed.ok) {
+        appendTelemetry(options.telemetryFile, {
+            event: "lifecycle-result-rejected",
+            run_id: options.runId,
+            role,
+            error: parsed.error,
+            message: parsed.message,
+            result_file: sealedResultFile,
+            timestamp: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            role,
+            provider: resolved.provider,
+            model: resolved.model,
+            resultFile: sealedResultFile,
+            error: parsed.error,
+            message: parsed.message,
+        };
+    }
+    const validation = validateLifecycleResult(parsed.value, packet);
+    if (!validation.ok) {
+        appendTelemetry(options.telemetryFile, {
+            event: "lifecycle-result-rejected",
+            run_id: options.runId,
+            role,
+            error: validation.error,
+            message: validation.message,
+            result_file: sealedResultFile,
+            timestamp: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            role,
+            provider: resolved.provider,
+            model: resolved.model,
+            resultFile: sealedResultFile,
+            error: validation.error,
+            message: validation.message,
+        };
+    }
+    try {
+        if (options.phase === "finalize") {
+            const cognitionArchiveOptions = deriveCognitionArchiveOptions(parsed.value, resolveRepoRoot(options));
+            if (cognitionArchiveOptions) {
+                (0, index_js_1.archiveCognitionNotes)(cognitionArchiveOptions);
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        appendTelemetry(options.telemetryFile, {
+            event: "lifecycle-result-rejected",
+            run_id: options.runId,
+            role,
+            error: "failed_result",
+            message: `Lifecycle post-validation apply failed: ${message}`,
+            result_file: sealedResultFile,
+            timestamp: new Date().toISOString(),
+        });
+        return {
+            ok: false,
+            role,
+            provider: resolved.provider,
+            model: resolved.model,
+            resultFile: sealedResultFile,
+            error: "failed_result",
+            message: `Lifecycle post-validation apply failed: ${message}`,
+        };
+    }
+    appendTelemetry(options.telemetryFile, {
+        event: "lifecycle-result-accepted",
+        run_id: options.runId,
+        role,
+        result_file: sealedResultFile,
+        timestamp: new Date().toISOString(),
+    });
+    return {
+        ok: true,
+        role,
+        provider: resolved.provider,
+        model: resolved.model,
+        resultFile: sealedResultFile,
+        result: parsed.value,
+    };
+}