specguard-mcp 0.1.0

package/dist/src/tools/index.d.ts

@@ -0,0 +1,33 @@
+import type { ToolDefinition } from "./types.js";
+/**
+ * THE REGISTRY — the one file that changes when the toolset grows.
+ *
+ * SPGD-310 ships a bootstrap, not a tool contract: the initial set wraps
+ * capabilities that are verified-shipped today, and the rest fills in as more
+ * of SpecGuard lands. This array is the seam that makes that true. `server.ts`
+ * iterates it and has no knowledge of any individual tool, so adding one is a
+ * new file plus one line here — no new plumbing, no `switch` to extend, no
+ * change to how the server starts, authenticates or reports errors.
+ *
+ * == What is in the bootstrap, and why only these two
+ *
+ *   - `lint_intent_annotations` wraps `specguard-lint` (shipped:
+ *     `specguard-rspec/bin/specguard-lint`, SPGD-12 §1).
+ *   - `get_repository_overview` wraps `GET /api/v1/repository` (shipped:
+ *     `specguard/config/routes.rb`).
+ *
+ * Both were confirmed present before being wrapped, and the two chosen cover
+ * the two halves of the surface — one local subprocess, one authenticated HTTP
+ * call — so the shape is proven on both kinds of capability rather than on one.
+ *
+ * == What is deliberately absent
+ *
+ * `/check-intent` and duplicate clustering are NOT here and must not be added
+ * until their backing engine and data exist (SPGD-114 / SPGD-115). A tool
+ * advertised in `tools/list` is a promise an agent will act on: wrapping an
+ * endpoint that does not exist would produce a server that discovers cleanly
+ * and fails on use, which is worse than not offering the tool, because the
+ * agent has already committed to a plan by the time it finds out.
+ */
+export declare const TOOLS: readonly ToolDefinition[];
+export type { ToolContext, ToolDefinition, ToolResult } from "./types.js";

package/dist/src/tools/index.js

@@ -0,0 +1,34 @@
+import lintIntentAnnotations from "./lint-intent-annotations.js";
+import getRepositoryOverview from "./repository-overview.js";
+/**
+ * THE REGISTRY — the one file that changes when the toolset grows.
+ *
+ * SPGD-310 ships a bootstrap, not a tool contract: the initial set wraps
+ * capabilities that are verified-shipped today, and the rest fills in as more
+ * of SpecGuard lands. This array is the seam that makes that true. `server.ts`
+ * iterates it and has no knowledge of any individual tool, so adding one is a
+ * new file plus one line here — no new plumbing, no `switch` to extend, no
+ * change to how the server starts, authenticates or reports errors.
+ *
+ * == What is in the bootstrap, and why only these two
+ *
+ *   - `lint_intent_annotations` wraps `specguard-lint` (shipped:
+ *     `specguard-rspec/bin/specguard-lint`, SPGD-12 §1).
+ *   - `get_repository_overview` wraps `GET /api/v1/repository` (shipped:
+ *     `specguard/config/routes.rb`).
+ *
+ * Both were confirmed present before being wrapped, and the two chosen cover
+ * the two halves of the surface — one local subprocess, one authenticated HTTP
+ * call — so the shape is proven on both kinds of capability rather than on one.
+ *
+ * == What is deliberately absent
+ *
+ * `/check-intent` and duplicate clustering are NOT here and must not be added
+ * until their backing engine and data exist (SPGD-114 / SPGD-115). A tool
+ * advertised in `tools/list` is a promise an agent will act on: wrapping an
+ * endpoint that does not exist would produce a server that discovers cleanly
+ * and fails on use, which is worse than not offering the tool, because the
+ * agent has already committed to a plan by the time it finds out.
+ */
+export const TOOLS = [lintIntentAnnotations, getRepositoryOverview];
+//# sourceMappingURL=index.js.map

package/dist/src/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,MAAM,8BAA8B,CAAC;AACjE,OAAO,qBAAqB,MAAM,0BAA0B,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,KAAK,GAA8B,CAAC,qBAAqB,EAAE,qBAAqB,CAAC,CAAC"}

package/dist/src/tools/lint-intent-annotations.d.ts

@@ -0,0 +1,45 @@
+import type { ToolDefinition } from "./types.js";
+/**
+ * `specguard-lint --json` as a tool — the `@intent` linter, which is shipped
+ * today in `specguard-rspec` (`bin/specguard-lint`, SPGD-12 §1).
+ *
+ * == Why this wraps the JSON renderer and not the human one
+ *
+ * The gem grew `--json` in SPGD-305 precisely so a consumer gets *which file,
+ * which line, which rule* as data instead of a prose format to regex. An agent
+ * is that consumer. Passing `--json` unconditionally is what makes this a thin
+ * client rather than a parser: the document goes back as the linter emitted it,
+ * key for key, and this file contains no knowledge of the OpenTestIntent schema,
+ * no finding shape, and no rule about what makes an annotation valid.
+ *
+ * == The exit code is a verdict, not an error
+ *
+ * The linter's contract is three-valued and the mapping is the one decision
+ * this tool actually makes:
+ *
+ *   0 — every annotation checked was valid (including "there were none").
+ *   1 — at least one annotation is malformed. A SUCCESSFUL tool call with
+ *       findings in it. Reporting exit 1 as a tool error would tell the agent
+ *       the linter broke, when what happened is the linter worked and the code
+ *       is wrong — and an agent that reads "tool failed" retries the tool
+ *       instead of fixing the annotation.
+ *   2 — the linter could not do its job. A tool error, and the only one. The
+ *       gem deliberately emits NO document on this path (a `{"ok": false,
+ *       "findings": []}` for a run that checked nothing is how a gate that
+ *       checked nothing gets mistaken for one that found nothing), so the prose
+ *       it wrote to stderr is the entire diagnosis and is passed through.
+ *
+ * `ok` is read off the document rather than re-derived from the exit code, and
+ * the exit code is reported beside it, so an agent can see the two agree.
+ *
+ * == What is deliberately not validated here
+ *
+ * `--changed` together with explicit paths is misuse, and the linter exits 2
+ * saying so. This tool does not pre-empt that. Re-implementing the rule would
+ * put a second copy of the linter's argument grammar in a different language,
+ * free to drift the day the gem adds a flag — and the tool would then be
+ * enforcing a contract it does not own. The schema documents the conflict; the
+ * linter adjudicates it.
+ */
+declare const lintIntentAnnotations: ToolDefinition;
+export default lintIntentAnnotations;

package/dist/src/tools/lint-intent-annotations.js

@@ -0,0 +1,342 @@
+import { stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { ArgumentError, CommandError } from "../errors.js";
+import { EXIT_CLOSE_GRACE_MS, MAX_OUTPUT_BYTES } from "../support/run-command.js";
+import { optionalBoolean, optionalString } from "./args.js";
+/**
+ * `specguard-lint --json` as a tool — the `@intent` linter, which is shipped
+ * today in `specguard-rspec` (`bin/specguard-lint`, SPGD-12 §1).
+ *
+ * == Why this wraps the JSON renderer and not the human one
+ *
+ * The gem grew `--json` in SPGD-305 precisely so a consumer gets *which file,
+ * which line, which rule* as data instead of a prose format to regex. An agent
+ * is that consumer. Passing `--json` unconditionally is what makes this a thin
+ * client rather than a parser: the document goes back as the linter emitted it,
+ * key for key, and this file contains no knowledge of the OpenTestIntent schema,
+ * no finding shape, and no rule about what makes an annotation valid.
+ *
+ * == The exit code is a verdict, not an error
+ *
+ * The linter's contract is three-valued and the mapping is the one decision
+ * this tool actually makes:
+ *
+ *   0 — every annotation checked was valid (including "there were none").
+ *   1 — at least one annotation is malformed. A SUCCESSFUL tool call with
+ *       findings in it. Reporting exit 1 as a tool error would tell the agent
+ *       the linter broke, when what happened is the linter worked and the code
+ *       is wrong — and an agent that reads "tool failed" retries the tool
+ *       instead of fixing the annotation.
+ *   2 — the linter could not do its job. A tool error, and the only one. The
+ *       gem deliberately emits NO document on this path (a `{"ok": false,
+ *       "findings": []}` for a run that checked nothing is how a gate that
+ *       checked nothing gets mistaken for one that found nothing), so the prose
+ *       it wrote to stderr is the entire diagnosis and is passed through.
+ *
+ * `ok` is read off the document rather than re-derived from the exit code, and
+ * the exit code is reported beside it, so an agent can see the two agree.
+ *
+ * == What is deliberately not validated here
+ *
+ * `--changed` together with explicit paths is misuse, and the linter exits 2
+ * saying so. This tool does not pre-empt that. Re-implementing the rule would
+ * put a second copy of the linter's argument grammar in a different language,
+ * free to drift the day the gem adds a flag — and the tool would then be
+ * enforcing a contract it does not own. The schema documents the conflict; the
+ * linter adjudicates it.
+ */
+const lintIntentAnnotations = {
+    name: "lint_intent_annotations",
+    title: "Lint @intent annotations",
+    description: "Validate the `@intent:` annotations in a Ruby project's RSpec files against the " +
+        "OpenTestIntent schema, using that project's own `specguard-lint`. Returns each finding as " +
+        "structured data — file, line, failure kind (schema / extraction / parse / read), and every " +
+        "violated rule — so a malformed annotation can be fixed without reading a CI log. " +
+        "Use it after writing or editing `@intent:` annotations, or to audit a suite. " +
+        "A MISSING annotation is never a failure: adoption is gradual by design, so a suite with no " +
+        "annotations at all lints clean. Runs locally and needs no SpecGuard deployment or API key.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project_dir: {
+                type: "string",
+                description: "Absolute path to the Ruby project to lint — the directory holding its Gemfile and " +
+                    "spec/. Defaults to the directory this server was started in.",
+            },
+            paths: {
+                type: "array",
+                items: { type: "string" },
+                description: "Specific spec files to check, relative to project_dir. Omit to check every *_spec.rb " +
+                    "under it. An empty list is an error, not a way to say 'everything'. " +
+                    "Cannot be combined with `changed`.",
+            },
+            changed: {
+                type: "boolean",
+                description: "Check only spec files that differ from the merge base with the default branch — the " +
+                    "mode CI uses. Cannot be combined with `paths`.",
+            },
+            base: {
+                type: "string",
+                description: "Diff `changed` against this git ref instead of the default merge base. Ignored unless " +
+                    "`changed` is true.",
+            },
+        },
+        additionalProperties: false,
+    },
+    async run(args, context) {
+        const projectDir = optionalString(args["project_dir"], "project_dir");
+        const paths = optionalStringArray(args["paths"], "paths");
+        const changed = optionalBoolean(args["changed"], "changed");
+        const base = optionalString(args["base"], "base");
+        // Every argument is checked before anything is spawned, so a call that was
+        // never going to run cannot leave a subprocess behind to explain.
+        if (projectDir !== undefined)
+            await requireProjectDir(projectDir);
+        const argv = [...context.config.lintCommand, "--json"];
+        if (changed === true)
+            argv.push(base === undefined ? "--changed" : `--changed=${base}`);
+        if (paths !== undefined)
+            argv.push(...paths);
+        const result = await context.runCommand(argv, {
+            cwd: projectDir,
+            notFoundHint: LINT_COMMAND_HINT,
+        });
+        // Exit 2 — and every signal death, which is the same "no verdict" outcome
+        // wearing a different code. stderr is the diagnosis; there is no document.
+        if (result.code !== 0 && result.code !== 1) {
+            throw new CommandError(`specguard-lint could not check anything (exit ${result.code ?? `signal ${result.signal}`}). ` +
+                `It reported:\n${result.stderr.trim() || "(nothing on stderr)"}`);
+        }
+        const report = parseReport(result);
+        return {
+            // The provenance line the gem writes to stderr on EVERY run names which
+            // implementation produced the verdicts (Ruby, or the Go port when
+            // SPECGUARD_VALIDATE_INTENT is set). It is deliberately absent from the
+            // document — SPGD-247 keeps it in one place — so dropping stderr here
+            // would make "which validator ran" unanswerable from this tool.
+            text: renderText(report, result.stderr, result.code),
+            structured: {
+                exit_code: result.code,
+                ok: report.ok,
+                report,
+                linter_stderr: result.stderr.trim(),
+            },
+        };
+    },
+};
+export default lintIntentAnnotations;
+/**
+ * What to try when `specguard-lint` is not on PATH.
+ *
+ * Passed to `runCommand` rather than baked into it: only this tool knows that
+ * ITS command comes from `SPECGUARD_LINT_COMMAND`, and a shared helper that
+ * names one tool's variable would misdirect every later tool that spawns
+ * something else.
+ */
+const LINT_COMMAND_HINT = "Set SPECGUARD_LINT_COMMAND to the command that runs it here " +
+    '(for a bundled Ruby project that is usually "bundle exec specguard-lint").';
+/**
+ * `project_dir` names a directory that exists, or the failure says exactly that.
+ *
+ * This check earns its place because of WHO supplies the argument. `project_dir`
+ * is model-supplied — an agent guesses a repository root — which makes it the
+ * likeliest thing about a call to this tool to be wrong. Unchecked it becomes
+ * `spawn`'s `cwd`, and Node reports a missing `cwd` as ENOENT: the same code as
+ * a missing binary. The answer to a mistyped path would then be "specguard-lint
+ * is not on this server's PATH; set SPECGUARD_LINT_COMMAND" — every clause of it
+ * wrong, and it names the one thing that was right. Worse, it points an agent at
+ * MCP server configuration it usually cannot reach, to fix a working install, so
+ * it will try again and fail identically.
+ *
+ * Checked here rather than in `run-command` because this is the only place the
+ * argument's NAME is known, and naming `project_dir` is what turns this from a
+ * message about the server into one the agent can act on unaided.
+ */
+async function requireProjectDir(projectDir) {
+    let isDirectory;
+    try {
+        isDirectory = (await stat(projectDir)).isDirectory();
+    }
+    catch {
+        throw new CommandError(`\`project_dir\` ${JSON.stringify(projectDir)} does not exist${resolvedNote(projectDir)}. ` +
+            "Pass the absolute path of the project root — the directory holding its Gemfile and " +
+            "spec/ — or omit `project_dir` to lint the directory this server was started in. " +
+            "(specguard-lint itself was not the problem.)");
+    }
+    if (!isDirectory) {
+        throw new CommandError(`\`project_dir\` ${JSON.stringify(projectDir)} is not a directory${resolvedNote(projectDir)}. ` +
+            "Pass the project root — the directory holding its Gemfile and spec/ — not a file inside " +
+            "it. To lint one file, pass it in `paths` instead.");
+    }
+}
+/**
+ * A relative `project_dir` is resolved against whatever directory this server
+ * was started in, which is not the agent's working directory and is not
+ * something the agent can see. When the two can differ, the path that was
+ * actually used is the useful half of the message.
+ */
+function resolvedNote(projectDir) {
+    return isAbsolute(projectDir)
+        ? ""
+        : ` (a relative path, resolved against this server's working directory to ${JSON.stringify(resolve(projectDir))})`;
+}
+/**
+ * Takes the whole `CommandResult` rather than the three or four fields it reads.
+ *
+ * Not tidiness: `stdoutTruncated` and `outputDrained` are both booleans meaning
+ * "the output is not all here", they are both consulted below, and they carry
+ * OPPOSITE remedies — ask for less output, versus stop leaving a process holding
+ * the pipe. As positional arguments they would typecheck swapped, and a swap
+ * would silently exchange one of this file's diagnoses for the other. The struct
+ * makes the two unswappable at the call site.
+ */
+function parseReport(result) {
+    const { stdout, stderr, stdoutTruncated: truncated, outputDrained: drained } = result;
+    const trimmed = stdout.trim();
+    if (trimmed === "") {
+        // Asked BEFORE the sibling below, because the two answer different
+        // questions and only one of them is established here. "The linter wrote no
+        // document" is a claim about the linter; when the pipe was never drained
+        // this bridge stopped listening, so what the linter wrote is precisely what
+        // we do not know. Blaming SPECGUARD_LINT_COMMAND for silence we caused is
+        // the `cwd`-vs-PATH mistake this file already refuses once above — it sends
+        // the reader to change the one thing that was right.
+        if (!drained)
+            throw new CommandError(undrainedPipe(result, ""));
+        // stderr is carried, not dropped. An exit of 0 or 1 with an empty stdout is
+        // most often produced by the WRAPPER in SPECGUARD_LINT_COMMAND — `bundle`,
+        // `rbenv`, a docker shim — failing before the linter ever ran, and such a
+        // wrapper explains itself on stderr and nowhere else. Withholding that line
+        // to speculate about the variable instead leaves the one reader who could
+        // fix it guessing, which is the failure mode the sibling branches below
+        // (and the exit-2 branch above) already avoid by quoting their evidence.
+        const reported = stderr.trim();
+        throw new CommandError("specguard-lint exited with a verdict but wrote no JSON document, so there are no " +
+            "findings to report — this is NOT a clean run." +
+            (reported === ""
+                ? " It wrote nothing on stderr either. The command in SPECGUARD_LINT_COMMAND may not be " +
+                    "specguard-lint, or may be a version older than the one that added --json."
+                : `\n\nIt reported:\n${truncate(reported)}\n\n` +
+                    "That is the command in SPECGUARD_LINT_COMMAND reporting why it produced no document."));
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        // Truncation is checked FIRST, because it is a cause and "not JSON" is only
+        // the symptom it produces. A document this bridge cut in half does not parse,
+        // and blaming the linter's output for it would name the wrong cause — and
+        // withhold the one thing that would fix it, which is asking for less.
+        if (truncated) {
+            throw new CommandError(`specguard-lint produced more than ${MAX_OUTPUT_BYTES / 1024 / 1024} MB of output, so ` +
+                "this bridge truncated it and the JSON document is incomplete — no findings could be " +
+                "read from it. Narrow the run with `paths`, or with `changed` to check only what " +
+                "differs from the merge base.");
+        }
+        // The same reasoning one rung further out, and it is ordered AFTER truncation
+        // deliberately: both mean "this bridge stopped reading", but truncation is
+        // the definite cut with the actionable remedy, so when a run manages to hit
+        // the 4 MB ceiling AND leak a descriptor, "ask for less" is still the advice
+        // that works. Below it, though, a document this bridge stopped reading is
+        // not the linter emitting garbage, and saying so would name the wrong cause.
+        if (!drained)
+            throw new CommandError(undrainedPipe(result, trimmed));
+        throw new CommandError(`specguard-lint's output was not JSON, so no findings could be read. It wrote:\n${truncate(trimmed)}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new CommandError("specguard-lint's --json output was not a JSON object.");
+    }
+    return parsed;
+}
+/**
+ * The diagnosis for a run whose output this bridge stopped reading.
+ *
+ * Reached only from the two failure branches above, never on its own: an
+ * undrained pipe that still delivered a parseable document is not an error and
+ * must not be reported as one. `outputDrained: false` says the tail was not
+ * waited for, not that anything is missing from what arrived — the run whose
+ * last unread byte was a newline is a successful run, and the caller sees the
+ * findings. So this is what a lost tail COST, asked only once something is
+ * actually absent.
+ *
+ * Names the pipe-holder rather than the linter or its configuration, because
+ * the remedy lives in neither: the command ran and SPECGUARD_LINT_COMMAND is
+ * correct. What is wrong is that the run leaves something behind holding the
+ * output, and re-running is the one thing guaranteed not to help.
+ */
+function undrainedPipe(result, partial) {
+    const reported = result.stderr.trim();
+    return (`specguard-lint exited ${result.code}, but this bridge did not receive its complete JSON ` +
+        `document — no findings could be read, and this is NOT a clean run. The command itself ` +
+        `finished; something it left running kept the output pipe open, so the bridge stopped ` +
+        `reading ${EXIT_CLOSE_GRACE_MS}ms later rather than waiting forever.\n\n` +
+        "The linter's output is not the problem here, and neither is SPECGUARD_LINT_COMMAND — that " +
+        "command ran. Look for a process the run leaves behind holding its stdout: a preloader " +
+        "(Ruby's `spring` is the usual one) or a helper the wrapper starts in the background. " +
+        "Stopping it is what makes the document arrive; re-running unchanged will end the same way." +
+        (partial === "" ? "" : `\n\nThe partial document was:\n${truncate(partial)}`) +
+        (reported === "" ? "" : `\n\nIt reported on stderr:\n${truncate(reported)}`));
+}
+/**
+ * The text rendering, built FROM the same parsed document the structured half
+ * carries — never a second pass over the raw output. A tool whose two renderings
+ * of one call can disagree is worse than one that returns only prose, because
+ * the disagreement is invisible from outside.
+ */
+function renderText(report, stderr, code) {
+    const provenance = stderr.trim();
+    return [
+        `specguard-lint exited ${code} (${code === 0 ? "no malformed annotations" : "malformed annotations found"}).`,
+        provenance === "" ? undefined : provenance,
+        JSON.stringify(report, null, 2),
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n\n");
+}
+function truncate(value, limit = 2000) {
+    return value.length <= limit ? value : `${value.slice(0, limit)}… [truncated]`;
+}
+/**
+ * A non-empty list of non-empty paths, or nothing.
+ *
+ * `paths: []` is REFUSED rather than normalised. Both readings of it are bad and
+ * neither is what an agent meant: passed through, an empty list leaves the
+ * linter with no positional arguments and it audits EVERY spec file in the
+ * project, so "check nothing" comes back as a clean bill of health for the whole
+ * suite; silently treated as "not given", the same thing happens by a different
+ * route. A tool whose entire purpose is to stop a check that examined nothing
+ * from looking like a check that found nothing cannot itself answer an empty
+ * selection with "all clean". So it is an error, and the message says which of
+ * the two the caller probably wanted.
+ */
+function optionalStringArray(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new ArgumentError(`\`${field}\` must be an array of strings.`);
+    const entries = value.map((entry) => {
+        if (typeof entry !== "string")
+            throw new ArgumentError(`\`${field}\` must contain only strings.`);
+        // Trimmed BEFORE the checks below, so a stray space cannot smuggle an entry
+        // past the leading-dash guard as " --version".
+        return entry.trim();
+    });
+    const nonEmpty = entries.filter((entry) => entry !== "");
+    if (nonEmpty.length === 0) {
+        throw new CommandError(`\`${field}\` was given but names no file${entries.length === 0 ? "" : " (every entry was blank)"}, ` +
+            "which selects nothing to check. Omit `paths` to check every spec file in the project, " +
+            "or list the files you want checked — an empty selection is not treated as “everything”, " +
+            "because a run that checked nothing must never come back clean.");
+    }
+    // A leading `-` would be read by the linter's OptionParser as a flag rather
+    // than a path — `--version` would exit 0 having checked nothing, which is the
+    // false-clean result this whole toolchain exists to prevent. Paths are paths.
+    for (const entry of nonEmpty) {
+        if (entry.startsWith("-")) {
+            throw new CommandError(`\`${field}\` entries are file paths and cannot start with "-" (got ${JSON.stringify(entry)}).`);
+        }
+    }
+    return nonEmpty;
+}
+//# sourceMappingURL=lint-intent-annotations.js.map

package/dist/src/tools/lint-intent-annotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-intent-annotations.js","sourceRoot":"","sources":["../../../src/tools/lint-intent-annotations.ts"],"names":[],"mappings":"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"}