@shrkcrft/mcp-server 0.1.0-alpha.2

package/dist/tools/list-knowledge.tool.js

@@ -0,0 +1,46 @@
+export const listKnowledgeTool = {
+    name: 'list_knowledge',
+    description: 'Lists available knowledge entries (id, title, type, tags, scope, priority, appliesWhen). Filterable.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: { type: 'string', description: 'Filter by knowledge type.' },
+            types: { type: 'array', items: { type: 'string' } },
+            scope: { type: 'array', items: { type: 'string' } },
+            tags: { type: 'array', items: { type: 'string' } },
+            appliesWhen: { type: 'array', items: { type: 'string' } },
+            limit: { type: 'integer', minimum: 1 },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const types = (Array.isArray(input.types) ? input.types : []).concat(typeof input.type === 'string' ? [input.type] : []);
+        const scope = input.scope ?? [];
+        const tags = input.tags ?? [];
+        const appliesWhen = input.appliesWhen ?? [];
+        const limit = typeof input.limit === 'number' ? input.limit : 200;
+        let entries = ctx.inspection.knowledgeEntries.slice();
+        if (types.length)
+            entries = entries.filter((e) => types.includes(String(e.type)));
+        if (scope.length)
+            entries = entries.filter((e) => scope.some((s) => e.scope.includes(s)));
+        if (tags.length)
+            entries = entries.filter((e) => tags.every((t) => e.tags.includes(t)));
+        if (appliesWhen.length) {
+            entries = entries.filter((e) => appliesWhen.some((a) => e.appliesWhen.includes(a)));
+        }
+        entries = entries.slice(0, limit);
+        return {
+            data: entries.map((e) => ({
+                id: e.id,
+                title: e.title,
+                type: e.type,
+                priority: e.priority,
+                scope: e.scope,
+                tags: e.tags,
+                appliesWhen: e.appliesWhen,
+                summary: e.summary,
+            })),
+        };
+    },
+};

package/dist/tools/list-packs.tool.d.ts

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

package/dist/tools/list-packs.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-packs.tool.d.ts","sourceRoot":"","sources":["../../src/tools/list-packs.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,aAAa,EAAE,eAmB3B,CAAC"}

package/dist/tools/list-packs.tool.js

@@ -0,0 +1,19 @@
+export const listPacksTool = {
+    name: 'list_packs',
+    description: 'List discovered SharkCraft packs (third-party npm packages that ship knowledge / templates / pipelines). Each entry includes both declared file counts and resolved object counts after dedup.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        return {
+            data: ctx.inspection.packs.discoveredPacks.map((p) => ({
+                packageName: p.packageName,
+                packageVersion: p.packageVersion,
+                valid: p.valid,
+                contributionCounts: p.contributionCounts,
+                resolvedCounts: p.resolvedCounts,
+                signatureStatus: p.signatureStatus,
+                signatureMessage: p.signatureMessage,
+                loadError: p.loadError,
+            })),
+        };
+    },
+};

package/dist/tools/list-path-conventions.tool.d.ts

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

package/dist/tools/list-path-conventions.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-path-conventions.tool.d.ts","sourceRoot":"","sources":["../../src/tools/list-path-conventions.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,uBAAuB,EAAE,eAmBrC,CAAC"}

package/dist/tools/list-path-conventions.tool.js

@@ -0,0 +1,20 @@
+export const listPathConventionsTool = {
+    name: 'list_path_conventions',
+    description: 'List known path conventions.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const paths = ctx.inspection.pathService.list();
+        return {
+            data: paths.map((p) => ({
+                id: p.id,
+                title: p.title,
+                path: p.metadata?.path ?? '',
+                priority: p.priority,
+                tags: p.tags,
+                scope: p.scope,
+                appliesWhen: p.appliesWhen,
+                description: p.metadata?.description ?? p.summary,
+            })),
+        };
+    },
+};

package/dist/tools/list-pipelines.tool.d.ts

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

package/dist/tools/list-pipelines.tool.d.ts.map

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

package/dist/tools/list-pipelines.tool.js

@@ -0,0 +1,19 @@
+export const listPipelinesTool = {
+    name: 'list_pipelines',
+    description: 'List available SharkCraft AI development pipelines (declarative agent workflows).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const list = ctx.inspection.pipelineRegistry.list();
+        return {
+            data: list.map((p) => ({
+                id: p.id,
+                title: p.title,
+                description: p.description,
+                tags: p.tags ?? [],
+                scope: p.scope ?? [],
+                appliesWhen: p.appliesWhen ?? [],
+                stepCount: p.steps.length,
+            })),
+        };
+    },
+};

package/dist/tools/list-presets.tool.d.ts

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

package/dist/tools/list-presets.tool.d.ts.map

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

package/dist/tools/list-presets.tool.js

@@ -0,0 +1,26 @@
+export const listPresetsTool = {
+    name: 'list_presets',
+    description: 'List all SharkCraft presets (built-in + pack-contributed). A preset is a reusable project setup (knowledge / rules / paths / templates / pipelines / docs) that can be applied via the CLI.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const presets = ctx.inspection.presetRegistry.list();
+        return {
+            data: presets.map((p) => ({
+                id: p.id,
+                title: p.title,
+                description: p.description,
+                tags: p.tags ?? [],
+                appliesTo: p.appliesTo ?? [],
+                weight: p.weight ?? 5,
+                source: ctx.inspection.presetSources.get(p.id) ?? null,
+                counts: {
+                    knowledge: p.includes.knowledge?.length ?? 0,
+                    rules: p.includes.rules?.length ?? 0,
+                    paths: p.includes.paths?.length ?? 0,
+                    templates: p.includes.templates?.length ?? 0,
+                    pipelines: p.includes.pipelines?.length ?? 0,
+                },
+            })),
+        };
+    },
+};

package/dist/tools/list-rules.tool.d.ts

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

package/dist/tools/list-rules.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-rules.tool.d.ts","sourceRoot":"","sources":["../../src/tools/list-rules.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,aAAa,EAAE,eAkB3B,CAAC"}

package/dist/tools/list-rules.tool.js

@@ -0,0 +1,19 @@
+export const listRulesTool = {
+    name: 'list_rules',
+    description: 'List all rules with compact metadata.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const rules = ctx.inspection.ruleService.list();
+        return {
+            data: rules.map((r) => ({
+                id: r.id,
+                title: r.title,
+                priority: r.priority,
+                tags: r.tags,
+                scope: r.scope,
+                appliesWhen: r.appliesWhen,
+                summary: r.summary,
+            })),
+        };
+    },
+};

package/dist/tools/list-templates.tool.d.ts

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

package/dist/tools/list-templates.tool.d.ts.map

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

package/dist/tools/list-templates.tool.js

@@ -0,0 +1,19 @@
+export const listTemplatesTool = {
+    name: 'list_templates',
+    description: 'List available generator templates.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const templates = ctx.inspection.templateRegistry.list();
+        return {
+            data: templates.map((t) => ({
+                id: t.id,
+                name: t.name,
+                description: t.description,
+                tags: t.tags,
+                scope: t.scope,
+                appliesWhen: t.appliesWhen,
+                variableCount: t.variables.length,
+            })),
+        };
+    },
+};

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { buildOnboardAdoptionDiff, renderOnboardAdoptionDiff, } from '@shrkcrft/inspector';
+const VALID_FORMATS = new Set(['text', 'markdown', 'html', 'json']);
+export const getOnboardAdoptionDiffTool = {
+    name: 'get_onboard_adoption_diff',
+    description: 'Render a line-level diff of the proposed onboard adoption against the live sharkcraft/*.ts files. Read-only; never writes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', enum: ['text', 'markdown', 'html', 'json'] },
+            confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+        },
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const formatRaw = typeof input['format'] === 'string' ? input['format'] : 'json';
+        const format = VALID_FORMATS.has(formatRaw) ? formatRaw : 'json';
+        const confidence = typeof input['confidence'] === 'string' ? input['confidence'] : undefined;
+        const diff = buildOnboardAdoptionDiff(ctx.inspection, {
+            ...(confidence ? { confidence } : {}),
+        });
+        return {
+            data: {
+                diff,
+                rendered: renderOnboardAdoptionDiff(diff, format),
+                format,
+            },
+        };
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const createOnboardingPlanTool: IToolDefinition;
+export declare const getOnboardingReportPreviewTool: IToolDefinition;
+export declare const createOnboardingAdoptionPlanTool: IToolDefinition;
+export declare const getOnboardingAdoptionReviewTool: IToolDefinition;
+export declare const listInferredAssetsTool: IToolDefinition;
+//# sourceMappingURL=onboarding.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.tool.d.ts","sourceRoot":"","sources":["../../src/tools/onboarding.tool.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE,eAAO,MAAM,wBAAwB,EAAE,eA6EtC,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,eAwB5C,CAAC;AAsBF,eAAO,MAAM,gCAAgC,EAAE,eAyD9C,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,eAgC7C,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAmDpC,CAAC"}

package/dist/tools/onboarding.tool.js

@@ -0,0 +1,253 @@
+import { AdoptionCategory, AdoptionKind, buildOnboardingAdoptionPlan, buildOnboardingDiff, buildOnboardingPlan, importAgentRulesForOnboarding, renderOnboardingReport, } from '@shrkcrft/inspector';
+const NEXT_COMMAND = 'shrk onboard --write-drafts';
+const NEXT_COMMANDS_FULL = [
+    'shrk onboard --write-drafts',
+    'shrk onboard --write-drafts --scaffold-templates',
+    'shrk onboard --write-drafts --import-agents',
+    'shrk onboard --diff',
+];
+export const createOnboardingPlanTool = {
+    name: 'create_onboarding_plan',
+    description: 'Build an onboarding plan for the current repository. Read-only: returns the structured plan (profiles, presets, inferred rules/paths/templates/boundaries/pipelines, readiness estimate). Options enable additional read-only analyses (template scaffolding preview, agent rule import preview, diff against live config). Does NOT write any files — use the CLI to materialize drafts.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            preferredPreset: {
+                type: 'string',
+                description: 'Pin this preset id to the top of the recommendation list. The plan still includes the full ranked list.',
+            },
+            scaffoldTemplates: {
+                type: 'boolean',
+                description: 'When true, attempt to produce runnable scaffolded bodies for high/medium-confidence template candidates. Still read-only — the user must run the CLI to write drafts.',
+            },
+            importAgents: {
+                type: 'boolean',
+                description: 'When true, also parse AGENTS.md / CLAUDE.md / .cursor/rules into an imported-agent-rules bundle.',
+            },
+            includeDiff: {
+                type: 'boolean',
+                description: 'When true, also compute a diff vs. the live SharkCraft config (rules / paths / templates / pipelines / boundaries / verification commands).',
+            },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const obj = input;
+        const preferredPreset = obj.preferredPreset;
+        const scaffoldTemplates = obj.scaffoldTemplates === true;
+        const importAgents = obj.importAgents === true;
+        const includeDiff = obj.includeDiff === true;
+        const plan = buildOnboardingPlan(ctx.inspection, {
+            ...(typeof preferredPreset === 'string' ? { preferredPreset } : {}),
+            ...(scaffoldTemplates ? { scaffoldTemplates: true } : {}),
+        });
+        const importedAgentRules = importAgents
+            ? importAgentRulesForOnboarding({ projectRoot: ctx.inspection.projectRoot })
+            : undefined;
+        const diff = includeDiff
+            ? buildOnboardingDiff(ctx.inspection, plan)
+            : undefined;
+        return {
+            data: {
+                plan,
+                reportPreview: renderOnboardingReport(plan),
+                inferredAssetsSummary: {
+                    rules: plan.inferredRules.length,
+                    paths: plan.inferredPathConventions.length,
+                    templates: plan.inferredTemplateCandidates.length,
+                    templatesScaffolded: plan.inferredTemplateCandidates.filter((t) => t.scaffold).length,
+                    pipelines: plan.inferredPipelines.length,
+                    boundaries: plan.inferredBoundaryRules.length,
+                    verificationCommands: plan.inferredVerificationCommands.length,
+                },
+                ...(importedAgentRules ? { importedAgentRules } : {}),
+                ...(diff ? { diff } : {}),
+                nextCommand: NEXT_COMMAND,
+                nextCommands: NEXT_COMMANDS_FULL,
+                note: 'MCP cannot write drafts. Run the CLI commands to materialize them under sharkcraft/onboarding/.',
+            },
+        };
+    },
+};
+export const getOnboardingReportPreviewTool = {
+    name: 'get_onboarding_report_preview',
+    description: 'Render the onboarding plan as a Markdown report (same content `shrk onboard --write-drafts` would write to sharkcraft/onboarding/onboarding-report.md). Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            preferredPreset: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const preferredPreset = input
+            .preferredPreset;
+        const plan = buildOnboardingPlan(ctx.inspection, {
+            ...(typeof preferredPreset === 'string' ? { preferredPreset } : {}),
+        });
+        return {
+            data: {
+                markdown: renderOnboardingReport(plan),
+                nextCommand: NEXT_COMMAND,
+            },
+        };
+    },
+};
+const KIND_MAP = {
+    rules: AdoptionKind.Rule,
+    paths: AdoptionKind.Path,
+    verifications: AdoptionKind.Verification,
+    templates: AdoptionKind.Template,
+    boundaries: AdoptionKind.Boundary,
+    pipelines: AdoptionKind.Pipeline,
+};
+function parseKinds(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = new Set();
+    for (const v of value) {
+        if (typeof v !== 'string')
+            continue;
+        const k = KIND_MAP[v.toLowerCase()];
+        if (k)
+            out.add(k);
+    }
+    return [...out];
+}
+export const createOnboardingAdoptionPlanTool = {
+    name: 'create_onboarding_adoption_plan',
+    description: 'Build an adoption plan classifying inferred items into safe-to-adopt / manual-review / low-confidence / conflict / already-covered / skipped buckets. READ-ONLY: this MCP tool never writes patches. Use `shrk onboard adopt --write-patch` on the CLI to materialize them.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            confidence: {
+                type: 'string',
+                enum: ['high', 'medium', 'low'],
+                description: 'Confidence threshold. Default high.',
+            },
+            include: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Kinds to include (rules,paths,verifications,templates,boundaries,pipelines).',
+            },
+            exclude: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Kinds to exclude.',
+            },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const obj = input;
+        const confidence = obj.confidence === 'medium' || obj.confidence === 'low' ? obj.confidence : 'high';
+        const include = parseKinds(obj.include);
+        const exclude = parseKinds(obj.exclude);
+        const plan = buildOnboardingPlan(ctx.inspection, {});
+        const adoption = buildOnboardingAdoptionPlan({
+            inspection: ctx.inspection,
+            plan,
+            confidence,
+            ...(include.length > 0 ? { include } : {}),
+            ...(exclude.length > 0 ? { exclude } : {}),
+        });
+        return {
+            data: {
+                confidence: adoption.confidence,
+                included: adoption.included,
+                excluded: adoption.excluded,
+                summary: adoption.summary,
+                items: adoption.items,
+                categories: Object.values(AdoptionCategory),
+                suggestedAdditions: adoption.byCategory[AdoptionCategory.SafeToAdopt],
+                skipped: adoption.byCategory[AdoptionCategory.Skipped],
+                conflicts: adoption.byCategory[AdoptionCategory.Conflict],
+                manualReview: adoption.byCategory[AdoptionCategory.ManualReview],
+                nextCommand: 'shrk onboard adopt --write-patch',
+                note: 'MCP cannot write the adoption patch. Run the CLI command above to materialize sharkcraft/onboarding/adoption/.',
+            },
+        };
+    },
+};
+export const getOnboardingAdoptionReviewTool = {
+    name: 'get_onboarding_adoption_review',
+    description: 'Return the categorised review of the inferred adoption plan, grouped by category (safe-to-adopt, manual-review, low-confidence, conflict, already-covered, skipped). READ-ONLY.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            confidence: { type: 'string', enum: ['high', 'medium', 'low'] },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const confidence = input.confidence === 'medium' ||
+            input.confidence === 'low'
+            ? input.confidence
+            : 'high';
+        const plan = buildOnboardingPlan(ctx.inspection, {});
+        const adoption = buildOnboardingAdoptionPlan({
+            inspection: ctx.inspection,
+            plan,
+            confidence,
+        });
+        return {
+            data: {
+                confidence: adoption.confidence,
+                byCategory: adoption.byCategory,
+                summary: adoption.summary,
+                nextCommand: 'shrk onboard adopt --write-patch',
+            },
+        };
+    },
+};
+export const listInferredAssetsTool = {
+    name: 'list_inferred_assets',
+    description: 'List the asset ids the inference engine would propose for this repository: rules, path conventions, boundary rules, template candidates, pipelines, verification commands. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            preferredPreset: { type: 'string' },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const preferredPreset = input
+            .preferredPreset;
+        const plan = buildOnboardingPlan(ctx.inspection, {
+            ...(typeof preferredPreset === 'string' ? { preferredPreset } : {}),
+        });
+        return {
+            data: {
+                rules: plan.inferredRules.map((r) => ({
+                    id: r.id,
+                    title: r.title,
+                    priority: r.priority,
+                    source: r.source,
+                })),
+                paths: plan.inferredPathConventions.map((p) => ({
+                    id: p.id,
+                    title: p.title,
+                })),
+                boundaries: plan.inferredBoundaryRules.map((b) => ({
+                    id: b.id,
+                    title: b.title,
+                    severity: b.severity,
+                })),
+                templates: plan.inferredTemplateCandidates.map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    confidence: t.confidence,
+                })),
+                pipelines: plan.inferredPipelines.map((p) => ({
+                    id: p.id,
+                    title: p.title,
+                })),
+                verificationCommands: plan.inferredVerificationCommands.map((v) => ({
+                    id: v.id,
+                    command: v.command,
+                })),
+                nextCommand: NEXT_COMMAND,
+            },
+        };
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestration.tool.d.ts","sourceRoot":"","sources":["../../src/tools/orchestration.tool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gCAAgC,EAAE,eAyB9C,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAgClC,CAAC"}

package/dist/tools/orchestration.tool.js

@@ -0,0 +1,57 @@
+import { buildAgentOrchestrationPlan, OrchestrationMode, simulateWorkflow, } from '@shrkcrft/inspector';
+export const createAgentOrchestrationPlanTool = {
+    name: 'create_agent_orchestration_plan',
+    description: 'Produce a read-only agent orchestration plan (discovery / plan / review / apply / validate). No execution; no writes.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            mode: { type: 'string' },
+        },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        const modeRaw = typeof input['mode'] === 'string' ? input['mode'].toLowerCase() : '';
+        const mode = modeRaw === 'conservative'
+            ? OrchestrationMode.Conservative
+            : modeRaw === 'aggressive'
+                ? OrchestrationMode.Aggressive
+                : OrchestrationMode.Balanced;
+        const plan = await buildAgentOrchestrationPlan(task, ctx.inspection, { mode });
+        return { data: plan };
+    },
+};
+export const simulateWorkflowTool = {
+    name: 'simulate_workflow',
+    description: 'Predict what a workflow would do without executing anything. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            playbookId: { type: 'string' },
+            pipelineId: { type: 'string' },
+            mode: { type: 'string' },
+        },
+        required: ['task'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const task = typeof input['task'] === 'string' ? input['task'] : '';
+        const playbookId = typeof input['playbookId'] === 'string' ? input['playbookId'] : undefined;
+        const pipelineId = typeof input['pipelineId'] === 'string' ? input['pipelineId'] : undefined;
+        const modeRaw = typeof input['mode'] === 'string' ? input['mode'].toLowerCase() : '';
+        const mode = modeRaw === 'conservative'
+            ? OrchestrationMode.Conservative
+            : modeRaw === 'aggressive'
+                ? OrchestrationMode.Aggressive
+                : OrchestrationMode.Balanced;
+        const sim = await simulateWorkflow(task, ctx.inspection, {
+            ...(playbookId ? { playbookId } : {}),
+            ...(pipelineId ? { pipelineId } : {}),
+            mode,
+        });
+        return { data: sim };
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.tool.d.ts","sourceRoot":"","sources":["../../src/tools/ownership.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,eAS9B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAmB7B,CAAC"}

package/dist/tools/ownership.tool.js

@@ -0,0 +1,31 @@
+import { impactFor, loadOwnershipRules, matchFile } from '@shrkcrft/inspector';
+export const getOwnershipTool = {
+    name: 'get_ownership',
+    description: 'List loaded ownership rules. Read-only.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async handler(_input, ctx) {
+        const cfg = ctx.inspection.config?.ownershipFiles;
+        const r = await loadOwnershipRules(ctx.cwd, cfg);
+        return { data: r };
+    },
+};
+export const matchOwnersTool = {
+    name: 'match_owners',
+    description: 'Match files against ownership rules. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            files: { type: 'array', items: { type: 'string' } },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const files = Array.isArray(input['files']) ? input['files'] : [];
+        const cfg = ctx.inspection.config?.ownershipFiles;
+        const { rules } = await loadOwnershipRules(ctx.cwd, cfg);
+        if (files.length === 1) {
+            return { data: matchFile(files[0], rules) };
+        }
+        return { data: impactFor(files, rules) };
+    },
+};

package/dist/tools/pack-compat.tool.d.ts

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

package/dist/tools/pack-compat.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-compat.tool.d.ts","sourceRoot":"","sources":["../../src/tools/pack-compat.tool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,uBAAuB,EAAE,eAyBrC,CAAC"}