@mikenguyen69/harness 0.1.0-beta.1

package/dist/internal/orchestration/harness/shim.js

@@ -0,0 +1,182 @@
+/**
+ * shim — the text-output adapter for `harness next` / `harness claim`, used
+ * until SH P7.4 (`--json` on both) lands. ISOLATED HERE ON PURPOSE: when the
+ * JSON flags ship, this file is deleted and `ShimHarness` is replaced by a
+ * straight JSON-parsing `CliHarness`. Nothing else in the loop imports it.
+ *
+ * Current text shapes it parses (from repos/system-harness/src/sequencer/cli.ts):
+ *   `harness next`              → `component#id\n` lines on stdout, `no ready units` on stderr
+ *   `harness next --escalated`  → same, `no escalated units` on stderr
+ *   `harness claim <id> --session <s>` → `claimed <id> by <s> (seq N)\n`, exit 0/1
+ *
+ * The text carries no deps and no mode, so shimmed `next()` returns
+ * `deps: []` and `mode: "build"` for every unit — a known degradation. explore
+ * parking and dep ordering are only correct once P7.4 delivers structured data;
+ * the FakeHarness (which the M1 dry loop actually exercises) has both.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const run = promisify(execFile);
+export class ShimHarness {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    base() {
+        return this.opts.ledgerDir ? ["--ledger", this.opts.ledgerDir] : [];
+    }
+    async call(args) {
+        try {
+            const { stdout, stderr } = await run(this.opts.bin, args, {
+                cwd: this.opts.cwd,
+            });
+            return { code: 0, stdout, stderr };
+        }
+        catch (e) {
+            const err = e;
+            return {
+                code: typeof err.code === "number" ? err.code : 1,
+                stdout: err.stdout ?? "",
+                stderr: err.stderr ?? "",
+            };
+        }
+    }
+    parseLines(stdout) {
+        return stdout
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const hash = line.indexOf("#");
+            return hash >= 0
+                ? {
+                    component: line.slice(0, hash),
+                    id: line.slice(hash + 1),
+                    deps: [],
+                    mode: "build",
+                }
+                : { id: line, deps: [], mode: "build" };
+        });
+    }
+    async next(opts) {
+        const args = ["next", ...this.base()];
+        if (opts?.only)
+            args.push("--only", opts.only);
+        const { stdout } = await this.call(args);
+        return this.parseLines(stdout);
+    }
+    async escalated() {
+        const { stdout } = await this.call(["next", "--escalated", ...this.base()]);
+        return this.parseLines(stdout);
+    }
+    async units() {
+        // The current CLI has no structured status query, so the shim cannot feed
+        // the startup sweep. It returns `[]` — the sweep is a no-op behind the shim
+        // and only fully functional against the FakeHarness (dry loop) or a real
+        // status surface. Filling this is P7.4-adjacent system-harness work.
+        return [];
+    }
+    async claim(unitId, session) {
+        const { code } = await this.call([
+            "claim",
+            unitId,
+            "--session",
+            session,
+            ...this.base(),
+        ]);
+        if (code !== 0)
+            return null;
+        // The text `claim` returns no briefing body. Until P7.4, the caller must
+        // treat a shimmed claim as "took the unit" only; briefing fields are unknown
+        // and the loop cannot run a real dispatch off it. This is why M2 is blocked
+        // on P7.4, not on this shim.
+        return {
+            unitId,
+            intent: "(shim: briefing unavailable until harness claim --json — SH P7.4)",
+            acceptanceCriteria: [],
+            scope: [],
+            branch: `unit/${unitId}`,
+            mergeFacts: {},
+        };
+    }
+    async heartbeat(unitId, session) {
+        await this.call(["heartbeat", unitId, "--session", session, ...this.base()]);
+    }
+    async ledgerAppend(event) {
+        await this.call([
+            "ledger",
+            "append",
+            "--type",
+            event.type,
+            "--unit",
+            event.unitId,
+            ...(event.session ? ["--session", event.session] : []),
+            ...(event.body ? ["--body", JSON.stringify(event.body)] : []),
+            ...this.base(),
+        ]);
+    }
+    async verify(unitId) {
+        const { code, stdout, stderr } = await this.call([
+            "verify",
+            "--unit",
+            unitId,
+            ...this.base(),
+        ]);
+        if (code === 0)
+            return { status: "pass" };
+        if (code === 2)
+            return { status: "halt", evidence: stderr || stdout };
+        return { status: "fail", evidence: stderr || stdout };
+    }
+    async verifySystem(unitId, systemToml) {
+        const { code, stdout, stderr } = await this.call([
+            "verify",
+            "--unit",
+            unitId,
+            "--system",
+            systemToml,
+            ...this.base(),
+        ]);
+        if (code === 0)
+            return { status: "pass" };
+        if (code === 2)
+            return { status: "halt", evidence: stderr || stdout };
+        return { status: "fail", evidence: stderr || stdout };
+    }
+    async merge(unitId, landedSha, facts) {
+        const flags = [];
+        if (facts.door === "one-way")
+            flags.push("--one-way");
+        if (facts.door === "two-way")
+            flags.push("--two-way");
+        if (facts.addsDependency)
+            flags.push("--adds-dependency");
+        if (facts.schemaChange)
+            flags.push("--schema-change");
+        if (facts.security)
+            flags.push("--security");
+        if (facts.gateExternal)
+            flags.push("--gate-external");
+        if (facts.artifactProducerChange)
+            flags.push("--artifact-producer-change");
+        if (facts.mode)
+            flags.push("--mode", facts.mode);
+        const { code, stdout, stderr } = await this.call([
+            "merge",
+            unitId,
+            "--landed",
+            landedSha,
+            ...flags,
+            ...this.base(),
+        ]);
+        if (code === 0)
+            return { status: "merged", landedSha };
+        return {
+            status: "door-open",
+            doorId: `${unitId}#door`,
+            unblock: (stderr || stdout).trim() ||
+                `harness door approve ${unitId} --reason "<why>" --who <operator>`,
+        };
+    }
+}
+//# sourceMappingURL=shim.js.map

package/dist/internal/orchestration/index.js

@@ -0,0 +1,29 @@
+/**
+ * @harness/orchestration — the execution loop.
+ *
+ * Public surface (v0): the loop primitives and their injectable fakes. The
+ * `orchestrate` CLI (./cli.ts) is the runnable entrypoint.
+ */
+export * from "./harness/index.js";
+export * from "./harness/cli.js";
+export * from "./routes/index.js";
+export * from "./runner/index.js";
+export * from "./runstate/index.js";
+export * from "./runstate/publish.js";
+export * from "./loop/index.js";
+export * from "./git/index.js";
+export * from "./config/index.js";
+export * from "./forge/index.js";
+export * from "./run/index.js";
+export * from "./worktree/index.js";
+export * from "./report/index.js";
+export * from "./prompts/index.js";
+export * from "./runners/telemetry.js";
+export * from "./runners/conformance/index.js";
+export { ClaudeRunner } from "./runners/claude/index.js";
+export { CodexRunner } from "./runners/codex/index.js";
+export { CursorRunner } from "./runners/cursor/index.js";
+export { runCodexExec, foldCodexStream, } from "./runners/codex/exec.js";
+export { runCursorAgent, foldCursorOutput, } from "./runners/cursor/exec.js";
+export { runClaudeSession, } from "./runners/claude/sdk.js";
+//# sourceMappingURL=index.js.map