@shrkcrft/mcp-server 0.1.0-alpha.1

package/dist/tools/ci-permissions-fix.tool.js

@@ -0,0 +1,32 @@
+import * as nodePath from 'node:path';
+import { auditCiWorkflow, buildCiPermissionsFixPreview } from '@shrkcrft/inspector';
+export const getCiPermissionsFixPreviewTool = {
+    name: 'get_ci_permissions_fix_preview',
+    description: 'Suggest a least-privilege fix for a CI workflow. Read-only — never writes.',
+    inputSchema: {
+        type: 'object',
+        required: ['file'],
+        properties: {
+            file: { type: 'string' },
+            provider: {
+                type: 'string',
+                enum: ['github-actions', 'gitlab', 'bitbucket', 'azure', 'jenkins'],
+            },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const fileRaw = typeof input['file'] === 'string' ? input['file'] : '';
+        if (!fileRaw) {
+            return {
+                isError: true,
+                error: { code: 'invalid-input', message: 'Missing `file`.' },
+            };
+        }
+        const file = nodePath.isAbsolute(fileRaw) ? fileRaw : nodePath.resolve(ctx.cwd, fileRaw);
+        const providerRaw = typeof input['provider'] === 'string' ? input['provider'] : null;
+        const audit = auditCiWorkflow({ file, provider: providerRaw });
+        const preview = buildCiPermissionsFixPreview(audit);
+        return { data: preview };
+    },
+};

package/dist/tools/ci-permissions.tool.d.ts

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

package/dist/tools/ci-permissions.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-permissions.tool.d.ts","sourceRoot":"","sources":["../../src/tools/ci-permissions.tool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,eAAO,MAAM,yBAAyB,EAAE,eAuBvC,CAAC"}

package/dist/tools/ci-permissions.tool.js

@@ -0,0 +1,26 @@
+import * as nodePath from 'node:path';
+import { auditCiWorkflow } from '@shrkcrft/inspector';
+const VALID = new Set(['github-actions', 'gitlab', 'bitbucket', 'azure', 'jenkins']);
+export const getCiPermissionsAuditTool = {
+    name: 'get_ci_permissions_audit',
+    description: 'Audit a CI workflow YAML for write permissions, comment posting, tokens, external actions. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['file'],
+        properties: {
+            file: { type: 'string' },
+            provider: { type: 'string', enum: ['github-actions', 'gitlab', 'bitbucket', 'azure', 'jenkins'] },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const fileRaw = typeof input['file'] === 'string' ? input['file'] : '';
+        const providerRaw = typeof input['provider'] === 'string' ? input['provider'] : null;
+        const abs = nodePath.isAbsolute(fileRaw) ? fileRaw : nodePath.resolve(ctx.cwd, fileRaw);
+        const audit = auditCiWorkflow({
+            file: abs,
+            provider: providerRaw && VALID.has(providerRaw) ? providerRaw : null,
+        });
+        return { data: audit };
+    },
+};

package/dist/tools/ci-scaffold-preview.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const getCiScaffoldPreviewTool: IToolDefinition;
+//# sourceMappingURL=ci-scaffold-preview.tool.d.ts.map

package/dist/tools/ci-scaffold-preview.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-scaffold-preview.tool.d.ts","sourceRoot":"","sources":["../../src/tools/ci-scaffold-preview.tool.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,eAAO,MAAM,wBAAwB,EAAE,eA2DtC,CAAC"}

package/dist/tools/ci-scaffold-preview.tool.js

@@ -0,0 +1,63 @@
+import { defaultCiOutputPath, renderBitbucketCiWorkflow, renderBundleReplayWorkflow, renderGitlabCiWorkflow, renderQualityCiWorkflow, } from '@shrkcrft/inspector';
+const VALID_PROVIDERS = new Set(['github-actions', 'gitlab', 'bitbucket']);
+export const getCiScaffoldPreviewTool = {
+    name: 'get_ci_scaffold_preview',
+    description: 'Render the CI workflow YAML for the SharkCraft CI scaffold without writing anything. Supports GitHub Actions, GitLab, and Bitbucket. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            target: { type: 'string', enum: ['quality', 'bundle-replay'] },
+            provider: { type: 'string', enum: ['github-actions', 'gitlab', 'bitbucket'] },
+            withQuality: { type: 'boolean' },
+            withPolicy: { type: 'boolean' },
+            withPolicySnapshotGate: { type: 'boolean' },
+            withImpact: { type: 'boolean' },
+            withReview: { type: 'boolean' },
+            withReportSite: { type: 'boolean' },
+            withBundleReplay: { type: 'boolean' },
+            withNodeCompat: { type: 'boolean' },
+            schedule: { type: 'string', enum: ['weekly', 'daily', 'manual'] },
+        },
+        additionalProperties: false,
+    },
+    handler(input) {
+        const target = typeof input['target'] === 'string' ? input['target'] : 'quality';
+        if (target === 'bundle-replay') {
+            const schedule = typeof input['schedule'] === 'string' && ['weekly', 'daily', 'manual'].includes(input['schedule'])
+                ? input['schedule']
+                : 'weekly';
+            const body = renderBundleReplayWorkflow({
+                schedule,
+                ...(input['withReportSite'] ? { withReportSite: true } : {}),
+            });
+            return { data: { target: 'bundle-replay', body } };
+        }
+        const providerRaw = (typeof input['provider'] === 'string' ? input['provider'] : 'github-actions');
+        const provider = VALID_PROVIDERS.has(providerRaw) ? providerRaw : 'github-actions';
+        const opts = {
+            ...(input['withQuality'] ? { withQuality: true } : {}),
+            ...(input['withPolicy'] ? { withPolicy: true } : {}),
+            ...(input['withPolicySnapshotGate'] ? { withPolicySnapshotGate: true } : {}),
+            ...(input['withImpact'] ? { withImpact: true } : {}),
+            ...(input['withReview'] ? { withReview: true } : {}),
+            ...(input['withReportSite'] ? { withReportSite: true } : {}),
+            ...(input['withBundleReplay'] ? { withBundleReplay: true } : {}),
+            ...(input['withNodeCompat'] ? { withNodeCompat: true } : {}),
+        };
+        let body;
+        if (provider === 'gitlab')
+            body = renderGitlabCiWorkflow(opts);
+        else if (provider === 'bitbucket')
+            body = renderBitbucketCiWorkflow(opts);
+        else
+            body = renderQualityCiWorkflow(opts);
+        return {
+            data: {
+                target: 'quality',
+                provider,
+                defaultOutputPath: defaultCiOutputPath(provider),
+                body,
+            },
+        };
+    },
+};

package/dist/tools/command-catalog.tool.d.ts

@@ -0,0 +1,27 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+interface ICatalogEntry {
+    command: string;
+    description: string;
+    category: string;
+    safetyLevel: string;
+    writesFiles: boolean;
+    writesSource: boolean;
+    runsShell: boolean;
+    requiresReview: boolean;
+    mcpAvailable: boolean;
+    aliases: readonly string[];
+    /**
+     * Coarse tier classification. The MCP catalog snapshot lacks
+     * the spine pipelines + project surface config available to the
+     * CLI's tier resolver, so this is a static fallback:
+     *   - `core` for bootstrap commands (doctor, init, recommend, etc.)
+     *   - `extended` for everything else.
+     * Agents querying through MCP that need the precise tier should
+     * call `shrk surface list --json` via the host's shell instead.
+     */
+    tier?: 'core' | 'extended' | 'experimental';
+}
+export declare const COMMAND_CATALOG_EXPORT: readonly ICatalogEntry[];
+export declare const getCommandCatalogTool: IToolDefinition;
+export {};
+//# sourceMappingURL=command-catalog.tool.d.ts.map

package/dist/tools/command-catalog.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-catalog.tool.d.ts","sourceRoot":"","sources":["../../src/tools/command-catalog.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAiBpE,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,cAAc,CAAC;CAC7C;AAwBD,eAAO,MAAM,sBAAsB,EAAE,SAAS,aAAa,EAgFzD,CAAC;AA+BH,eAAO,MAAM,qBAAqB,EAAE,eA4BnC,CAAC"}

package/dist/tools/command-catalog.tool.js

@@ -0,0 +1,147 @@
+const MCP_BOOTSTRAP_CORE = new Set([
+    'doctor',
+    'init',
+    'recommend',
+    'surface',
+    'commands',
+    'start-here',
+    'help',
+    'version',
+    // Spine commands the CLI resolver promotes to core. Mirrored here so
+    // the MCP catalog matches the CLI's --json output for the most
+    // load-bearing entries.
+    'context',
+    'apply',
+    'gen',
+    'plan review',
+    'check boundaries',
+]);
+// Mirror of the CLI catalog. We re-state it here rather than import the CLI
+// to keep the MCP server independent of the CLI build. Tests assert the
+// invariant that both lists contain the same `command` keys.
+export const COMMAND_CATALOG_EXPORT = Object.freeze([
+    entry('doctor', 'Workspace doctor: config + entry validation.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('context', 'Focused context for a task.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('task', 'Full task packet for a task.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('inspect', 'Aggregate inspection of registries + packs.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('coverage', 'Coverage report across knowledge axes.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('drift', 'Stale-entry drift report.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('graph', 'Knowledge graph — nodes, edges, paths, exports.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('check boundaries', 'Boundary enforcement check.', 'core', 'read-only', { mcpAvailable: true }),
+    entry('review', 'PR-review packet.', 'review', 'read-only', { mcpAvailable: true }),
+    entry('review render-comment', 'Render PR-comment markdown (CLI-only writes).', 'review', 'writes-drafts', {
+        writesFiles: true,
+    }),
+    entry('init', 'Create sharkcraft/ scaffold.', 'core', 'writes-source', { writesFiles: true, writesSource: true }),
+    entry('gen', 'Generate from template (CLI write only).', 'core', 'writes-source', {
+        writesFiles: true,
+        writesSource: true,
+        requiresReview: true,
+    }),
+    entry('apply', 'Apply a saved plan — CLI only.', 'core', 'writes-source', {
+        writesFiles: true,
+        writesSource: true,
+        requiresReview: true,
+    }),
+    entry('dev start', 'Start a dev session.', 'dev', 'writes-session', { writesFiles: true }),
+    entry('dev plan', 'Generate session plans.', 'dev', 'writes-session', { writesFiles: true }),
+    entry('dev validate', 'Run validation in a session.', 'dev', 'runs-shell', {
+        runsShell: true,
+        writesFiles: true,
+    }),
+    entry('dev report', 'Audit-trail report.', 'dev', 'writes-session', { writesFiles: true }),
+    entry('dev mark-applied', 'Metadata-only mark applied.', 'dev', 'writes-session', { writesFiles: true }),
+    entry('dev mark-validated', 'Metadata-only mark validated.', 'dev', 'writes-session', { writesFiles: true }),
+    entry('dev diff', 'Diff two dev sessions.', 'dev', 'read-only', {}),
+    entry('dev list', 'List dev sessions.', 'dev', 'read-only', {}),
+    entry('dev archive', 'Archive a session.', 'dev', 'writes-session', { writesFiles: true }),
+    entry('dev clean', 'Clean old sessions (dry-run by default).', 'dev', 'writes-session', {
+        writesFiles: true,
+        requiresReview: true,
+    }),
+    entry('onboard', 'Onboard an existing repo.', 'onboarding', 'read-only', { mcpAvailable: true }),
+    entry('onboard --write-drafts', 'Write onboarding drafts.', 'onboarding', 'writes-drafts', {
+        writesFiles: true,
+        requiresReview: true,
+    }),
+    entry('onboard adopt', 'Adoption classification.', 'onboarding', 'read-only', { mcpAvailable: true }),
+    entry('onboard adopt --write-patch', 'Write adoption pseudo-patch.', 'onboarding', 'writes-drafts', {
+        writesFiles: true,
+        requiresReview: true,
+    }),
+    entry('packs list', 'List packs.', 'packs', 'read-only', { mcpAvailable: true }),
+    entry('packs doctor', 'Validate pack discovery.', 'packs', 'read-only', { mcpAvailable: true }),
+    entry('packs sign', 'Sign pack manifest.', 'packs', 'writes-source', {
+        writesFiles: true,
+        requiresReview: true,
+    }),
+    entry('packs verify', 'Verify pack signatures.', 'packs', 'read-only', {}),
+    entry('packs new', 'Scaffold a new pack (CLI dry-run by default).', 'packs', 'writes-source', {
+        writesFiles: true,
+        requiresReview: true,
+    }),
+    entry('packs test', 'Validate a pack at the given path.', 'packs', 'read-only', {}),
+    entry('quality', 'Quality gate orchestrator.', 'gates', 'runs-shell', {}),
+    entry('ci scaffold github-actions', 'Scaffold GitHub Actions workflow.', 'gates', 'writes-source', {
+        writesFiles: true,
+    }),
+    entry('boundaries list', 'List boundary rules.', 'boundaries', 'read-only', { mcpAvailable: true }),
+    entry('boundaries infer', 'Infer boundary candidates.', 'boundaries', 'read-only', {}),
+    entry('boundaries explain', 'Explain a boundary rule.', 'boundaries', 'read-only', { mcpAvailable: true }),
+    entry('test context', 'Run context retrieval tests.', 'tests', 'read-only', { mcpAvailable: true }),
+    entry('test agent', 'Run agent contract tests.', 'tests', 'read-only', { mcpAvailable: true }),
+    entry('test generate context', 'Generate a context-test draft.', 'tests', 'writes-drafts', {
+        writesFiles: true,
+    }),
+    entry('test generate agent', 'Generate an agent-test draft.', 'tests', 'writes-drafts', {
+        writesFiles: true,
+    }),
+    entry('commands', 'List all CLI commands with safety labels.', 'meta', 'read-only', { mcpAvailable: true }),
+    entry('mcp', 'Start the read-only MCP server.', 'meta', 'read-only', {}),
+    entry('version', 'Print CLI version.', 'meta', 'read-only', {}),
+]);
+function entry(command, description, category, safetyLevel, opts) {
+    return {
+        command,
+        description,
+        category,
+        safetyLevel,
+        writesFiles: opts.writesFiles ?? false,
+        writesSource: opts.writesSource ?? false,
+        runsShell: opts.runsShell ?? false,
+        requiresReview: opts.requiresReview ?? false,
+        mcpAvailable: opts.mcpAvailable ?? false,
+        aliases: opts.aliases ?? [],
+        tier: MCP_BOOTSTRAP_CORE.has(command) ? 'core' : 'extended',
+    };
+}
+export const getCommandCatalogTool = {
+    name: 'get_command_catalog',
+    description: 'List every `shrk` command with its safety level, side effects, and MCP availability. Read-only. Useful when an agent needs to choose a CLI command for the user without scanning the source tree.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            safetyLevel: { type: 'string', description: 'Filter by safety level (read-only, writes-session, writes-drafts, writes-source, runs-shell, requires-review).' },
+            category: { type: 'string', description: 'Filter by category.' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input) {
+        const safety = input.safetyLevel;
+        const category = input.category;
+        let entries = COMMAND_CATALOG_EXPORT;
+        if (typeof safety === 'string')
+            entries = entries.filter((e) => e.safetyLevel === safety);
+        if (typeof category === 'string')
+            entries = entries.filter((e) => e.category === category);
+        return {
+            data: {
+                entries,
+                totals: {
+                    total: COMMAND_CATALOG_EXPORT.length,
+                    returned: entries.length,
+                },
+            },
+        };
+    },
+};

package/dist/tools/construct-adoption-diff.tool.d.ts

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

package/dist/tools/construct-adoption-diff.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-adoption-diff.tool.d.ts","sourceRoot":"","sources":["../../src/tools/construct-adoption-diff.tool.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,eAAO,MAAM,4BAA4B,EAAE,eAwB1C,CAAC"}

package/dist/tools/construct-adoption-diff.tool.js

@@ -0,0 +1,26 @@
+import { buildConstructAdoptionDiff, loadConstructs, renderConstructAdoptionDiff, } from '@shrkcrft/inspector';
+const VALID_FORMATS = new Set(['text', 'markdown', 'html', 'json']);
+export const getConstructAdoptionDiffTool = {
+    name: 'get_construct_adoption_diff',
+    description: 'Render a line-level diff of the proposed construct adoption against the live constructs registry. Read-only; never writes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', enum: ['text', 'markdown', 'html', 'json'] },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        await loadConstructs(ctx.inspection);
+        const formatRaw = typeof input['format'] === 'string' ? input['format'] : 'json';
+        const format = VALID_FORMATS.has(formatRaw) ? formatRaw : 'json';
+        const diff = await buildConstructAdoptionDiff(ctx.inspection);
+        return {
+            data: {
+                diff,
+                rendered: renderConstructAdoptionDiff(diff, format),
+                format,
+            },
+        };
+    },
+};

package/dist/tools/construct-adoption.tool.d.ts

@@ -0,0 +1,4 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const createConstructAdoptionPlanTool: IToolDefinition;
+export declare const getConstructAdoptionReviewTool: IToolDefinition;
+//# sourceMappingURL=construct-adoption.tool.d.ts.map

package/dist/tools/construct-adoption.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-adoption.tool.d.ts","sourceRoot":"","sources":["../../src/tools/construct-adoption.tool.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,+BAA+B,EAAE,eA6B7C,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,eAS5C,CAAC"}

package/dist/tools/construct-adoption.tool.js

@@ -0,0 +1,37 @@
+import { buildConstructAdoptionPlan, loadConstructs, readConstructAdoptionStatus, } from '@shrkcrft/inspector';
+export const createConstructAdoptionPlanTool = {
+    name: 'create_construct_adoption_plan',
+    description: 'Build a construct-adoption plan classifying inferred construct drafts. Read-only; never writes patches.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            minConfidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+            include: { type: 'array', items: { type: 'string' } },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        await loadConstructs(ctx.inspection);
+        const min = typeof input['minConfidence'] === 'string'
+            ? input['minConfidence']
+            : undefined;
+        const include = Array.isArray(input['include'])
+            ? input['include'].filter((x) => ['facets', 'publicApi', 'events', 'tokens'].includes(x))
+            : undefined;
+        const plan = await buildConstructAdoptionPlan(ctx.inspection, {
+            ...(min ? { minConfidence: min } : {}),
+            ...(include ? { include } : {}),
+        });
+        return { data: plan };
+    },
+};
+export const getConstructAdoptionReviewTool = {
+    name: 'get_construct_adoption_review',
+    description: 'Return the current construct-adoption status (paths + summary). Read-only.',
+    inputSchema: { type: 'object', properties: {} },
+    async handler(_input, ctx) {
+        await loadConstructs(ctx.inspection);
+        const status = readConstructAdoptionStatus(ctx.inspection);
+        return { data: status };
+    },
+};

package/dist/tools/construct-inference.tool.d.ts

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

package/dist/tools/construct-inference.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construct-inference.tool.d.ts","sourceRoot":"","sources":["../../src/tools/construct-inference.tool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,0BAA0B,EAAE,eA0BxC,CAAC"}

package/dist/tools/construct-inference.tool.js

@@ -0,0 +1,26 @@
+import { inferConstructs, loadConstructs, } from '@shrkcrft/inspector';
+export const inferConstructsPreviewTool = {
+    name: 'infer_constructs_preview',
+    description: 'Infer construct candidates from files, conventions, and the import graph. Read-only — no drafts are written. Use `shrk constructs infer --write-drafts` to materialise them.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: { type: 'string' },
+            minConfidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+            limit: { type: 'number' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const minConf = typeof input['minConfidence'] === 'string'
+            ? input['minConfidence']
+            : undefined;
+        await loadConstructs(ctx.inspection);
+        const result = await inferConstructs(ctx.inspection, {
+            ...(typeof input['type'] === 'string' ? { type: input['type'] } : {}),
+            ...(minConf ? { minConfidence: minConf } : {}),
+            ...(typeof input['limit'] === 'number' ? { limit: input['limit'] } : {}),
+        });
+        return { data: result };
+    },
+};

package/dist/tools/constructs.tool.d.ts

@@ -0,0 +1,7 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const listConstructsTool: IToolDefinition;
+export declare const getConstructTool: IToolDefinition;
+export declare const traceConstructTool: IToolDefinition;
+export declare const getConstructApiTool: IToolDefinition;
+export declare const listConstructFacetsTool: IToolDefinition;
+//# sourceMappingURL=constructs.tool.d.ts.map

package/dist/tools/constructs.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructs.tool.d.ts","sourceRoot":"","sources":["../../src/tools/constructs.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,kBAAkB,EAAE,eAShC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAe9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAehC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAejC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAerC,CAAC"}

package/dist/tools/constructs.tool.js

@@ -0,0 +1,79 @@
+import { loadConstructs, traceConstruct } from '@shrkcrft/inspector';
+export const listConstructsTool = {
+    name: 'list_constructs',
+    description: 'List registered constructs. Read-only.',
+    inputSchema: { type: 'object', properties: { type: { type: 'string' } } },
+    async handler(input, ctx) {
+        const type = typeof input['type'] === 'string' ? input['type'] : undefined;
+        const list = await loadConstructs(ctx.inspection);
+        return { data: type ? list.filter((c) => c.type === type) : list };
+    },
+};
+export const getConstructTool = {
+    name: 'get_construct',
+    description: 'Show details for a single construct. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const id = String(input['id'] ?? '');
+        const list = await loadConstructs(ctx.inspection);
+        const c = list.find((x) => x.id === id);
+        if (!c)
+            return { error: { code: 'not-found', message: `No construct "${id}"` } };
+        return { data: c };
+    },
+};
+export const traceConstructTool = {
+    name: 'trace_construct',
+    description: 'Trace files / publicApi / events / tokens of a construct. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const id = String(input['id'] ?? '');
+        const list = await loadConstructs(ctx.inspection);
+        const c = list.find((x) => x.id === id);
+        if (!c)
+            return { error: { code: 'not-found', message: `No construct "${id}"` } };
+        return { data: traceConstruct(c) };
+    },
+};
+export const getConstructApiTool = {
+    name: 'get_construct_api',
+    description: 'Return the publicApi entries for a construct. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const id = String(input['id'] ?? '');
+        const list = await loadConstructs(ctx.inspection);
+        const c = list.find((x) => x.id === id);
+        if (!c)
+            return { error: { code: 'not-found', message: `No construct "${id}"` } };
+        return { data: { id, publicApi: c.publicApi ?? [] } };
+    },
+};
+export const listConstructFacetsTool = {
+    name: 'list_construct_facets',
+    description: 'List facets of a construct. Read-only.',
+    inputSchema: {
+        type: 'object',
+        required: ['id'],
+        properties: { id: { type: 'string' } },
+    },
+    async handler(input, ctx) {
+        const id = String(input['id'] ?? '');
+        const list = await loadConstructs(ctx.inspection);
+        const c = list.find((x) => x.id === id);
+        if (!c)
+            return { error: { code: 'not-found', message: `No construct "${id}"` } };
+        return { data: { id, facets: c.facets ?? {} } };
+    },
+};

package/dist/tools/create-generation-plan.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const createGenerationPlanTool: IToolDefinition;
+//# sourceMappingURL=create-generation-plan.tool.d.ts.map

package/dist/tools/create-generation-plan.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-generation-plan.tool.d.ts","sourceRoot":"","sources":["../../src/tools/create-generation-plan.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,wBAAwB,EAAE,eA8CtC,CAAC"}

package/dist/tools/create-generation-plan.tool.js

@@ -0,0 +1,48 @@
+import { generate } from '@shrkcrft/generator';
+export const createGenerationPlanTool = {
+    name: 'create_generation_plan',
+    description: 'Create a generation plan (dry-run). Never writes files. Use to preview a template before applying.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            templateId: { type: 'string' },
+            name: { type: 'string' },
+            variables: { type: 'object', additionalProperties: { type: 'string' } },
+        },
+        required: ['templateId'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const templateId = String(input.templateId);
+        const template = ctx.inspection.templateRegistry.get(templateId);
+        if (!template)
+            return { isError: true, text: `No template with id "${templateId}"` };
+        const variables = input.variables ?? {};
+        const result = generate(template, {
+            templateId,
+            name: typeof input.name === 'string' ? input.name : undefined,
+            variables,
+            projectRoot: ctx.inspection.projectRoot,
+            write: false,
+        });
+        if (!result.ok)
+            return { isError: true, text: result.error.message };
+        const { plan } = result.value;
+        return {
+            data: {
+                templateId: plan.templateId,
+                templateName: plan.templateName,
+                totalFiles: plan.totalFiles,
+                hasConflicts: plan.hasConflicts,
+                warnings: plan.warnings,
+                postGenerationNotes: plan.postGenerationNotes,
+                changes: plan.changes.map((c) => ({
+                    type: c.type,
+                    relativePath: c.relativePath,
+                    sizeBytes: c.sizeBytes,
+                    reason: c.reason,
+                })),
+            },
+        };
+    },
+};

package/dist/tools/create-pipeline-plan.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const createPipelinePlanTool: IToolDefinition;
+//# sourceMappingURL=create-pipeline-plan.tool.d.ts.map

package/dist/tools/create-pipeline-plan.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-pipeline-plan.tool.d.ts","sourceRoot":"","sources":["../../src/tools/create-pipeline-plan.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,sBAAsB,EAAE,eAwCpC,CAAC"}

package/dist/tools/create-pipeline-plan.tool.js

@@ -0,0 +1,41 @@
+import { interpolatePipeline, renderPipelineScript } from '@shrkcrft/pipelines';
+export const createPipelinePlanTool = {
+    name: 'create_pipeline_plan',
+    description: 'Resolve a pipeline against a task + named inputs and return the interpolated step list. Optionally include a copy-pasteable shell script (apply/write steps include a manual-confirm prompt). Never executes anything.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string' },
+            task: { type: 'string' },
+            inputs: { type: 'object', additionalProperties: { type: 'string' } },
+            includeOptional: { type: 'array', items: { type: 'string' } },
+            includeScript: { type: 'boolean' },
+        },
+        required: ['id', 'task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const id = String(input.id ?? '');
+        const pipeline = ctx.inspection.pipelineRegistry.get(id);
+        if (!pipeline)
+            return { isError: true, text: `No pipeline with id "${id}".` };
+        const interp = interpolatePipeline(pipeline, {
+            task: String(input.task),
+            projectRoot: ctx.inspection.projectRoot,
+            inputs: input.inputs ?? {},
+            includeOptional: input.includeOptional ?? [],
+        });
+        const data = {
+            pipelineId: pipeline.id,
+            title: pipeline.title,
+            description: pipeline.description,
+            task: interp.task,
+            inputs: interp.inputs,
+            steps: interp.steps,
+        };
+        if (input.includeScript === true) {
+            data.script = renderPipelineScript(interp);
+        }
+        return { data };
+    },
+};