@shrkcrft/mcp-server 0.1.0-alpha.1 → 0.1.0-alpha.11

package/README.md

@@ -2,7 +2,7 @@
 
 SharkCraft MCP server: 25 tools over @modelcontextprotocol/sdk's stdio transport.
 
-Part of [SharkCraft](https://github.com/sharkcraft/sharkcraft) — a deterministic, local-first toolkit that gives AI coding agents durable project context. See the main repo for documentation, examples, and the `shrk` CLI.
+Part of [SharkCraft](https://github.com/shrkcrft/sharkcraft) — a deterministic, local-first toolkit that gives AI coding agents durable project context. See the main repo for documentation, examples, and the `shrk` CLI.
 
 ## Install
 

package/dist/main.d.ts

@@ -1,3 +1,3 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 export {};
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { startMcpServer } from "./server/create-mcp-server.js";
 function extractFlag(argv, name) {
     for (let i = 0; i < argv.length; i += 1) {

package/dist/server/create-mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-mcp-server.d.ts","sourceRoot":"","sources":["../../src/server/create-mcp-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAQnE,OAAO,EAAqB,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEpF,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAK9B,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,qEAAqE;IACrE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,MAAM,WAAW,6BAA8B,SAAQ,gBAAgB;IACrE,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,UAAU,WAAW;IACnB,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACzC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC1C,mCAAmC;IACnC,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAIR;AAqBD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,6BAA6B,GAAG;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC;CACpB,CAqHA;AAED,wBAAsB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CA0EvF"}
+{"version":3,"file":"create-mcp-server.d.ts","sourceRoot":"","sources":["../../src/server/create-mcp-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAQnE,OAAO,EAAqB,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAM9B,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,qEAAqE;IACrE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,MAAM,WAAW,6BAA8B,SAAQ,gBAAgB;IACrE,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,UAAU,WAAW;IACnB,MAAM,EAAE,gBAAgB,CAAC;IACzB,UAAU,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACzC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC1C,mCAAmC;IACnC,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GACpD,MAAM,CAIR;AAqBD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,6BAA6B,GAAG;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,WAAW,CAAC;CACpB,CAgIA;AAED,wBAAsB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAmEvF"}

package/dist/server/create-mcp-server.js

@@ -3,9 +3,9 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { inspectSharkcraft } from '@shrkcrft/inspector';
-import { initTokenizer } from '@shrkcrft/context';
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION, } from "./mcp-server-config.js";
 import { ALL_TOOLS } from "../tools/index.js";
+import { PRIMARY_MCP_TOOLS, shouldAdvertiseFullToolset } from "../tools/primary-tools.js";
 import { validateToolInput } from "./tool-input-validators.js";
 import { buildResourceList, readResource } from "../resources/index.js";
 /**
@@ -53,13 +53,24 @@ export function createSharkcraftServer(config) {
             resources: { listChanged: true },
         },
     });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: ALL_TOOLS.map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: t.inputSchema,
-        })),
-    }));
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        // Default `tools/list` advertises only the ~30 primary tools to
+        // keep the agent's tool-selection surface focused. The other ~200
+        // tools stay CALLABLE via `tools/call` for agents that already
+        // know the name (e.g. via `shrk export claude-skill` referencing
+        // them). Set SHRK_MCP_FULL_TOOLS=1 to advertise everything.
+        const advertiseFull = shouldAdvertiseFullToolset();
+        const advertised = advertiseFull
+            ? ALL_TOOLS
+            : ALL_TOOLS.filter((t) => PRIMARY_MCP_TOOLS.has(t.name));
+        return {
+            tools: advertised.map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            })),
+        };
+    });
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const name = request.params.name;
         const args = (request.params.arguments ?? {});
@@ -141,11 +152,6 @@ export function createSharkcraftServer(config) {
 export async function startMcpServer(options = {}) {
     const cwd = resolveTargetRoot(options.cwd, options.projectRoot);
     const verbose = options.verbose ?? false;
-    // Best-effort upgrade from the estimator to gpt-tokenizer. Failure leaves
-    // the estimator active — the server still serves requests.
-    if (process.env.SHARKCRAFT_NO_REAL_TOKENIZER !== '1') {
-        initTokenizer().catch(() => undefined);
-    }
     const { server, state } = createSharkcraftServer({
         name: MCP_SERVER_NAME,
         version: MCP_SERVER_VERSION,
@@ -198,8 +204,8 @@ export async function startMcpServer(options = {}) {
         };
         process.on('SIGINT', () => void stop());
         process.on('SIGTERM', () => void stop());
-        // Always announce the URL on stderr so the user knows where to connect.
-        process.stderr.write(`[mcp] http endpoint: ${handle.url}\n`);
+        if (verbose)
+            process.stderr.write(`[mcp] http endpoint: ${handle.url}\n`);
         return;
     }
     const transport = new StdioServerTransport();

package/dist/server/http-transport.d.ts

@@ -2,9 +2,9 @@ import type { Server as McpServer } from '@modelcontextprotocol/sdk/server/index
 export interface StartHttpServerOptions {
     /** McpServer (NOT yet connected). */
     server: McpServer;
-    /** Bind host. Default '127.0.0.1' (loopback only). */
+    /** Bind host. Default 'localhost'. */
     host?: string;
-    /** Bind port. Default 0 (kernel-assigned ephemeral). */
+    /** Bind port. Default 4000. */
     port?: number;
     /** Path that accepts MCP traffic. Default '/mcp'. */
     path?: string;
@@ -17,12 +17,7 @@ export interface StartHttpServerOptions {
     log?: (line: string) => void;
 }
 export interface HttpServerHandle {
-    /** Full URL clients should POST to (host:port + path). */
     url: string;
-    /** The host the server is actually bound to. */
-    host: string;
-    /** The port the server is actually bound to (resolved when port=0). */
-    port: number;
     close: () => Promise<void>;
 }
 export declare function startHttpServer(options: StartHttpServerOptions): Promise<HttpServerHandle>;

package/dist/server/http-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-transport.d.ts","sourceRoot":"","sources":["../../src/server/http-transport.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAErF,MAAM,WAAW,sBAAsB;IACrC,qCAAqC;IACrC,MAAM,EAAE,SAAS,CAAC;IAClB,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qBAAqB;IACrB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAsBD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAuDhG"}
+{"version":3,"file":"http-transport.d.ts","sourceRoot":"","sources":["../../src/server/http-transport.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,IAAI,SAAS,EAAE,MAAM,2CAA2C,CAAC;AAErF,MAAM,WAAW,sBAAsB;IACrC,qCAAqC;IACrC,MAAM,EAAE,SAAS,CAAC;IAClB,sCAAsC;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qBAAqB;IACrB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAsBD,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmDhG"}

package/dist/server/http-transport.js

@@ -22,8 +22,8 @@ function writeJson(res, status, body) {
     res.end(JSON.stringify(body));
 }
 export async function startHttpServer(options) {
-    const host = options.host ?? '127.0.0.1';
-    const requestedPort = options.port ?? 0;
+    const host = options.host ?? 'localhost';
+    const port = options.port ?? 4000;
     const path = options.path ?? '/mcp';
     const stateful = options.stateful ?? true;
     const log = options.log ?? (() => undefined);
@@ -40,7 +40,7 @@ export async function startHttpServer(options) {
             writeJson(res, 200, { ok: true, transport: 'streamable-http', stateful });
             return;
         }
-        const url = new URL(req.url, `http://${host}:${requestedPort || 80}`);
+        const url = new URL(req.url, `http://${host}:${port}`);
         if (url.pathname !== path) {
             writeJson(res, 404, { error: `not found: ${url.pathname}` });
             return;
@@ -59,14 +59,10 @@ export async function startHttpServer(options) {
             }
         }
     });
-    await new Promise((resolve) => http.listen(requestedPort, host, resolve));
-    const address = http.address();
-    const actualPort = address?.port ?? requestedPort;
-    log(`[mcp:http] listening on http://${host}:${actualPort}${path} (stateful=${stateful})`);
+    await new Promise((resolve) => http.listen(port, host, resolve));
+    log(`[mcp:http] listening on http://${host}:${port}${path} (stateful=${stateful})`);
     return {
-        url: `http://${host}:${actualPort}${path}`,
-        host,
-        port: actualPort,
+        url: `http://${host}:${port}${path}`,
         close: async () => {
             await transport.close().catch(() => undefined);
             await new Promise((resolve, reject) => http.close((err) => (err ? reject(err) : resolve())));

package/dist/tools/all-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"all-tools.d.ts","sourceRoot":"","sources":["../../src/tools/all-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAmTpE,eAAO,MAAM,SAAS,EAAE,SAAS,eAAe,EA6P9C,CAAC"}
+{"version":3,"file":"all-tools.d.ts","sourceRoot":"","sources":["../../src/tools/all-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAuUpE,eAAO,MAAM,SAAS,EAAE,SAAS,eAAe,EAgR9C,CAAC"}

package/dist/tools/all-tools.js

@@ -42,6 +42,28 @@ import { checkBoundariesTool } from "./check-boundaries.tool.js";
 import { listBoundaryRulesTool } from "./list-boundary-rules.tool.js";
 import { getBoundaryRuleTool } from "./get-boundary-rule.tool.js";
 import { getImportGraphSummaryTool } from "./get-import-graph-summary.tool.js";
+import { getGraphStatusTool } from "./get-graph-status.tool.js";
+import { getGraphSearchTool } from "./get-graph-search.tool.js";
+import { getGraphContextTool } from "./get-graph-context.tool.js";
+import { getGraphImpactTool } from "./get-graph-impact.tool.js";
+import { getGraphCallersTool } from "./get-graph-callers.tool.js";
+import { getGraphCyclesTool } from "./get-graph-cycles.tool.js";
+import { getGraphUnresolvedTool } from "./get-graph-unresolved.tool.js";
+import { getGraphDepsTool } from "./get-graph-deps.tool.js";
+import { getImpactBaselineTool } from "./get-impact-baseline.tool.js";
+import { getPatternRegistryTool } from "./get-pattern-registry.tool.js";
+import { getIntentBenchmarkRunTool } from "./get-intent-benchmark-run.tool.js";
+import { getCodeIntelligenceStateTool } from "./get-code-intelligence-state.tool.js";
+import { getRulesForFileTool } from "./get-rules-for-file.tool.js";
+import { getStructuralSearchTool } from "./get-structural-search.tool.js";
+import { getStructuralRewritePlanTool } from "./get-structural-rewrite-plan.tool.js";
+import { getGraphImpactAnalysisTool } from "./get-graph-impact-analysis.tool.js";
+import { getContextPackTool } from "./get-context-pack.tool.js";
+import { getArchViolationsTool } from "./get-arch-violations.tool.js";
+import { getFrameworkEntitiesTool } from "./get-framework-entities.tool.js";
+import { getApiSurfaceDiffTool } from "./get-api-surface-diff.tool.js";
+import { getQualityGateTool } from "./get-quality-gate.tool.js";
+import { getMigrationsTool } from "./get-migrations.tool.js";
 import { getDriftReportTool } from "./get-drift-report.tool.js";
 import { getKnowledgeGraphTool } from "./get-knowledge-graph.tool.js";
 import { getGraphNodeTool } from "./get-graph-node.tool.js";
@@ -116,7 +138,8 @@ import { getContractTemplateTool, getLanguageCommandsTool, getLanguageProfilesTo
 import { getTaskContextTool, understandTaskTool, validateChangeContextTool, } from "./r26-task-context.tool.js";
 import { getLanguageCacheStatusTool, getLanguageProfilesLiveTool, getLanguageRunPlanTool, getPolyglotBoundaryReportTool, } from "./r27-polyglot.tool.js";
 import { getChangedBoundaryReportTool } from "./r28-changed-boundary.tool.js";
-import { previewPluginRemoveTool, previewPluginRenameTool } from "./r28-plugin-lifecycle.tool.js";
+import { getDiffCheckReportTool } from "./diff-check.tool.js";
+import { getFileAdviceTool } from "./file-advice.tool.js";
 import { getHelperTool, listHelpersTool, previewHelperPlanTool } from "./r28-helpers.tool.js";
 import { getPackDevStatusTool, previewPackTestsTool } from "./r28-pack-author.tool.js";
 import { getRegistryLifecycleReportTool } from "./r28-registry-lifecycle.tool.js";
@@ -135,7 +158,7 @@ import { suggestCommandsTool, searchCommandsTool, explainCommandTool, } from "./
 import { previewFixTool, listFixKindsTool, } from "./r31-fix-preview.tool.js";
 import { getScaffoldCoverageReportTool } from "./r31-scaffold-coverage.tool.js";
 import { getChangesSummaryTool, getPrSummaryPreviewTool, getCiIntegrityReportTool, } from "./r31-changes-pr-ci.tool.js";
-import { listProfilesTool, getProfileTool, getProfilesDoctorTool, listPluginLifecycleProfilesTool, getPluginLifecycleProfileTool, getPluginLifecycleProfileDoctorTool, } from "./r32-profiles.tool.js";
+import { listProfilesTool, getProfileTool, getProfilesDoctorTool, } from "./r32-profiles.tool.js";
 import { getProjectCouplingReportTool } from "./r32-project-coupling.tool.js";
 import { getPackContributionsTool, getPackConflictsTool, } from "./r33-pack-contributions.tool.js";
 import { listConventionsTool, getConventionTool, getConventionsDoctorTool, } from "./r33-conventions.tool.js";
@@ -192,6 +215,28 @@ export const ALL_TOOLS = Object.freeze([
     listBoundaryRulesTool,
     getBoundaryRuleTool,
     getImportGraphSummaryTool,
+    getGraphStatusTool,
+    getGraphSearchTool,
+    getGraphContextTool,
+    getGraphImpactTool,
+    getGraphCallersTool,
+    getGraphCyclesTool,
+    getGraphUnresolvedTool,
+    getGraphDepsTool,
+    getImpactBaselineTool,
+    getPatternRegistryTool,
+    getIntentBenchmarkRunTool,
+    getCodeIntelligenceStateTool,
+    getRulesForFileTool,
+    getStructuralSearchTool,
+    getStructuralRewritePlanTool,
+    getGraphImpactAnalysisTool,
+    getContextPackTool,
+    getArchViolationsTool,
+    getFrameworkEntitiesTool,
+    getApiSurfaceDiffTool,
+    getQualityGateTool,
+    getMigrationsTool,
     getDriftReportTool,
     getKnowledgeGraphTool,
     getGraphNodeTool,
@@ -334,8 +379,8 @@ export const ALL_TOOLS = Object.freeze([
     getLanguageCacheStatusTool,
     getLanguageProfilesLiveTool,
     getChangedBoundaryReportTool,
-    previewPluginRenameTool,
-    previewPluginRemoveTool,
+    getDiffCheckReportTool,
+    getFileAdviceTool,
     listHelpersTool,
     getHelperTool,
     previewHelperPlanTool,
@@ -370,9 +415,6 @@ export const ALL_TOOLS = Object.freeze([
     listProfilesTool,
     getProfileTool,
     getProfilesDoctorTool,
-    listPluginLifecycleProfilesTool,
-    getPluginLifecycleProfileTool,
-    getPluginLifecycleProfileDoctorTool,
     getProjectCouplingReportTool,
     getPackContributionsTool,
     getPackConflictsTool,

package/dist/tools/diff-check.tool.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read-only MCP tool: get_diff_check_report.
+ *
+ * The MCP-side mirror of `shrk diff-check`. Same envelope, same
+ * verdict logic — the agent gets a single structured answer to "did
+ * my edits pass this project's boundary + import-hygiene gates?".
+ *
+ * Still read-only: this tool DOES NOT fix anything, even when it
+ * could trivially suggest the fix. The agent reads the envelope, then
+ * the human (or the agent, via a separate write-path tool) runs the
+ * fix on the CLI. Keeps the safety contract intact.
+ */
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getDiffCheckReportTool: IToolDefinition;
+//# sourceMappingURL=diff-check.tool.d.ts.map

package/dist/tools/diff-check.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-check.tool.d.ts","sourceRoot":"","sources":["../../src/tools/diff-check.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAaH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAyBpE,eAAO,MAAM,sBAAsB,EAAE,eAyHpC,CAAC"}

package/dist/tools/diff-check.tool.js

@@ -0,0 +1,157 @@
+/**
+ * Read-only MCP tool: get_diff_check_report.
+ *
+ * The MCP-side mirror of `shrk diff-check`. Same envelope, same
+ * verdict logic — the agent gets a single structured answer to "did
+ * my edits pass this project's boundary + import-hygiene gates?".
+ *
+ * Still read-only: this tool DOES NOT fix anything, even when it
+ * could trivially suggest the fix. The agent reads the envelope, then
+ * the human (or the agent, via a separate write-path tool) runs the
+ * fix on the CLI. Keeps the safety contract intact.
+ */
+import { buildImportHygieneReport, filterViolationsToChangedScope, resolveChangedFiles, } from '@shrkcrft/inspector';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+const SCHEMA = 'sharkcraft.diff-check/v1';
+function resolveScopeFromInput(input, cwd) {
+    const staged = input.staged === true;
+    const since = typeof input.since === 'string' ? input.since : undefined;
+    const files = Array.isArray(input.files)
+        ? input.files.filter((f) => typeof f === 'string')
+        : [];
+    if (files.length > 0) {
+        return { mode: 'files', options: { projectRoot: cwd, files } };
+    }
+    if (staged) {
+        return { mode: 'staged', options: { projectRoot: cwd, staged: true } };
+    }
+    if (since) {
+        return { mode: 'since', options: { projectRoot: cwd, since } };
+    }
+    return { mode: 'worktree', options: { projectRoot: cwd, includeWorktree: true } };
+}
+export const getDiffCheckReportTool = {
+    name: 'get_diff_check_report',
+    description: 'Self-check the current git diff against this project\'s boundary + import-hygiene rules. Single-call composite of the boundary-check and import-hygiene engines, scoped to the changed files, with one verdict (ok | warnings | errors) and one nextAction line. Use after editing code so you can validate before declaring done. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            staged: { type: 'boolean', description: 'Scope to staged changes only.' },
+            since: { type: 'string', description: 'Compare against ref (HEAD, origin/main, SHA).' },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Explicit file list (overrides --staged / --since).',
+            },
+        },
+    },
+    async handler(input, ctx) {
+        const cwd = ctx.cwd;
+        const { mode, options: scopeOptions } = resolveScopeFromInput(input, cwd);
+        const changed = resolveChangedFiles(scopeOptions);
+        const changedFiles = changed.files;
+        const rules = ctx.inspection.boundaryRegistry.list();
+        let boundaryBlock = {
+            ran: false,
+            rulesEvaluated: 0,
+            counts: { error: 0, warning: 0, info: 0 },
+            violations: [],
+        };
+        if (rules.length > 0 && changedFiles.length > 0) {
+            const scan = scanImports({ projectRoot: cwd });
+            const tsconfigPaths = loadTsconfigPaths(cwd);
+            const evalResult = evaluateBoundaries(scan, rules, {
+                ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+            });
+            const filtered = filterViolationsToChangedScope(evalResult.violations, scopeOptions);
+            boundaryBlock = {
+                ran: true,
+                rulesEvaluated: evalResult.rulesEvaluated,
+                counts: {
+                    error: filtered.includedViolations.filter((v) => v.severity === 'error').length,
+                    warning: filtered.includedViolations.filter((v) => v.severity === 'warning').length,
+                    info: filtered.includedViolations.filter((v) => v.severity === 'info').length,
+                },
+                violations: filtered.includedViolations,
+            };
+        }
+        else if (rules.length > 0) {
+            boundaryBlock = { ...boundaryBlock, ran: true, rulesEvaluated: rules.length };
+        }
+        let importsBlock = {
+            ran: false,
+            verdict: 'skipped',
+            counts: {},
+            findings: [],
+        };
+        if (changedFiles.length > 0) {
+            const report = buildImportHygieneReport(cwd, { files: changedFiles });
+            importsBlock = {
+                ran: true,
+                verdict: report.verdict,
+                counts: report.counts ?? {},
+                findings: report.findings,
+            };
+        }
+        // Derive verdict — same logic as the CLI command, duplicated
+        // intentionally to keep the MCP tool self-contained (no CLI
+        // import — preserves the package dependency direction).
+        const bErr = boundaryBlock.counts.error;
+        const bWarn = boundaryBlock.counts.warning;
+        const iErr = importsBlock.verdict === 'errors' ? (importsBlock.counts.error ?? importsBlock.findings.length) : 0;
+        const iWarn = importsBlock.verdict === 'warnings' ? (importsBlock.counts.warning ?? importsBlock.findings.length) : 0;
+        let verdict;
+        let summary;
+        let nextAction;
+        if (changedFiles.length === 0) {
+            verdict = 'ok';
+            summary = 'No files changed in the current diff scope.';
+            nextAction =
+                'Nothing to check. If you expected changes, verify the `staged` / `since` argument or save edits first.';
+        }
+        else if (bErr > 0 || iErr > 0) {
+            verdict = 'errors';
+            const parts = [];
+            if (bErr > 0)
+                parts.push(`${bErr} boundary violation${bErr === 1 ? '' : 's'}`);
+            if (iErr > 0)
+                parts.push(`${iErr} import-hygiene error${iErr === 1 ? '' : 's'}`);
+            summary = `Diff fails the gate: ${parts.join(', ')}.`;
+            nextAction =
+                'Fix every error in `boundaries.violations` and `imports.findings` (each entry\'s `suggestedFix` shows the fix), then re-run.';
+        }
+        else if (bWarn > 0 || iWarn > 0) {
+            verdict = 'warnings';
+            const parts = [];
+            if (bWarn > 0)
+                parts.push(`${bWarn} boundary warning${bWarn === 1 ? '' : 's'}`);
+            if (iWarn > 0)
+                parts.push(`${iWarn} import-hygiene warning${iWarn === 1 ? '' : 's'}`);
+            summary = `Diff passes the gate with ${parts.join(', ')}.`;
+            nextAction = 'Safe to declare done. Review warnings if the diff touches a sensitive area.';
+        }
+        else {
+            verdict = 'ok';
+            summary = `Diff passes the gate (${changedFiles.length} file${changedFiles.length === 1 ? '' : 's'}, 0 violations).`;
+            nextAction = 'Safe to declare done.';
+        }
+        return {
+            text: `verdict=${verdict}. ${summary} ${nextAction}`,
+            data: {
+                schema: SCHEMA,
+                generatedAt: new Date().toISOString(),
+                scope: {
+                    mode,
+                    files: changedFiles,
+                    fileCount: changedFiles.length,
+                },
+                boundaries: boundaryBlock,
+                imports: importsBlock,
+                verdict,
+                summary,
+                nextAction,
+            },
+        };
+    },
+};

package/dist/tools/file-advice.tool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Read-only MCP tool: get_file_advice.
+ *
+ * For a given file path, returns the rules, path conventions, boundary
+ * rules, and knowledge entries that apply to it. The agent equivalent
+ * of `shrk why <file>` — same engine (`buildWhyReport`), shaped for
+ * MCP consumption.
+ *
+ * Why this exists alongside `inspect_workspace` and the various
+ * `list_*` tools: agents tend to over-explore when given browsable
+ * catalogs. Asking "give me everything for this file" in one call
+ * keeps the prompt window tight and the answer focused — the agent
+ * doesn't have to discover which rule matches the file's path glob,
+ * which boundary rule constrains its imports, or which knowledge
+ * entry is the right one to read first.
+ *
+ * Use after a `shrk diff-check` flags a violation, or before editing
+ * an unfamiliar file. Read-only.
+ */
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getFileAdviceTool: IToolDefinition;
+//# sourceMappingURL=file-advice.tool.d.ts.map

package/dist/tools/file-advice.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-advice.tool.d.ts","sourceRoot":"","sources":["../../src/tools/file-advice.tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,iBAAiB,EAAE,eAyC/B,CAAC"}

package/dist/tools/file-advice.tool.js

@@ -0,0 +1,88 @@
+/**
+ * Read-only MCP tool: get_file_advice.
+ *
+ * For a given file path, returns the rules, path conventions, boundary
+ * rules, and knowledge entries that apply to it. The agent equivalent
+ * of `shrk why <file>` — same engine (`buildWhyReport`), shaped for
+ * MCP consumption.
+ *
+ * Why this exists alongside `inspect_workspace` and the various
+ * `list_*` tools: agents tend to over-explore when given browsable
+ * catalogs. Asking "give me everything for this file" in one call
+ * keeps the prompt window tight and the answer focused — the agent
+ * doesn't have to discover which rule matches the file's path glob,
+ * which boundary rule constrains its imports, or which knowledge
+ * entry is the right one to read first.
+ *
+ * Use after a `shrk diff-check` flags a violation, or before editing
+ * an unfamiliar file. Read-only.
+ */
+import { buildWhyReport } from '@shrkcrft/inspector';
+export const getFileAdviceTool = {
+    name: 'get_file_advice',
+    description: 'For a given file path, return the rules, path conventions, boundary rules, and knowledge entries that apply to it. Single-call replacement for browsing the registry to figure out what constrains one file. Read-only.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['file'],
+        properties: {
+            file: {
+                type: 'string',
+                description: 'Path to the file (absolute, or relative to the project root). The file does not need to exist — path-string matching still works.',
+            },
+            limit: {
+                type: 'number',
+                description: 'Cap rules and knowledge entries returned (default 10).',
+            },
+        },
+    },
+    async handler(input, ctx) {
+        const file = typeof input.file === 'string' ? input.file : '';
+        if (!file) {
+            return {
+                text: 'Error: `file` argument is required.',
+                data: { error: 'missing-argument', argument: 'file' },
+            };
+        }
+        const limit = typeof input.limit === 'number' && input.limit > 0 ? Math.floor(input.limit) : 10;
+        const report = buildWhyReport({
+            inspection: ctx.inspection,
+            projectRoot: ctx.cwd,
+            target: file,
+            limit,
+        });
+        const summary = buildSummary(report);
+        return {
+            text: summary,
+            data: report,
+        };
+    },
+};
+function buildSummary(report) {
+    const lines = [];
+    lines.push(`File: ${report.target.relativePath} (${report.target.kind})`);
+    if (report.inferredPackage)
+        lines.push(`Package: ${report.inferredPackage}`);
+    if (report.inferredLayer)
+        lines.push(`Layer: ${report.inferredLayer}`);
+    const counts = {
+        rules: report.rules.length,
+        boundaries: report.boundaries.length,
+        paths: report.pathConventions.length,
+        knowledge: report.knowledge.length,
+    };
+    lines.push(`Matches: ${counts.rules} rule${counts.rules === 1 ? '' : 's'}, ` +
+        `${counts.boundaries} boundary rule${counts.boundaries === 1 ? '' : 's'}, ` +
+        `${counts.paths} path convention${counts.paths === 1 ? '' : 's'}, ` +
+        `${counts.knowledge} knowledge entr${counts.knowledge === 1 ? 'y' : 'ies'}.`);
+    if (counts.rules === 0 &&
+        counts.boundaries === 0 &&
+        counts.paths === 0 &&
+        counts.knowledge === 0) {
+        lines.push('No registry entries matched. The file may be outside the conventions, or the workspace may not have rules / paths defined yet.');
+    }
+    else {
+        lines.push('See `data` for the full per-category list.');
+    }
+    return lines.join('\n');
+}

package/dist/tools/get-api-surface-diff.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getApiSurfaceDiffTool: IToolDefinition;
+//# sourceMappingURL=get-api-surface-diff.tool.d.ts.map

package/dist/tools/get-api-surface-diff.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-api-surface-diff.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-api-surface-diff.tool.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE,eAAO,MAAM,qBAAqB,EAAE,eAsDnC,CAAC"}

package/dist/tools/get-api-surface-diff.tool.js

@@ -0,0 +1,60 @@
+import { readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { diffApiSurfaces, extractApiSurface, } from '@shrkcrft/api-surface-diff';
+import { GraphStore } from '@shrkcrft/graph';
+const NEXT = 'shrk graph index';
+export const getApiSurfaceDiffTool = {
+    name: 'get_api_surface_diff',
+    description: 'Read-only: compare the current code-graph public-API surface to a baseline. Provide `baselinePath` (file system path to a previously captured `IApiSurface`) OR `baseline` (inline). Optional `packages` filter restricts both sides to those workspace packages.',
+    cliCommand: 'api-diff',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            baselinePath: { type: 'string' },
+            baseline: { type: 'object' },
+            packages: { type: 'array', items: { type: 'string' } },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const args = input;
+        const store = new GraphStore(ctx.inspection.projectRoot);
+        if (!store.exists()) {
+            return {
+                isError: true,
+                error: {
+                    code: 'graph-missing',
+                    message: "code-graph store missing",
+                    details: { nextCommand: NEXT },
+                },
+            };
+        }
+        let baseline = args.baseline;
+        if (!baseline && args.baselinePath) {
+            const abs = nodePath.isAbsolute(args.baselinePath)
+                ? args.baselinePath
+                : nodePath.resolve(ctx.inspection.projectRoot, args.baselinePath);
+            try {
+                baseline = JSON.parse(readFileSync(abs, 'utf8'));
+            }
+            catch (e) {
+                return {
+                    isError: true,
+                    error: { code: 'invalid-input', message: `baseline read failed: ${e.message}` },
+                };
+            }
+        }
+        if (!baseline) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'baseline or baselinePath is required' },
+            };
+        }
+        const snap = store.loadSnapshot();
+        const current = extractApiSurface(snap, {
+            ...(args.packages && args.packages.length > 0 ? { packageFilter: args.packages } : {}),
+        });
+        const diff = diffApiSurfaces(baseline, current);
+        return { data: diff };
+    },
+};

package/dist/tools/get-arch-violations.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getArchViolationsTool: IToolDefinition;
+//# sourceMappingURL=get-arch-violations.tool.d.ts.map

package/dist/tools/get-arch-violations.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-arch-violations.tool.d.ts","sourceRoot":"","sources":["../../src/tools/get-arch-violations.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAWpE,eAAO,MAAM,qBAAqB,EAAE,eA6BnC,CAAC"}