@boyingliu01/xp-gate 0.20.2 → 0.22.0

package/plugins/dsh/src/index.test.ts

@@ -8,34 +8,50 @@ interface CapturedTool {
   execute: (args: unknown, exec: unknown) => Promise<unknown>
 }
 
-function makeCtx(stdoutText: string) {
-  const captured: unknown[] = []
-  const requests: ShellExecRequest[] = []
-  const shell = {
+// Boy Scout (#447): the inline shell mock pushed makeCtx to 5 brace levels.
+// The spec/result builders keep every function at ≤4.
+function makeSpec(req: ShellExecRequest): ShellExecSpec {
+  return {
+    command: req.command,
+    workdir: req.workdir ?? "/workspace",
+    timeoutMs: req.timeoutMs ?? 1000,
+    stdoutMaxBytes: 1_000_000,
+    signal: req.signal,
+    sandboxPolicy: undefined,
+  }
+}
+
+function makeRunResult(stdoutText: string): ShellRunResult {
+  return {
+    exitCode: 0,
+    signal: null,
+    timedOut: false,
+    aborted: false,
+    timeoutMs: 1000,
+    stdout: { text: stdoutText, truncated: false },
+    stderr: { text: "", truncated: false },
+  }
+}
+
+function makeShell(stdoutText: string, requests: ShellExecRequest[]) {
+  return {
     resolve(req: ShellExecRequest): ShellExecSpec {
       requests.push(req)
-      return {
-        command: req.command,
-        workdir: req.workdir ?? "/workspace",
-        timeoutMs: req.timeoutMs ?? 1000,
-        stdoutMaxBytes: 1_000_000,
-        signal: req.signal,
-        sandboxPolicy: undefined,
-      }
+      return makeSpec(req)
     },
     run(): Promise<ShellRunResult> {
-      return Promise.resolve({
-        exitCode: 0,
-        signal: null,
-        timedOut: false,
-        aborted: false,
-        timeoutMs: 1000,
-        stdout: { text: stdoutText, truncated: false },
-        stderr: { text: "", truncated: false },
-      })
+      return Promise.resolve(makeRunResult(stdoutText))
     },
   }
-  const ctx = { tools: { register: (def: unknown) => captured.push(def) }, shell } as unknown as Context
+}
+
+function makeCtx(stdoutText: string) {
+  const captured: unknown[] = []
+  const requests: ShellExecRequest[] = []
+  const ctx = {
+    tools: { register: (def: unknown) => captured.push(def) },
+    shell: makeShell(stdoutText, requests),
+  } as unknown as Context
   return { ctx, captured, requests }
 }
 
@@ -82,16 +98,17 @@ describe("apply", () => {
 
   /**
    * @test REQ-DSH-004
-   * @intent 验证 gate-arch 工具执行生成 `xp-gate arch --config <config>`（缺省 architecture.yaml）
+   * @intent 验证 gate-arch 工具执行生成 `xp-gate arch`（默认不带 --config，#447），显式 config 走 --use-config
    * @covers AC-DSH-004-01
    */
-  it("gate-arch execute builds `xp-gate arch` with default and custom config", async () => {
+  it("gate-arch execute builds `xp-gate arch` with built-in rules by default", async () => {
     const { ctx, captured, requests } = makeCtx("arch report")
     apply(ctx)
     const tool = captured.find((c) => (c as CapturedTool).name === "gate-arch") as CapturedTool
     await tool.execute({}, { signal: new AbortController().signal })
-    expect(requests[0]?.command).toContain("xp-gate arch --config 'architecture.yaml'")
+    expect(requests[0]?.command).toContain("xp-gate arch")
+    expect(requests[0]?.command).not.toContain("--config")
     await tool.execute({ config: "custom.yaml" }, { signal: new AbortController().signal })
-    expect(requests[1]?.command).toContain("xp-gate arch --config 'custom.yaml'")
+    expect(requests[1]?.command).toContain("xp-gate arch --use-config 'custom.yaml'")
   })
 })

package/plugins/dsh/src/index.ts

@@ -1,5 +1,6 @@
 import { defineTool } from "@deepseek-ai/dsh-tools"
 import type { Context } from "@deepseek-ai/cordis"
+import type { ShellDialect } from "./command.js"
 import { GATE_WHITELIST, buildCommand, detectDialect, resolveTarget } from "./command.js"
 import { runXpGate } from "./gate-runner.js"
 import { DelphiSetupError, loadDelphiConfig, toDelphiOptions } from "./delphi-config.js"
@@ -9,152 +10,177 @@ export const name = "tool-xp-gate"
 export const inject = ["tools", "shell"]
 
 const DEFAULT_TIMEOUT_MS = 120_000
+// Multi-round reviews over large inputs are slow; the transport applies its
+// own per-request timeout on top of this ceiling.
+const DELPHI_TIMEOUT_MS = 900_000
 
-export function apply(ctx: Context, _config: unknown = {}): void {
-  const shell = ctx.shell
-  // DSH runs a POSIX shell off-Windows and PowerShell on Windows; generating the
-  // wrong dialect makes every tool fail to parse rather than degrade gracefully.
-  const dialect = detectDialect()
+// Boy Scout (#447): gate-check's `gates` parameter nests one level too deep
+// inline (parameters → gates → items), so the schema lives at module scope.
+const GATES_PARAMETER = {
+  type: "array",
+  items: { type: "string", enum: GATE_WHITELIST },
+  description: "Optional gate subset to run (e.g. ['principles', 'arch']).",
+} as const
 
-  ctx.tools.register(
-    defineTool({
-      name: "gate-check",
-      description:
-        "Run XP-Gate quality gates (xp-gate check) on a file or directory and return the gate report. Prefers the global xp-gate CLI and degrades to an actionable install hint when it is absent.",
-      parameters: {
-        path: {
-          type: "string",
-          required: true,
-          description: "File or directory path to check (absolute or relative to the workspace).",
-        },
-        gates: {
-          type: "array",
-          items: { type: "string", enum: GATE_WHITELIST },
-          description: "Optional gate subset to run (e.g. ['principles', 'arch']).",
-        },
+// Boy Scout (#447): apply() used to inline four register(defineTool({...}))
+// blocks (149 lines, 5 brace levels). Each tool now lives in its own factory;
+// apply() is pure wiring.
+function gateCheckTool(shell: Context["shell"], dialect: ShellDialect) {
+  return defineTool({
+    name: "gate-check",
+    description:
+      "Run XP-Gate quality gates (xp-gate check) on a file or directory and return the gate report. Prefers the global xp-gate CLI and degrades to an actionable install hint when it is absent.",
+    parameters: {
+      path: {
+        type: "string",
+        required: true,
+        description: "File or directory path to check (absolute or relative to the workspace).",
       },
-      output: {
-        schema: { type: "string" },
-        render: (_args, value) => [{ type: "text", text: value }],
-      },
-      timeoutMs: DEFAULT_TIMEOUT_MS,
-      async execute(args, exec) {
-        const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
-        const target = resolveTarget(args.path, cwd)
-        const command = buildCommand({ subcommand: "check", target, gates: args.gates, dialect })
-        return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
-      },
-    }),
-  )
+      gates: GATES_PARAMETER,
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }],
+    },
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    async execute(args, exec) {
+      const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
+      const target = resolveTarget(args.path, cwd)
+      const command = buildCommand({ subcommand: "check", target, gates: args.gates, dialect })
+      return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
+    },
+  })
+}
 
-  ctx.tools.register(
-    defineTool({
-      name: "gate-principles",
-      description:
-        "Run the 14 Clean Code / SOLID rules (xp-gate principles, Gate 4) on a file or directory and return the principles report.",
-      parameters: {
-        path: {
-          type: "string",
-          required: true,
-          description: "File or directory path to check (absolute or relative to the workspace).",
-        },
-      },
-      output: {
-        schema: { type: "string" },
-        render: (_args, value) => [{ type: "text", text: value }],
+function gatePrinciplesTool(shell: Context["shell"], dialect: ShellDialect) {
+  return defineTool({
+    name: "gate-principles",
+    description:
+      "Run the 14 Clean Code / SOLID rules (xp-gate principles, Gate 4) on a file or directory and return the principles report.",
+    parameters: {
+      path: {
+        type: "string",
+        required: true,
+        description: "File or directory path to check (absolute or relative to the workspace).",
       },
-      timeoutMs: DEFAULT_TIMEOUT_MS,
-      async execute(args, exec) {
-        const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
-        const target = resolveTarget(args.path, cwd)
-        const command = buildCommand({ subcommand: "principles", target, dialect })
-        return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
-      },
-    }),
-  )
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }],
+    },
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    async execute(args, exec) {
+      const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
+      const target = resolveTarget(args.path, cwd)
+      const command = buildCommand({ subcommand: "principles", target, dialect })
+      return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
+    },
+  })
+}
 
-  ctx.tools.register(
-    defineTool({
-      name: "gate-arch",
-      description:
-        "Run architecture validation (xp-gate arch, Gate 6) using the given config file and return the architecture report. Defaults to architecture.yaml.",
-      parameters: {
-        config: {
-          type: "string",
-          description: "Architecture config file path (defaults to architecture.yaml).",
-        },
-      },
-      output: {
-        schema: { type: "string" },
-        render: (_args, value) => [{ type: "text", text: value }],
+function gateArchTool(shell: Context["shell"], dialect: ShellDialect) {
+  return defineTool({
+    name: "gate-arch",
+    description:
+      "Run architecture validation (xp-gate arch, Gate 6) with the pinned local @archlinter/cli built-in rules and baseline ratchet, and return the architecture report. Pass a config file only to opt into archlint's own --config path (pre-0.16 schemas are rejected by archlint itself).",
+    parameters: {
+      config: {
+        type: "string",
+        description:
+          "Optional architecture config file (opts into archlint --config; the default built-in-rules path needs none).",
       },
-      timeoutMs: DEFAULT_TIMEOUT_MS,
-      async execute(args, exec) {
-        const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
-        const command = buildCommand({ subcommand: "arch", config: args.config, dialect })
-        return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
-      },
-    }),
-  )
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }],
+    },
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    async execute(args, exec) {
+      const cwd = exec.agent?.session?.header?.cwd ?? process.cwd()
+      const command = buildCommand({ subcommand: "arch", config: args.config, dialect })
+      return runXpGate(shell, exec.signal, command, cwd, DEFAULT_TIMEOUT_MS)
+    },
+  })
+}
+
+// Delphi multi-model cross-review.
+//
+// DSH's own subagents cannot do this: they inherit one host-configured model,
+// so three "experts" would be three instances of the same model, and Delphi's
+// value rests entirely on the reviewers being DIFFERENT models. This tool
+// therefore calls an external OpenAI-compatible provider directly, with one
+// distinct model per seat.
+// Boy Scout (#447): the review body used to sit inline in execute() at 5 brace
+// levels (defineTool → execute → try → runReview options). Module scope keeps
+// the try/catch semantics identical while dropping two levels.
+async function runDelphiReview(
+  subject: string,
+  addressed: string,
+  maxRounds: number | undefined,
+  cwd: string,
+): Promise<string> {
+  try {
+    const cfg = loadDelphiConfig(cwd)
+    const outcome = await runReview(
+      { ...toDelphiOptions(cfg), maxRounds: maxRounds ?? cfg.maxRounds },
+      subject,
+      addressed,
+    )
+    const seats = cfg.seats.map((s) => s.model).join(", ")
+    return `${formatOutcome(outcome)}\n\nProvider: ${cfg.provider}\nSeats: ${seats}`
+  } catch (e) {
+    // Config problems are the common failure; report them as guidance
+    // rather than a stack trace.
+    if (e instanceof DelphiSetupError) return `Delphi review not started: ${e.message}`
+    throw e
+  }
+}
 
-  // Delphi multi-model cross-review.
-  //
-  // DSH's own subagents cannot do this: they inherit one host-configured model,
-  // so three "experts" would be three instances of the same model, and Delphi's
-  // value rests entirely on the reviewers being DIFFERENT models. This tool
-  // therefore calls an external OpenAI-compatible provider directly, with one
-  // distinct model per seat.
-  ctx.tools.register(
-    defineTool({
-      name: "delphi-review",
-      description:
-        "Run a Delphi cross-review of a subject (a diff, a design, a spec) using three DISTINCT models from an external OpenAI-compatible provider configured in .delphi-config.json. Round 1 is anonymous and concurrent; later rounds feed back the aggregate until the approval ratio reaches the configured threshold (default 90%) or the round cap (default 5). Use this whenever a change needs independent multi-model review rather than a single model's opinion.",
-      parameters: {
-        subject: {
-          type: "string",
-          required: true,
-          description:
-            "The material to review, inline. For a diff, pass the diff text (or a summarized form if very large).",
-        },
-        addressed: {
-          type: "string",
-          description:
-            "Optional description of what changed since a previous round, fed back to later rounds so reviewers can revise their position.",
-        },
-        maxRounds: {
-          type: "number",
-          description: "Override the configured round cap (Delphi default is 5).",
-        },
-        cwd: {
-          type: "string",
-          description: "Project root containing .delphi-config.json (defaults to the session cwd).",
-        },
+function delphiReviewTool() {
+  return defineTool({
+    name: "delphi-review",
+    description:
+      "Run a Delphi cross-review of a subject (a diff, a design, a spec) using three DISTINCT models from an external OpenAI-compatible provider configured in .delphi-config.json. Round 1 is anonymous and concurrent; later rounds feed back the aggregate until the approval ratio reaches the configured threshold (default 90%) or the round cap (default 5). Use this whenever a change needs independent multi-model review rather than a single model's opinion.",
+    parameters: {
+      subject: {
+        type: "string",
+        required: true,
+        description:
+          "The material to review, inline. For a diff, pass the diff text (or a summarized form if very large).",
+      },
+      addressed: {
+        type: "string",
+        description:
+          "Optional description of what changed since a previous round, fed back to later rounds so reviewers can revise their position.",
       },
-      output: {
-        schema: { type: "string" },
-        render: (_args, value) => [{ type: "text", text: value }],
+      maxRounds: {
+        type: "number",
+        description: "Override the configured round cap (Delphi default is 5).",
       },
-      // Multi-round reviews over large inputs are slow; the transport applies
-      // its own per-request timeout on top of this ceiling.
-      timeoutMs: 900_000,
-      async execute(args, exec) {
-        const cwd = args.cwd ?? exec.agent?.session?.header?.cwd ?? process.cwd()
-        try {
-          const cfg = loadDelphiConfig(cwd)
-          const outcome = await runReview(
-            { ...toDelphiOptions(cfg), maxRounds: args.maxRounds ?? cfg.maxRounds },
-            args.subject,
-            args.addressed ?? "",
-          )
-          const seats = cfg.seats.map((s) => s.model).join(", ")
-          return `${formatOutcome(outcome)}\n\nProvider: ${cfg.provider}\nSeats: ${seats}`
-        } catch (e) {
-          // Config problems are the common failure; report them as guidance
-          // rather than a stack trace.
-          if (e instanceof DelphiSetupError) return `Delphi review not started: ${e.message}`
-          throw e
-        }
+      cwd: {
+        type: "string",
+        description: "Project root containing .delphi-config.json (defaults to the session cwd).",
       },
-    }),
-  )
-}
+    },
+    output: {
+      schema: { type: "string" },
+      render: (_args, value) => [{ type: "text", text: value }],
+    },
+    timeoutMs: DELPHI_TIMEOUT_MS,
+    async execute(args, exec) {
+      const cwd = args.cwd ?? exec.agent?.session?.header?.cwd ?? process.cwd()
+      return runDelphiReview(args.subject, args.addressed ?? "", args.maxRounds, cwd)
+    },
+  })
+}
+
+export function apply(ctx: Context, _config: unknown = {}): void {
+  // DSH runs a POSIX shell off-Windows and PowerShell on Windows; generating the
+  // wrong dialect makes every tool fail to parse rather than degrade gracefully.
+  const dialect = detectDialect()
+  const shell = ctx.shell
+  ctx.tools.register(gateCheckTool(shell, dialect))
+  ctx.tools.register(gatePrinciplesTool(shell, dialect))
+  ctx.tools.register(gateArchTool(shell, dialect))
+  ctx.tools.register(delphiReviewTool())
+}

package/plugins/opencode/README.md

@@ -9,7 +9,8 @@ OpenCode plugin exposing xp-gate quality gates and AI workflow skills.
 - **gate-principles** ⇄ `xp-gate principles <path>`: Run Clean Code + SOLID
   principles checker (Gate 4 standalone).
 - **gate-arch** ⇄ `xp-gate arch`: Run architecture validation (Gate 6
-  standalone, layer boundary checks).
+  standalone) with the pinned local @archlinter/cli built-in rules and baseline
+  ratchet; an optional config file opts into archlint's own `--config` path.
 - **session-reload-model**: Reload session model from config. After switching
   provider configs (opencode.json + oh-my-openagent.json via switch-coding-plan.sh),
   updates the session model in OpenCode DB to match the new config, so restarted
@@ -67,7 +68,9 @@ Or via local path (development):
 - One of:
   - `xp-gate` CLI installed globally (`npm install -g @boyingliu01/xp-gate`) — **preferred**, or
   - the xp-gate repo checked out locally with `src/principles/index.ts` reachable — **fallback** (the tool will shell out via `npx -y tsx`)
-- `architecture.yaml` in repo root (for `gate-arch` only)
+- `@archlinter/cli` installed locally or on PATH (for `gate-arch` only; the
+  default built-in-rules path needs no `architecture.yaml` — passing one opts
+  into archlint's own `--config` schema validation, which rejects pre-0.16 files)
 
 ## Graceful Degradation