codictator 0.0.0 → 0.1.3

package/dist/kernel/stdin.js

@@ -0,0 +1,59 @@
+// SPEC §4.19.3 step 1 with §4.5.5: stdin read for the hook entry. The
+// kernel owns the OS read; the byte cap and the arrival deadline arrive
+// as data. A TTY stdin means no harness piped a payload, so it answers
+// empty without waiting. Past the cap the payload is CDX-E305; past the
+// deadline the wait is CDX-E902, so an idle pipe fails closed instead of
+// hanging the hook past its time limit. A closed or unreadable stdin is
+// no payload at all, and the caller maps that to its own empty-payload
+// error (CDX-E303 for hooks).
+import { makeError } from "./errors.js";
+import { err, ok } from "./result.js";
+function overCapError(maxBytes) {
+    return err(makeError("CDX-E305", `hook payload over ${maxBytes} bytes is refused`, "Write the file in smaller edits, then retry the tool call."));
+}
+function pastDeadlineError() {
+    return err(makeError("CDX-E902", "hook input did not arrive within the hook time limit", "Retry the tool call; if the harness stalls its hook input, report the stall."));
+}
+export function readStdinText(maxBytes, deadlineMs) {
+    if (process.stdin.isTTY === true) {
+        return Promise.resolve(ok(""));
+    }
+    return new Promise((resolve) => {
+        const chunks = [];
+        let total = 0;
+        let settled = false;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            process.stdin.removeListener("data", onData);
+            process.stdin.removeListener("end", onEnd);
+            process.stdin.removeListener("error", onError);
+            process.stdin.pause();
+            resolve(result);
+        };
+        const onData = (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                finish(overCapError(maxBytes));
+                return;
+            }
+            chunks.push(chunk);
+        };
+        const onEnd = () => {
+            finish(ok(Buffer.concat(chunks).toString("utf8")));
+        };
+        const onError = () => {
+            finish(ok(""));
+        };
+        const timer = setTimeout(() => {
+            finish(pastDeadlineError());
+        }, deadlineMs);
+        process.stdin.on("data", onData);
+        process.stdin.on("end", onEnd);
+        process.stdin.on("error", onError);
+        process.stdin.resume();
+    });
+}

package/dist/kernel/test-report.d.ts

@@ -0,0 +1,7 @@
+import { type Result } from "./result.ts";
+export interface TestCaseResult {
+    readonly id: string;
+    readonly title: string;
+    readonly outcome: "passed" | "failed" | "skipped";
+}
+export declare function readTestReport(xml: string): Result<Array<TestCaseResult>>;

package/dist/kernel/test-report.js

@@ -0,0 +1,112 @@
+// SPEC §4.1.2: minimal reader for JUnit XML and TRX so red and green
+// proofs need no runner-specific parsing (SPEC §4.10.2). No XML library is
+// used; the reader matches only the elements it owns and fails closed on
+// anything else.
+import { makeError } from "./errors.js";
+import { err, ok } from "./result.js";
+function malformed() {
+    return err(makeError("CDX-E101", "test report XML is unparseable", "Regenerate the report as JUnit or TRX XML, then retry."));
+}
+function decodeEntities(text) {
+    return text
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, "&");
+}
+function attributes(tag) {
+    const found = new Map();
+    const pattern = /([\w:.-]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+    let match = pattern.exec(tag);
+    while (match !== null) {
+        const name = match[1] ?? "";
+        const value = match[3] ?? match[4] ?? "";
+        if (!found.has(name)) {
+            found.set(name, decodeEntities(value));
+        }
+        match = pattern.exec(tag);
+    }
+    return found;
+}
+function junitOutcome(inner) {
+    if (/<skipped(?:[\s>/])/.test(inner)) {
+        return "skipped";
+    }
+    if (/<failure(?:[\s>/])/.test(inner) || /<error(?:[\s>/])/.test(inner)) {
+        return "failed";
+    }
+    return "passed";
+}
+function readJUnit(xml) {
+    const cases = [];
+    const selfClosed = /<testcase\b([^>]*?)\/>/g;
+    for (const match of xml.matchAll(selfClosed)) {
+        const attrs = attributes(match[1] ?? "");
+        const name = attrs.get("name") ?? "";
+        const classname = attrs.get("classname") ?? "";
+        cases.push({
+            id: classname === "" ? name : `${classname}#${name}`,
+            title: name,
+            outcome: "passed",
+        });
+    }
+    const stripped = xml.replace(selfClosed, "");
+    const paired = /<testcase\b([^>]*)>([\s\S]*?)<\/testcase>/g;
+    for (const match of stripped.matchAll(paired)) {
+        const attrs = attributes(match[1] ?? "");
+        const name = attrs.get("name") ?? "";
+        const classname = attrs.get("classname") ?? "";
+        cases.push({
+            id: classname === "" ? name : `${classname}#${name}`,
+            title: name,
+            outcome: junitOutcome(match[2] ?? ""),
+        });
+    }
+    return cases;
+}
+function trxOutcome(raw) {
+    const outcome = raw.toLowerCase();
+    if (outcome === "passed") {
+        return "passed";
+    }
+    if (outcome === "failed") {
+        return "failed";
+    }
+    if (outcome === "skipped" || outcome === "notexecuted") {
+        return "skipped";
+    }
+    return undefined;
+}
+function readTrx(xml) {
+    if (!/<TestRun\b/.test(xml)) {
+        return undefined;
+    }
+    const cases = [];
+    const pattern = /<UnitTestResult\b([^>]*?)\/>/g;
+    for (const match of xml.matchAll(pattern)) {
+        const attrs = attributes(match[1] ?? "");
+        const name = attrs.get("testName") ?? "";
+        const id = attrs.get("testId") ?? name;
+        const outcome = trxOutcome(attrs.get("outcome") ?? "");
+        if (outcome === undefined) {
+            return undefined;
+        }
+        cases.push({ id, title: name, outcome });
+    }
+    return cases;
+}
+export function readTestReport(xml) {
+    const text = xml.trim();
+    if (text === "") {
+        return malformed();
+    }
+    const trx = readTrx(text);
+    if (trx !== undefined) {
+        return ok(trx);
+    }
+    if (!/<testsuite\b/.test(text) && !/<testsuites\b/.test(text)) {
+        return malformed();
+    }
+    return ok(readJUnit(text));
+}

package/dist/kernel/version.d.ts

@@ -0,0 +1,2 @@
+import { type Result } from "./result.ts";
+export declare function installedEngineVersion(): Promise<Result<string>>;

package/dist/kernel/version.js

@@ -0,0 +1,46 @@
+// SPEC §4.2.1: the installed engine version. Config's `codictator` field
+// must equal this (§7.2, EC-11); the CLI resolves it once at startup and
+// threads it through, so only the kernel touches the filesystem (§3.3).
+import { fileURLToPath } from "node:url";
+import { makeError } from "./errors.js";
+import { readHostText } from "./host.js";
+import { parseJson } from "./json.js";
+import { err, ok } from "./result.js";
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// The version field of a decoded engine manifest, validated apart from
+// the manifest read below.
+function manifestVersion(raw) {
+    if (!isObject(raw)) {
+        return err(makeError("CDX-E903", "the engine manifest is not an object", "Reinstall codictator, then retry."));
+    }
+    const key = "version";
+    const version = raw[key];
+    if (typeof version !== "string" || version === "") {
+        return err(makeError("CDX-E903", "the engine manifest has no version", "Reinstall codictator, then retry."));
+    }
+    return ok(version);
+}
+// src/kernel/version.ts and dist/kernel/version.js both sit two levels
+// below the engine root, so ../../package.json names the engine manifest
+// in either layout. A missing or malformed manifest fails, and the caller
+// falls back to the pinned placeholder; tests pin the placeholder.
+export async function installedEngineVersion() {
+    let manifestPath;
+    try {
+        manifestPath = fileURLToPath(new URL("../../package.json", import.meta.url));
+    }
+    catch {
+        return err(makeError("CDX-E903", "cannot locate the engine manifest", "Reinstall codictator, then retry."));
+    }
+    const text = await readHostText(manifestPath);
+    if (!text.ok) {
+        return err(text.error);
+    }
+    const parsed = parseJson(text.value);
+    if (!parsed.ok) {
+        return err(parsed.error);
+    }
+    return manifestVersion(parsed.value);
+}