@rsaglobaltech/specgate 0.12.0 → 0.13.0

package/dist/packages/mcp-spec-driven/src/tools.js

@@ -0,0 +1,667 @@
+"use strict";
+// GENERATED FILE - DO NOT EDIT BY HAND
+// Derived from scripts/lib/surface.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markRequirementDone = exports.plan = exports.validateProject = exports.lintPack = exports.updateTraceability = exports.listRequirements = exports.readSpec = exports.TOOLS = exports.GenericCliTool = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const native_tools_1 = require("./native-tools");
+class ProjectHelper {
+    /**
+     * A tool that is handed a directory which is not a spec-driven project has to
+     * say so. #138 reduced this to a type check, so every such call went on to
+     * shell out and came back `{ exitCode: 1, raw: "" }` — a failure with no
+     * reason in it, which is exactly the shape ADR-0017 exists to prevent.
+     */
+    static ensureProjectDir(projectDir) {
+        if (!projectDir || typeof projectDir !== "string") {
+            throw new Error("projectDir is required (absolute path to a spec-driven project)");
+        }
+        if (!fs.existsSync(projectDir)) {
+            throw new Error(`projectDir does not exist: ${projectDir}`);
+        }
+        if (!fs.existsSync(path.join(projectDir, "spec.md"))) {
+            throw new Error(`Not a spec-driven project (no spec.md): ${projectDir}`);
+        }
+        return projectDir;
+    }
+}
+class CliInvoker {
+    /**
+     * Split a command line, honouring quotes.
+     *
+     * `bin.split(" ")` was the whole parser after #138, so any interpreter path
+     * with a space in it — `"/Users/me/My Tools/node" "…/cli.js"` — was torn into
+     * fragments and the spawn failed with no output.
+     */
+    static parseCliCommand(cliPath) {
+        const raw = (cliPath || process.env.SPECGATE_CLI || "npx @rsaglobaltech/specgate").trim();
+        const tokens = [];
+        const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+        let m;
+        while ((m = re.exec(raw)) !== null) {
+            tokens.push(m[1] !== undefined ? m[1] : m[2] !== undefined ? m[2] : m[3]);
+        }
+        return tokens;
+    }
+    static spawnCli(cliPath, args) {
+        const cmd = CliInvoker.parseCliCommand(cliPath);
+        const useShell = process.platform === "win32";
+        const quote = (v) => (useShell && /\s/.test(v) ? `"${v}"` : v);
+        return (0, node_child_process_1.spawnSync)(quote(cmd[0]), [...cmd.slice(1), ...args].map(quote), {
+            encoding: "utf8",
+            shell: useShell,
+            timeout: 60000,
+        });
+    }
+}
+class GenericCliTool {
+    name;
+    description;
+    csda;
+    inputSchema;
+    dirStyle;
+    editsContract;
+    constructor(name, description, csda, inputSchema, 
+    /**
+     * How this command takes the project directory. `validate` takes it as a
+     * positional `<dir>` and rejects `--project-dir` outright, so the flag form
+     * made `validate_project` — the most used tool of the seven — fail with
+     * "Unknown flag(s)" and an empty payload over MCP. The surface already
+     * records which is which in `json.args`; this reads it instead of assuming.
+     */
+    dirStyle = "flag", 
+    /**
+     * True when this command may write a path the write-scope rules protect.
+     * Computed at generation time from scripts/lib/surface.ts and
+     * WriteScope.DEFAULT_PROTECTED_PATHS, so the rule has one definition.
+     */
+    editsContract = false) {
+        this.name = name;
+        this.description = description;
+        this.csda = csda;
+        this.inputSchema = inputSchema;
+        this.dirStyle = dirStyle;
+        this.editsContract = editsContract;
+    }
+    handler(args) {
+        const dir = ProjectHelper.ensureProjectDir(args.projectDir);
+        // C10-04. The prompt has always told the agent not to rewrite the
+        // specification it is being measured against; nothing enforced it over MCP.
+        // An agent that cannot make a scenario pass can otherwise relax the
+        // scenario, and the gate approves — the exact failure this product exists
+        // to prevent. The change cycle is the way to edit a spec on purpose, and it
+        // leaves a reviewable trail.
+        if (this.editsContract)
+            (0, native_tools_1.assertContractEditable)(this.name, dir);
+        const argv = this.csda.split(" ");
+        if (this.dirStyle === "positional")
+            argv.push(dir);
+        else
+            argv.push("--project-dir", dir);
+        // Pass args safely
+        for (const [k, v] of Object.entries(args)) {
+            if (k === "projectDir" || k === "cliPath")
+                continue;
+            if (typeof v === "string") {
+                argv.push(v); // Quick hack, we need proper arg mapping
+            }
+        }
+        if (!argv.includes("--json")) {
+            argv.push("--json");
+        }
+        const result = CliInvoker.spawnCli(args.cliPath, argv);
+        const combined = (result.stdout || "") + "\n" + (result.stderr || "");
+        try {
+            if (result.stdout && result.stdout.trim().startsWith("{")) {
+                return JSON.parse(result.stdout.trim());
+            }
+        }
+        catch {
+            // Not JSON: fall through to the raw envelope below.
+        }
+        return {
+            exitCode: typeof result.status === "number" ? result.status : 1,
+            raw: combined.trim(),
+        };
+    }
+}
+exports.GenericCliTool = GenericCliTool;
+exports.TOOLS = {};
+exports.TOOLS["specgate_init"] = new GenericCliTool("specgate_init", "Adopt this repo if it has code, else scaffold one; --new forces a scaffold.", "init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_adopt"] = new GenericCliTool("specgate_adopt", "Install SDD on an EXISTING repository (brownfield, non-invasive).", "adopt", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_onboard"] = new GenericCliTool("specgate_onboard", "Read an existing repo and propose the capabilities its code implies.", "onboard", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_doctor"] = new GenericCliTool("specgate_doctor", "Diagnose the project and environment; every finding ships a fix.", "doctor", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_status"] = new GenericCliTool("specgate_status", "Daily dashboard: what is done, what is orphaned, what to do next.", "status", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_ci_init"] = new GenericCliTool("specgate_ci_init", "Generate the spec gate for GitHub, GitLab, Azure, or Jenkins.", "ci init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_alm_sync"] = new GenericCliTool("specgate_alm_sync", "Sync REQs with Jira / Azure Boards (create, close, drift).", "alm sync", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_alm_link"] = new GenericCliTool("specgate_alm_link", "Run specgate alm link", "alm link", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_alm_status"] = new GenericCliTool("specgate_alm_status", "Run specgate alm status", "alm status", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_alm_pull"] = new GenericCliTool("specgate_alm_pull", "Run specgate alm pull", "alm pull", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_check"] = new GenericCliTool("specgate_check", "The gate: validate --strict, then your tests — before you open a PR.", "check", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "positional", false);
+exports.TOOLS["validate_project"] = new GenericCliTool("validate_project", "Check structure, traceability, Gherkin. --strict is the gate: TDD, links, scenarios, requirements and coverage.", "validate", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "positional", false);
+exports.TOOLS["specgate_expand"] = new GenericCliTool("specgate_expand", "Apply a domain pack (local path or remote git tag).", "expand", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["plan"] = new GenericCliTool("plan", "List requirements that still need a test or implementation.", "plan", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_report"] = new GenericCliTool("specgate_report", "Spec-coverage dashboard as self-contained HTML (CI/Pages artifact).", "report", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["mark_requirement_done"] = new GenericCliTool("mark_requirement_done", "Mark a requirement Implemented — after the gate passes for it.", "done", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        requirement: { type: "string", description: "The <REQ> argument of `specgate done`." },
+    },
+    required: ["projectDir", "requirement"],
+}, "flag", true);
+exports.TOOLS["specgate_new"] = new GenericCliTool("specgate_new", "One requirement in one step: spec.md section, tagged scenario, matrix row.", "new", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        title: { type: "string", description: "The <title> argument of `specgate new`." },
+    },
+    required: ["projectDir", "title"],
+}, "flag", true);
+exports.TOOLS["specgate_req_add"] = new GenericCliTool("specgate_req_add", "Run specgate req add", "req add", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_req_link"] = new GenericCliTool("specgate_req_link", "Run specgate req link", "req link", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_req_done"] = new GenericCliTool("specgate_req_done", "Run specgate req done", "req done", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_req_rm"] = new GenericCliTool("specgate_req_rm", "Run specgate req rm", "req rm", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_req_list"] = new GenericCliTool("specgate_req_list", "Run specgate req list", "req list", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_fix"] = new GenericCliTool("specgate_fix", "Apply the fixes validate suggests (--dry-run to preview).", "fix", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_change_new"] = new GenericCliTool("specgate_change_new", "Run specgate change new", "change new", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_change_list"] = new GenericCliTool("specgate_change_list", "Run specgate change list", "change list", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_change_show"] = new GenericCliTool("specgate_change_show", "Run specgate change show", "change show", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        id: { type: "string", description: "The <id> argument of `specgate change show`." },
+    },
+    required: ["projectDir", "id"],
+}, "flag", false);
+exports.TOOLS["specgate_change_status"] = new GenericCliTool("specgate_change_status", "Run specgate change status", "change status", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_change_validate"] = new GenericCliTool("specgate_change_validate", "Run specgate change validate", "change validate", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        id: { type: "string", description: "The <id> argument of `specgate change validate`." },
+    },
+    required: ["projectDir", "id"],
+}, "flag", false);
+exports.TOOLS["specgate_change_archive"] = new GenericCliTool("specgate_change_archive", "Run specgate change archive", "change archive", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        id: { type: "string", description: "The <id> argument of `specgate change archive`." },
+    },
+    required: ["projectDir", "id"],
+}, "flag", false);
+exports.TOOLS["specgate_change_instructions"] = new GenericCliTool("specgate_change_instructions", "Run specgate change instructions", "change instructions", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        artifact: {
+            type: "string",
+            description: "The <artifact> argument of `specgate change instructions`.",
+        },
+    },
+    required: ["projectDir", "artifact"],
+}, "flag", false);
+exports.TOOLS["specgate_change_author"] = new GenericCliTool("specgate_change_author", "Run specgate change author", "change author", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+        id: { type: "string", description: "The <id> argument of `specgate change author`." },
+    },
+    required: ["projectDir", "id"],
+}, "flag", false);
+exports.TOOLS["specgate_pack_init"] = new GenericCliTool("specgate_pack_init", "Scaffold a new pack skeleton (backend · frontend · contracts).", "pack init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["lint_pack"] = new GenericCliTool("lint_pack", "Lint a pack: schema, cross-refs, and scenario quality (--strict).", "pack lint", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_pack_infer"] = new GenericCliTool("specgate_pack_infer", "Propose a pack.yaml skeleton from a .feature file.", "pack infer", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_pack_bundle"] = new GenericCliTool("specgate_pack_bundle", "Export a pack repo as a git bundle for air-gapped use.", "pack bundle", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_specops_add"] = new GenericCliTool("specgate_specops_add", "Add a pack (npm-install-style); writes .specops.lock.", "specops add", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_specops_remove"] = new GenericCliTool("specgate_specops_remove", "Drop a pack entry from .specops.lock.", "specops remove", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_specops_sync"] = new GenericCliTool("specgate_specops_sync", "Re-expand packs and three-way merge them, preserving local edits.", "specops sync", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_specops_diff"] = new GenericCliTool("specgate_specops_diff", "Preview a version bump; --as-change derives a reviewable change.", "specops diff", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_specops_contribute"] = new GenericCliTool("specgate_specops_contribute", "Send a local change back upstream to the pack (never pushes).", "specops contribute", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_harness_run"] = new GenericCliTool("specgate_harness_run", "Run the plan → agent → verify → done loop for every pending requirement.", "harness run", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_harness_prompt"] = new GenericCliTool("specgate_harness_prompt", "Print the prompt the harness would hand an agent for one REQ.", "harness prompt", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_harness_init"] = new GenericCliTool("specgate_harness_init", "Scaffold harness.config.yaml and the prompt prefix.", "harness init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_harness_report"] = new GenericCliTool("specgate_harness_report", "What the harness has cost: first-attempt rate, time per delivered requirement.", "harness report", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_config_init"] = new GenericCliTool("specgate_config_init", "Run specgate config init", "config init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_config_set"] = new GenericCliTool("specgate_config_set", "Run specgate config set", "config set", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_config_get"] = new GenericCliTool("specgate_config_get", "Run specgate config get", "config get", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_config_list"] = new GenericCliTool("specgate_config_list", "Run specgate config list", "config list", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_agents_init"] = new GenericCliTool("specgate_agents_init", "Wire the loop into Claude, Cursor, Copilot, Aider and more.", "agents init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_update"] = new GenericCliTool("specgate_update", "Refresh generated agent files after a CLI upgrade, keeping your edits.", "update", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", true);
+exports.TOOLS["specgate_schema_which"] = new GenericCliTool("specgate_schema_which", "Run specgate schema which", "schema which", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_schema_init"] = new GenericCliTool("specgate_schema_init", "Run specgate schema init", "schema init", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_schema_fork"] = new GenericCliTool("specgate_schema_fork", "Run specgate schema fork", "schema fork", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_schema_validate"] = new GenericCliTool("specgate_schema_validate", "Run specgate schema validate", "schema validate", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_completion_bash"] = new GenericCliTool("specgate_completion_bash", "Run specgate completion bash", "completion bash", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_completion_zsh"] = new GenericCliTool("specgate_completion_zsh", "Run specgate completion zsh", "completion zsh", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_completion_fish"] = new GenericCliTool("specgate_completion_fish", "Run specgate completion fish", "completion fish", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+exports.TOOLS["specgate_studio"] = new GenericCliTool("specgate_studio", "Serve a local, read-only HTML view of the spec tree (--json for agents).", "studio", {
+    type: "object",
+    properties: {
+        projectDir: { type: "string" },
+        cliPath: { type: "string" },
+    },
+    required: ["projectDir"],
+}, "flag", false);
+// ── The published seven ──────────────────────────────────────────────────────
+exports.TOOLS["read_spec"] = new native_tools_1.ReadSpecTool();
+exports.TOOLS["list_requirements"] = new native_tools_1.ListRequirementsTool();
+exports.TOOLS["update_traceability"] = new native_tools_1.UpdateTraceabilityTool();
+// Aliases: the documented name and the generated id are the same tool.
+for (const [published, generated] of [
+    ["lint_pack", "specgate_pack_lint"],
+    ["validate_project", "specgate_validate"],
+    ["plan", "specgate_plan"],
+    ["mark_requirement_done", "specgate_done"],
+]) {
+    if (exports.TOOLS[generated])
+        exports.TOOLS[published] = exports.TOOLS[generated];
+}
+const readSpec = (args) => exports.TOOLS["read_spec"].handler(args);
+exports.readSpec = readSpec;
+const listRequirements = (args) => exports.TOOLS["list_requirements"].handler(args);
+exports.listRequirements = listRequirements;
+const updateTraceability = (args) => exports.TOOLS["update_traceability"].handler(args);
+exports.updateTraceability = updateTraceability;
+const lintPack = (args) => exports.TOOLS["lint_pack"].handler(args);
+exports.lintPack = lintPack;
+const validateProject = (args) => exports.TOOLS["validate_project"].handler(args);
+exports.validateProject = validateProject;
+const plan = (args) => exports.TOOLS["plan"].handler(args);
+exports.plan = plan;
+const markRequirementDone = (args) => exports.TOOLS["mark_requirement_done"].handler(args);
+exports.markRequirementDone = markRequirementDone;
+//# sourceMappingURL=tools.js.map