@boyingliu01/xp-gate 0.31.4 → 0.32.1

package/plugins/dsh/lib/gate-runner.js

@@ -0,0 +1,95 @@
+import { TOOL_ABORTED } from "@deepseek-ai/dsh-tools";
+import { HarnessError } from "@deepseek-ai/dsh-llm";
+/**
+ * Classify a completed shell run.
+ *
+ * The order below is load-bearing and must not be rearranged:
+ *
+ *   1. timeout / truncation  -> INDETERMINATE (a killed or clipped run yields no verdict)
+ *   2. exit 0 with no stdout -> INDETERMINATE (the command succeeded but said nothing)
+ *   3. exit 0 with stdout    -> PASS
+ *   4. otherwise             -> GATE FAILED  (nonzero with output) or INDETERMINATE (silent)
+ *
+ * Step 1 must precede step 3: a timed-out process can still report exit 0 from
+ * the state it held when the deadline killed it, so testing `exitCode === 0`
+ * first would render a timeout as a pass. That is the exact defect this project
+ * fixed in Gate 8 and Gate 10, and the plugin must not reintroduce it.
+ */
+export function classifyGateRun(result) {
+    const stdout = result.stdout.text.trim();
+    if (result.timedOut)
+        return "INDETERMINATE";
+    if (result.stdout.truncated)
+        return "INDETERMINATE";
+    if (result.exitCode === 0)
+        return stdout.length > 0 ? "PASS" : "INDETERMINATE";
+    // Nonzero: a verdict exists only when the run produced something to show.
+    const stderr = result.stderr.text.trim();
+    return stdout.length > 0 || stderr.length > 0 ? "GATE FAILED" : "INDETERMINATE";
+}
+/** Detailed diagnostics appended after the verdict line, when present. */
+function renderDetails(result) {
+    const lines = [];
+    const stdout = result.stdout.text.trim();
+    if (stdout.length > 0)
+        lines.push(stdout);
+    const stderr = result.stderr.text.trim();
+    if (stderr.length > 0)
+        lines.push(`[stderr] ${stderr}`);
+    if (result.timedOut)
+        lines.push(`[timed out after ${result.timeoutMs}ms]`);
+    if (result.exitCode !== null && result.exitCode !== 0)
+        lines.push(`[exit code: ${result.exitCode}]`);
+    if (result.signal !== null)
+        lines.push(`[signal: ${result.signal}]`);
+    if (result.sandbox?.denied === true) {
+        lines.push(`[sandbox: file access denied under ${result.sandbox.mode} mode]`);
+    }
+    if (result.stdout.truncated) {
+        const spill = result.stdout.spillPath !== undefined ? `, full output: ${result.stdout.spillPath}` : "";
+        lines.push(`[stdout truncated${spill}]`);
+    }
+    if (result.stderr.truncated) {
+        const spill = result.stderr.spillPath !== undefined ? `, full output: ${result.stderr.spillPath}` : "";
+        lines.push(`[stderr truncated${spill}]`);
+    }
+    return lines;
+}
+/** Install hint appended whenever no verdict could be reached. */
+const INDETERMINATE_HINT = "The gate produced no usable verdict. Check that the xp-gate CLI is installed " +
+    "and runnable (npm i -g @boyingliu01/xp-gate), then retry.";
+/**
+ * Render a completed shell run as model-facing text.
+ *
+ * Every run resolves to exactly one of three verdicts. A run that could not
+ * establish a verdict says INDETERMINATE and states explicitly that it is not a
+ * pass, because an empty output read as a green check is worse than no output.
+ */
+export function renderGateResult(result) {
+    const verdict = classifyGateRun(result);
+    const lines = renderDetails(result);
+    if (verdict === "PASS") {
+        return `[XP-Gate] PASS\n${lines.join("\n")}`;
+    }
+    if (verdict === "GATE FAILED") {
+        return `[XP-Gate] GATE FAILED\n${lines.join("\n")}`;
+    }
+    return [`[XP-Gate] INDETERMINATE — gate produced no output; NOT a pass`, ...lines, INDETERMINATE_HINT].join("\n");
+}
+/**
+ * Run an xp-gate command through the harness shell seam. Nonzero exits, timeouts,
+ * and sandbox denials resolve (and render) rather than reject; only cancellation
+ * (the caller's AbortSignal fired first) throws an AbortError with code ABORTED.
+ */
+export async function runXpGate(shell, signal, command, workdir, timeoutMs) {
+    const spec = shell.resolve({ command, workdir, timeoutMs, signal });
+    const execution = await shell.execute(spec);
+    const result = await execution.result();
+    if (result.aborted) {
+        const error = new HarnessError("tool call aborted", TOOL_ABORTED);
+        error.name = "AbortError";
+        throw error;
+    }
+    return renderGateResult(result);
+}
+//# sourceMappingURL=gate-runner.js.map

package/plugins/dsh/lib/git-context.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Minimal git context for evidence.
+ *
+ * @test REQ-DSH-012 delphi-review can produce Gate MW evidence
+ * @intent Read HEAD and the current branch name, which the walkthrough evidence must
+ *         name exactly, without adding a git library dependency.
+ * @covers AC-DSH-012-02
+ *
+ * Spawned git, not a parsed .git directory: worktrees and detached HEAD have
+ * layouts that are easy to misread, and getting either wrong produces evidence the
+ * validator rejects at push time with no hint about why.
+ */
+/** The two facts the validator compares against. */
+export interface GitContext {
+    readonly head: string;
+    readonly branch: string;
+}
+/**
+ * Read HEAD and the branch.
+ *
+ * The validator compares `branch` to the name the push reports; a detached HEAD
+ * reports "HEAD", which is what git itself would say, so it is passed through
+ * rather than guessed at.
+ */
+export declare function readGitContext(cwd: string): GitContext;
+//# sourceMappingURL=git-context.d.ts.map

package/plugins/dsh/lib/git-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-context.d.ts","sourceRoot":"","sources":["../src/git-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,oDAAoD;AACpD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAStD"}

package/plugins/dsh/lib/git-context.js

@@ -0,0 +1,30 @@
+/**
+ * Minimal git context for evidence.
+ *
+ * @test REQ-DSH-012 delphi-review can produce Gate MW evidence
+ * @intent Read HEAD and the current branch name, which the walkthrough evidence must
+ *         name exactly, without adding a git library dependency.
+ * @covers AC-DSH-012-02
+ *
+ * Spawned git, not a parsed .git directory: worktrees and detached HEAD have
+ * layouts that are easy to misread, and getting either wrong produces evidence the
+ * validator rejects at push time with no hint about why.
+ */
+import { execFileSync } from "node:child_process";
+/**
+ * Read HEAD and the branch.
+ *
+ * The validator compares `branch` to the name the push reports; a detached HEAD
+ * reports "HEAD", which is what git itself would say, so it is passed through
+ * rather than guessed at.
+ */
+export function readGitContext(cwd) {
+    const run = (args) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    try {
+        return { head: run(["rev-parse", "HEAD"]), branch: run(["rev-parse", "--abbrev-ref", "HEAD"]) };
+    }
+    catch (error) {
+        throw new Error(`cannot read git context in ${cwd}: ${error.message}`);
+    }
+}
+//# sourceMappingURL=git-context.js.map

package/plugins/dsh/lib/hooks.d.ts

@@ -0,0 +1,42 @@
+/**
+ * DSH-native hooks: the delphi-review guard and the save-time principles check.
+ *
+ * @test REQ-DSH-015 sprint-phase writes are gated the way the IDE plugin gates them
+ * @intent Port the Claude Code guard and save-check to DSH's own pre/post-execute
+ *         seams, keeping the degrade rules that made them safe there.
+ * @covers AC-DSH-015-01
+ *
+ * Degrade semantics are copied from plugins/claude-code/bin/delphi-review-guard.sh,
+ * which has been in use long enough to have settled them:
+ *
+ *   no .sprint-state   -> ALLOW  (not a sprint project; gating it would punish every
+ *                                 ordinary repo that installed the plugin)
+ *   state, no verdict  -> DENY   (sprint is open, review not done)
+ *   verdict != APPROVED-> DENY   (reason names the actual verdict)
+ *   APPROVED           -> ALLOW
+ *
+ * The guard only ever inspects state. It must not throw: a throw inside pre-execute
+ * aborts the tool call, which is a worse failure than letting an edit through.
+ */
+/** Denial the guard returns; shape matches DSH's PreToolDecision deny variant. */
+export interface GuardDenial {
+    readonly kind: "deny";
+    readonly reason: string;
+}
+/** Does this tool modify files? */
+export declare function isEditTool(name: string): boolean;
+/**
+ * Should a save-time check run for this path?
+ *
+ * Documents and data files are excluded on purpose: they are a large share of the
+ * commits in repositories using xp-gate, and the engine has nothing to say about
+ * them. Skipping them removes most of the hook's cost.
+ */
+export declare function isCheckablePath(path: string): boolean;
+/**
+ * Decide whether an edit may proceed.
+ *
+ * Returns undefined to mean "allow" so the caller can `if (denial) return denial`.
+ */
+export declare function delphiGuardDecision(root: string, toolName: string): GuardDenial | undefined;
+//# sourceMappingURL=hooks.d.ts.map

package/plugins/dsh/lib/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAYH,kFAAkF;AAClF,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAsBD,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKrD;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CA8B3F"}

package/plugins/dsh/lib/hooks.js

@@ -0,0 +1,113 @@
+/**
+ * DSH-native hooks: the delphi-review guard and the save-time principles check.
+ *
+ * @test REQ-DSH-015 sprint-phase writes are gated the way the IDE plugin gates them
+ * @intent Port the Claude Code guard and save-check to DSH's own pre/post-execute
+ *         seams, keeping the degrade rules that made them safe there.
+ * @covers AC-DSH-015-01
+ *
+ * Degrade semantics are copied from plugins/claude-code/bin/delphi-review-guard.sh,
+ * which has been in use long enough to have settled them:
+ *
+ *   no .sprint-state   -> ALLOW  (not a sprint project; gating it would punish every
+ *                                 ordinary repo that installed the plugin)
+ *   state, no verdict  -> DENY   (sprint is open, review not done)
+ *   verdict != APPROVED-> DENY   (reason names the actual verdict)
+ *   APPROVED           -> ALLOW
+ *
+ * The guard only ever inspects state. It must not throw: a throw inside pre-execute
+ * aborts the tool call, which is a worse failure than letting an edit through.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Tools that modify files. Read-only tools are never gated. */
+const EDIT_TOOLS = new Set(["write", "edit", "str_replace_editor"]);
+/** Where Sprint Flow records the review verdict. */
+const SPRINT_STATE_DIR = ".sprint-state";
+const VERDICT_FILE = "delphi-reviewed.json";
+/** The file extensions the principles engine actually covers. */
+const CHECKABLE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".go",
+    ".java",
+    ".kt",
+    ".c",
+    ".cpp",
+    ".h",
+    ".swift",
+    ".m",
+    ".dart",
+    ".sh",
+    ".ps1",
+]);
+/** Does this tool modify files? */
+export function isEditTool(name) {
+    return EDIT_TOOLS.has(name);
+}
+/**
+ * Should a save-time check run for this path?
+ *
+ * Documents and data files are excluded on purpose: they are a large share of the
+ * commits in repositories using xp-gate, and the engine has nothing to say about
+ * them. Skipping them removes most of the hook's cost.
+ */
+export function isCheckablePath(path) {
+    const lowered = path.toLowerCase();
+    const dot = lowered.lastIndexOf(".");
+    if (dot < 0)
+        return false;
+    return CHECKABLE_EXTENSIONS.has(lowered.slice(dot));
+}
+/** Read the recorded verdict, or a reason it cannot be read. */
+function readVerdict(root) {
+    const file = join(root, SPRINT_STATE_DIR, VERDICT_FILE);
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        const verdict = typeof parsed.verdict === "string" ? parsed.verdict : "";
+        return { verdict };
+    }
+    catch (error) {
+        // Corrupt JSON is a real state (a half-written file, a merge conflict). Treat it
+        // as "not reviewed" and say why, rather than throwing into the tool pipeline.
+        return { unreadable: error.message };
+    }
+}
+/**
+ * Decide whether an edit may proceed.
+ *
+ * Returns undefined to mean "allow" so the caller can `if (denial) return denial`.
+ */
+export function delphiGuardDecision(root, toolName) {
+    if (!isEditTool(toolName))
+        return undefined;
+    if (!existsSync(join(root, SPRINT_STATE_DIR)))
+        return undefined;
+    const verdictFile = join(root, SPRINT_STATE_DIR, VERDICT_FILE);
+    if (!existsSync(verdictFile)) {
+        return {
+            kind: "deny",
+            reason: "delphi-review has not run for this sprint. Complete the Phase 2 delphi-review " +
+                "before modifying code, then retry.",
+        };
+    }
+    const { verdict, unreadable } = readVerdict(root);
+    if (unreadable !== undefined) {
+        return {
+            kind: "deny",
+            reason: `${VERDICT_FILE} is not readable as JSON (${unreadable}). Re-run delphi-review.`,
+        };
+    }
+    if (verdict !== "APPROVED") {
+        return {
+            kind: "deny",
+            reason: `delphi-review verdict is "${verdict || "(missing)"}", not APPROVED. ` +
+                "Address the findings and re-run delphi-review, then retry.",
+        };
+    }
+    return undefined;
+}
+//# sourceMappingURL=hooks.js.map

package/plugins/dsh/lib/index.d.ts

@@ -0,0 +1,20 @@
+import z from "@deepseek-ai/schemastery";
+import type { Context } from "@deepseek-ai/cordis";
+export declare const name = "tool-xp-gate";
+export declare const inject: string[];
+/**
+ * Runtime schema for the keys above.
+ *
+ * Exported as a schema, not just a type: DSH validates against it and surfaces the
+ * keys in the profile schema, so a user can discover and set them. A bare interface
+ * is invisible to the harness.
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    principlesCheck: z<"auto" | "off", "auto" | "off", "defined">;
+    delphiGuard: z<"auto" | "off", "auto" | "off", "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    principlesCheck: z<"auto" | "off", "auto" | "off", "defined">;
+    delphiGuard: z<"auto" | "off", "auto" | "off", "defined">;
+}>>, "plain">;
+export declare function apply(ctx: Context, config?: unknown): void;
+//# sourceMappingURL=index.d.ts.map

package/plugins/dsh/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,CAAC,MAAM,0BAA0B,CAAA;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAgBlD,eAAO,MAAM,IAAI,iBAAiB,CAAA;AAGlC,eAAO,MAAM,MAAM,UAA+B,CAAA;AA0TlD;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;;;;;;aAajB,CAAA;AAEF,wBAAgB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,GAAE,OAAY,GAAG,IAAI,CA6B9D"}