@mcptoolshop/toolshopstudio 1.4.0-toolshop → 1.5.0-toolshop

package/.github/workflows/ci.yml

@@ -23,7 +23,7 @@ concurrency:
 
 jobs:
   test:
-    name: Typecheck + Test + Smoke (FFmpeg + Pandoc + FreeCAD + GDAL + OpenSCAD)
+    name: Typecheck + Test + Registry + Smoke
     runs-on: ubuntu-latest
 
     strategy:
@@ -43,11 +43,16 @@ jobs:
       - name: Typecheck
         run: npm run typecheck
 
-      - name: Unit tests (FFmpeg + Pandoc + FreeCAD + GDAL + OpenSCAD)
+      - name: Unit tests (237 — 5 tools + registry)
         run: npm test
 
       - name: Build
         run: npm run build
 
-      - name: Smoke test (all five tools)
+      - name: Registry validation + docs generation
+        run: |
+          npm run toolshop registry json
+          npm run docs:generate
+
+      - name: Smoke test (5 tools + registry, 13 tests)
         run: npm run smoke

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.5.0-toolshop] - 2026-02-19
+
+### Added
+- **Live Registry**: self-documenting, validated, MCP-ready registry as first-class citizen
+- Registry Phase 1: type-safe `ToolDefinition` schema, `TOOL_REGISTRY` with all 5 tools, 11 `SHARED_PATTERNS`, search/introspection functions
+- Registry Phase 2: `validateRegistry()` engine with Zod refinements (preset existence, fallback integrity, shared pattern coverage), enriched search (`searchAllByPreset`, `searchByOutputExt`, `getPremiumPresetMap`, `getToolsByPattern`), consistency checks
+- Registry Phase 3: `loadRegistry()` validated singleton, MCP introspection tools (`listTools`, `getToolInfo`, `searchPresets`), CLI (`toolshop registry list|show|summary|json|docs`), auto-docs generator (pure markdown)
+- Registry Phase 4: MCP resources (`getRegistryResource`, `getToolResource`), `generateAllToolDocs()` build step, unified `allRegistryMcpTools` table (5 MCP tools), `json` and `docs` CLI subcommands
+- 7 auto-generated markdown docs committed (5 per-tool + registry.md + presets.md)
+- `npm run docs:generate` script for regenerating docs
+- `npm run toolshop registry` CLI with 5 subcommands
+- CI now validates registry JSON + generates docs on every push
+- 48 new registry tests (8 golden + 15 engine + 16 runtime + 9 integration)
+- Smoke test 13: registry validation + listTools + getRegistryResource
+
+### Changed
+- Total test count: 189 → 237 (48 registry tests)
+- Smoke tests: 12 → 13 (registry smoke block)
+- README updated with registry table, CLI docs, generated docs section, architecture bullet
+- Dockerfile relabeled for v1.5.0-toolshop with registry description
+- CI job name reflects registry presence
+- package.json description highlights live Registry
+
+---
+
 ## [1.4.0-toolshop] - 2026-02-19
 
 ### Added

package/Dockerfile

@@ -46,9 +46,9 @@ ENV NODE_ENV=production
 
 VOLUME ["/sandbox", "/tmp/toolshop"]
 
-LABEL org.opencontainers.image.title="ToolShopStudio" \
-      org.opencontainers.image.description="FFmpeg YouTube + Pandoc + FreeCAD + GDAL + OpenSCAD MCP tools — quint-tool kit for ordinary creators" \
-      org.opencontainers.image.version="1.4.0-toolshop" \
+LABEL org.opencontainers.image.title="ToolShopStudio v1.5.0-toolshop" \
+      org.opencontainers.image.description="Five MCP tools + live Registry (FFmpeg, Pandoc, FreeCAD, GDAL, OpenSCAD)" \
+      org.opencontainers.image.version="1.5.0-toolshop" \
       org.opencontainers.image.logo="assets/logo.png" \
       org.opencontainers.image.source="https://github.com/mcp-tool-shop-org/ToolShopStudio" \
       org.opencontainers.image.licenses="MIT"

package/README.md

@@ -5,7 +5,7 @@
 <h1 align="center">ToolShopStudio</h1>
 
 <p align="center">
-  One install. Five production-grade MCP tools for ordinary creators.
+  Five MCP tools + live Registry — one install for ordinary creators.
 </p>
 
 <p align="center">
@@ -23,7 +23,7 @@
   <a href="https://github.com/mcp-tool-shop-org/ToolShopStudio/actions"><img src="https://github.com/mcp-tool-shop-org/ToolShopStudio/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <a href="https://www.npmjs.com/package/@mcptoolshop/toolshopstudio"><img src="https://img.shields.io/npm/v/@mcptoolshop/toolshopstudio" alt="npm version"></a>
   <img src="https://img.shields.io/badge/tools-FFmpeg%20%2B%20Pandoc%20%2B%20FreeCAD%20%2B%20GDAL%20%2B%20OpenSCAD-orange" alt="Tools">
-  <img src="https://img.shields.io/badge/tests-189%20passing-brightgreen" alt="Tests">
+  <img src="https://img.shields.io/badge/tests-237%20passing-brightgreen" alt="Tests">
   <img src="https://img.shields.io/badge/license-MIT-blue" alt="License">
 </p>
 
@@ -38,9 +38,31 @@
 | **FreeCAD MCP** | Safe 3D CAD export: STL, STEP, GLB, 3MF, OBJ — headless, no user code |
 | **GDAL MCP** | Geospatial transforms: reproject rasters, convert vectors, clip regions — the FFmpeg of GIS |
 | **OpenSCAD MCP** | Pure-text parametric CAD: STL, OBJ, 3MF, PNG preview, DXF — text in, mesh out |
+| **Registry** | Self-documenting, MCP-ready — 5 tools, 27 presets, 15 output formats, auto-generated docs |
 
 All five tools share the same frozen surface: **schema-first, sandboxed, observable, context DI, zero raw args**.
 
+ToolShopStudio now includes a **self-documenting registry** — ask it anything about any tool, preset, or pattern.
+
+```typescript
+import { registry } from "@mcptoolshop/toolshopstudio";
+
+registry.findTool("openscad");           // full ToolDefinition
+registry.searchByPreset("academic-pdf"); // → { toolId: "pandoc", ... }
+registry.searchByOutputFormat("STL");    // → FreeCAD + OpenSCAD presets
+registry.getAllPremiumPresets();          // → 8 premium→guaranteed fallback chains
+```
+
+ToolShopStudio now ships with a **live registry** — run `npm run toolshop registry list` or call `listTools()` from any MCP client.
+
+```bash
+npm run toolshop registry list         # table of all tools + preset counts
+npm run toolshop registry show ffmpeg  # full details for one tool
+npm run toolshop registry summary      # 5 tools, 27 presets, 15 formats
+npm run toolshop registry json         # registry summary as JSON
+npm run toolshop registry docs         # generate markdown docs to docs/
+```
+
 ## Quick Start
 
 ```bash
@@ -156,6 +178,23 @@ const model = await openscad.renderModel(
 - **Safe execution**: FreeCAD uses pre-baked Python one-liners (no exec/eval/user code)
 - **Multi-binary**: GDAL dispatches to gdalwarp, ogr2ogr, or gdal_translate per preset
 - **Text-first CAD**: OpenSCAD renders pure `.scad` text to mesh/image (no binary input)
+- **Live Registry**: Validated singleton, MCP introspection tools, CLI, auto-generated docs
+
+## Generated Docs
+
+The registry auto-generates markdown docs for every tool, all presets, and the full registry overview:
+
+| Document | Contents |
+|----------|----------|
+| [`docs/registry.md`](docs/registry.md) | Full registry overview — all 5 tools, presets, patterns |
+| [`docs/presets.md`](docs/presets.md) | Preset cross-reference — which presets exist on which tools |
+| [`docs/tools/ffmpeg.md`](docs/tools/ffmpeg.md) | FFmpeg YouTube MCP — 7 presets, 14 patterns |
+| [`docs/tools/pandoc.md`](docs/tools/pandoc.md) | Pandoc MCP — 5 presets, 11 patterns |
+| [`docs/tools/freecad.md`](docs/tools/freecad.md) | FreeCAD MCP — 5 presets, 13 patterns |
+| [`docs/tools/gdal.md`](docs/tools/gdal.md) | GDAL MCP — 5 presets, 14 patterns |
+| [`docs/tools/openscad.md`](docs/tools/openscad.md) | OpenSCAD MCP — 5 presets, 15 patterns |
+
+Regenerate at any time: `npm run docs:generate`
 
 ## Docker
 
@@ -171,9 +210,10 @@ All five runtime binaries (`ffmpeg`, `pandoc`, `freecad-cmd`, `gdal-bin`, `opens
 ```bash
 npm install          # dependencies
 npm run typecheck    # tsc --noEmit
-npm test             # vitest (189 tests)
+npm test             # vitest (237 tests)
 npm run build        # compile to dist/
-npm run smoke        # end-to-end smoke (all five tools, 12 tests)
+npm run smoke        # end-to-end smoke (all five tools + registry, 13 tests)
+npm run docs:generate # generate registry docs to docs/
 ```
 
 ## License

package/bin/toolshop.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "../dist/registry/cli.js";
+main();

package/dist/index.d.ts

@@ -13,3 +13,4 @@ export * as pandoc from "./pandoc/index.js";
 export * as freecad from "./freecad/index.js";
 export * as gdal from "./gdal/index.js";
 export * as openscad from "./openscad/index.js";
+export * as registry from "./registry/index.js";

package/dist/index.js

@@ -13,3 +13,4 @@ export * as pandoc from "./pandoc/index.js";
 export * as freecad from "./freecad/index.js";
 export * as gdal from "./gdal/index.js";
 export * as openscad from "./openscad/index.js";
+export * as registry from "./registry/index.js";

package/dist/registry/auto-docs.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generate a markdown document for a single tool.
+ * Returns empty string if tool is not found.
+ *
+ * Output includes: name, description, preset table, patterns, example.
+ * Pure function — no I/O, no file writes.
+ */
+export declare function generateToolMarkdown(toolId: string): string;
+/**
+ * Generate a combined markdown document for all tools.
+ * Useful for full registry documentation.
+ */
+export declare function generateRegistryMarkdown(): string;
+/**
+ * Generate a preset cross-reference table across all tools.
+ * Shows which presets are shared (e.g. stl-print-ready in FreeCAD + OpenSCAD).
+ */
+export declare function generatePresetCrossRef(): string;
+/**
+ * Generate all tool docs and write them to disk.
+ *
+ * Creates:
+ *   - `<outDir>/tools/<toolId>.md` for each tool
+ *   - `<outDir>/registry.md` — combined registry doc
+ *   - `<outDir>/presets.md` — preset cross-reference
+ *
+ * @param outDir Target directory (default: "docs")
+ * @returns Array of file paths written
+ */
+export declare function generateAllToolDocs(outDir?: string): string[];

package/dist/registry/auto-docs.js

@@ -0,0 +1,130 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { loadRegistry } from "./runtime.js";
+// ── Auto-docs — pure markdown generation from registry data ──────
+/**
+ * Generate a markdown document for a single tool.
+ * Returns empty string if tool is not found.
+ *
+ * Output includes: name, description, preset table, patterns, example.
+ * Pure function — no I/O, no file writes.
+ */
+export function generateToolMarkdown(toolId) {
+    const reg = loadRegistry();
+    const tool = reg.get(toolId);
+    if (!tool)
+        return "";
+    const lines = [
+        `# ${tool.name}`,
+        "",
+        `> ${tool.description}`,
+        "",
+        `**Version:** ${tool.version}  `,
+        `**Pipeline:** \`${tool.pipelineFn}\``,
+        "",
+        "## Presets",
+        "",
+        "| Preset | Format | Extension | Tier | Fallback |",
+        "|--------|--------|-----------|------|----------|",
+    ];
+    for (const [name, info] of Object.entries(tool.presets)) {
+        const tier = info.isPremium ? "Premium" : "Guaranteed";
+        const fallback = info.fallbackTo ?? "—";
+        lines.push(`| \`${name}\` | ${info.outputFormat} | \`.${info.outputExt}\` | ${tier} | ${fallback} |`);
+    }
+    lines.push("", "## Architectural Patterns", "");
+    for (const p of tool.commonPatterns) {
+        lines.push(`- ${p}`);
+    }
+    if (tool.examples.length > 0) {
+        lines.push("", "## Example", "");
+        const ex = tool.examples[0];
+        lines.push(`**${ex.description}**`, "", "```typescript", ex.code, "```");
+    }
+    return lines.join("\n");
+}
+/**
+ * Generate a combined markdown document for all tools.
+ * Useful for full registry documentation.
+ */
+export function generateRegistryMarkdown() {
+    const reg = loadRegistry();
+    const s = reg.summary;
+    const header = [
+        "# ToolShopStudio Registry",
+        "",
+        `> ${s.toolCount} tools, ${s.totalPresets} presets (${s.guaranteedPresets} guaranteed, ${s.premiumPresets} premium)`,
+        "",
+        `**Version:** ${s.version}  `,
+        `**Output Formats:** ${s.uniqueOutputFormats.join(", ")}`,
+        "",
+        "---",
+        "",
+    ];
+    const toolDocs = reg
+        .ids()
+        .map((id) => generateToolMarkdown(id))
+        .filter(Boolean);
+    return [...header, ...toolDocs.join("\n\n---\n\n").split("\n")].join("\n");
+}
+/**
+ * Generate a preset cross-reference table across all tools.
+ * Shows which presets are shared (e.g. stl-print-ready in FreeCAD + OpenSCAD).
+ */
+export function generatePresetCrossRef() {
+    const reg = loadRegistry();
+    const presetMap = new Map();
+    for (const tool of reg.all()) {
+        for (const presetName of Object.keys(tool.presets)) {
+            const list = presetMap.get(presetName) ?? [];
+            list.push(tool.id);
+            presetMap.set(presetName, list);
+        }
+    }
+    const lines = [
+        "# Preset Cross-Reference",
+        "",
+        "| Preset | Tools |",
+        "|--------|-------|",
+    ];
+    for (const [preset, tools] of [...presetMap.entries()].sort()) {
+        lines.push(`| \`${preset}\` | ${tools.join(", ")} |`);
+    }
+    return lines.join("\n");
+}
+// ── File-writing build step ──────────────────────────────────────
+/**
+ * Generate all tool docs and write them to disk.
+ *
+ * Creates:
+ *   - `<outDir>/tools/<toolId>.md` for each tool
+ *   - `<outDir>/registry.md` — combined registry doc
+ *   - `<outDir>/presets.md` — preset cross-reference
+ *
+ * @param outDir Target directory (default: "docs")
+ * @returns Array of file paths written
+ */
+export function generateAllToolDocs(outDir = "docs") {
+    const reg = loadRegistry();
+    const toolsDir = join(outDir, "tools");
+    mkdirSync(toolsDir, { recursive: true });
+    const written = [];
+    // Per-tool docs
+    for (const id of reg.ids()) {
+        const md = generateToolMarkdown(id);
+        if (md) {
+            const filePath = join(toolsDir, `${id}.md`);
+            writeFileSync(filePath, md + "\n", "utf8");
+            written.push(filePath);
+        }
+    }
+    // Combined registry doc
+    const registryPath = join(outDir, "registry.md");
+    writeFileSync(registryPath, generateRegistryMarkdown() + "\n", "utf8");
+    written.push(registryPath);
+    // Preset cross-reference
+    const presetsPath = join(outDir, "presets.md");
+    writeFileSync(presetsPath, generatePresetCrossRef() + "\n", "utf8");
+    written.push(presetsPath);
+    return written;
+}

package/dist/registry/cli.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Format the tool list as a printable table string.
+ */
+export declare function formatToolList(): string;
+/**
+ * Format a single tool's full info as a printable string.
+ */
+export declare function formatToolShow(toolId: string): string;
+/**
+ * Format the registry summary as a printable string.
+ */
+export declare function formatSummary(): string;
+/**
+ * Format the registry summary as JSON string.
+ */
+export declare function formatJson(): string;
+/**
+ * Run the docs generator and return a status message.
+ * @param outDir Target directory (default: "docs")
+ */
+export declare function runDocsGenerate(outDir?: string): string;
+/**
+ * Process CLI arguments and return the output string.
+ * Separated from I/O for testability.
+ */
+export declare function processCommand(args: string[]): string;
+/**
+ * CLI main — reads process.argv and writes to stdout.
+ * Called from bin/toolshop.mjs.
+ */
+export declare function main(): void;

package/dist/registry/cli.js

@@ -0,0 +1,129 @@
+import { loadRegistry } from "./runtime.js";
+import { generateAllToolDocs } from "./auto-docs.js";
+// ── CLI registry commands — testable core logic ──────────────────
+/**
+ * Format the tool list as a printable table string.
+ */
+export function formatToolList() {
+    const reg = loadRegistry();
+    const tools = reg.all();
+    const header = "ID              Presets  Premium  Version";
+    const separator = "─".repeat(header.length);
+    const rows = tools.map((t) => {
+        const presetCount = Object.keys(t.presets).length;
+        const premiumCount = Object.values(t.presets).filter((p) => p.isPremium).length;
+        return [
+            t.id.padEnd(16),
+            String(presetCount).padStart(7),
+            String(premiumCount).padStart(8),
+            `  ${t.version}`,
+        ].join("");
+    });
+    return [header, separator, ...rows].join("\n");
+}
+/**
+ * Format a single tool's full info as a printable string.
+ */
+export function formatToolShow(toolId) {
+    const reg = loadRegistry();
+    const tool = reg.get(toolId);
+    if (!tool) {
+        return `Error: tool "${toolId}" not found. Available: ${reg.ids().join(", ")}`;
+    }
+    const lines = [
+        `${tool.name} (${tool.id}) v${tool.version}`,
+        "",
+        tool.description,
+        "",
+        "Presets:",
+    ];
+    for (const [name, info] of Object.entries(tool.presets)) {
+        const tier = info.isPremium ? `Premium → ${info.fallbackTo}` : "Guaranteed";
+        lines.push(`  ${name.padEnd(24)} .${info.outputExt}  [${tier}]`);
+    }
+    lines.push("", "Patterns:");
+    for (const p of tool.commonPatterns) {
+        lines.push(`  • ${p}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format the registry summary as a printable string.
+ */
+export function formatSummary() {
+    const reg = loadRegistry();
+    const s = reg.summary;
+    return [
+        `ToolShopStudio Registry v${s.version}`,
+        "",
+        `  Tools:       ${s.toolCount}`,
+        `  Presets:     ${s.totalPresets} (${s.guaranteedPresets} guaranteed, ${s.premiumPresets} premium)`,
+        `  Formats:     ${s.uniqueOutputFormats.join(", ")}`,
+    ].join("\n");
+}
+/**
+ * Format the registry summary as JSON string.
+ */
+export function formatJson() {
+    const reg = loadRegistry();
+    return JSON.stringify(reg.summary, null, 2);
+}
+/**
+ * Run the docs generator and return a status message.
+ * @param outDir Target directory (default: "docs")
+ */
+export function runDocsGenerate(outDir = "docs") {
+    const files = generateAllToolDocs(outDir);
+    return `Generated ${files.length} docs:\n${files.map((f) => `  ${f}`).join("\n")}`;
+}
+// ── CLI entry point ──────────────────────────────────────────────
+/**
+ * Process CLI arguments and return the output string.
+ * Separated from I/O for testability.
+ */
+export function processCommand(args) {
+    const sub = args[0];
+    switch (sub) {
+        case "list":
+            return formatToolList();
+        case "show": {
+            const toolId = args[1];
+            if (!toolId)
+                return "Usage: toolshop registry show <toolId>";
+            return formatToolShow(toolId);
+        }
+        case "summary":
+            return formatSummary();
+        case "json":
+            return formatJson();
+        case "docs": {
+            const outDir = args[1] || "docs";
+            return runDocsGenerate(outDir);
+        }
+        default:
+            return [
+                "Usage: toolshop registry <command>",
+                "",
+                "Commands:",
+                "  list        List all registered tools",
+                "  show <id>   Show full details for a tool",
+                "  summary     Show registry summary",
+                "  json        Output registry summary as JSON",
+                "  docs [dir]  Generate markdown docs (default: docs/)",
+            ].join("\n");
+    }
+}
+/**
+ * CLI main — reads process.argv and writes to stdout.
+ * Called from bin/toolshop.mjs.
+ */
+export function main() {
+    const top = process.argv[2];
+    if (top === "registry") {
+        const output = processCommand(process.argv.slice(3));
+        console.log(output);
+    }
+    else {
+        console.log("Usage: toolshop registry <list|show|summary|json|docs>");
+    }
+}

package/dist/registry/consistency.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Check that ALL tools implement a specific architectural pattern.
+ * Uses case-insensitive substring matching.
+ *
+ * Returns true if every registered tool has at least one
+ * commonPattern entry that contains the given string.
+ */
+export declare function checkAllToolsHavePattern(pattern: string): boolean;
+/**
+ * Get tools that are MISSING a specific architectural pattern.
+ * Useful for finding tools that need to be updated.
+ */
+export declare function getToolsMissingPattern(pattern: string): string[];
+/**
+ * Check that all tools share the same version string.
+ * Returns the version if consistent, throws if mismatched.
+ */
+export declare function checkVersionConsistency(): string;
+/**
+ * Get the version of a specific tool.
+ * Returns null if the tool is not registered.
+ */
+export declare function getToolVersion(id: string): string | null;
+/**
+ * Check that all shared patterns from SHARED_PATTERNS are present
+ * in every tool. Returns an array of { toolId, missingPattern } entries.
+ * Empty array means fully consistent.
+ */
+export declare function checkSharedPatternCoverage(): Array<{
+    toolId: string;
+    missingPattern: string;
+}>;
+/**
+ * Get a summary of the registry: tool count, total presets,
+ * premium count, guaranteed count, unique output formats.
+ */
+export declare function getRegistrySummary(): {
+    toolCount: number;
+    totalPresets: number;
+    premiumPresets: number;
+    guaranteedPresets: number;
+    uniqueOutputFormats: string[];
+    version: string;
+};

package/dist/registry/consistency.js

@@ -0,0 +1,89 @@
+import { TOOL_REGISTRY } from "./tools.js";
+import { SHARED_PATTERNS } from "./helpers.js";
+// ── Consistency checks — pure cross-tool assertions ──────────────
+/**
+ * Check that ALL tools implement a specific architectural pattern.
+ * Uses case-insensitive substring matching.
+ *
+ * Returns true if every registered tool has at least one
+ * commonPattern entry that contains the given string.
+ */
+export function checkAllToolsHavePattern(pattern) {
+    const lower = pattern.toLowerCase();
+    return Object.values(TOOL_REGISTRY).every((tool) => tool.commonPatterns.some((p) => p.toLowerCase().includes(lower)));
+}
+/**
+ * Get tools that are MISSING a specific architectural pattern.
+ * Useful for finding tools that need to be updated.
+ */
+export function getToolsMissingPattern(pattern) {
+    const lower = pattern.toLowerCase();
+    return Object.entries(TOOL_REGISTRY)
+        .filter(([, tool]) => !tool.commonPatterns.some((p) => p.toLowerCase().includes(lower)))
+        .map(([id]) => id);
+}
+/**
+ * Check that all tools share the same version string.
+ * Returns the version if consistent, throws if mismatched.
+ */
+export function checkVersionConsistency() {
+    const versions = new Set(Object.values(TOOL_REGISTRY).map((t) => t.version));
+    if (versions.size !== 1) {
+        const details = Object.entries(TOOL_REGISTRY)
+            .map(([id, t]) => `  ${id}: ${t.version}`)
+            .join("\n");
+        throw new Error(`Version mismatch across tools:\n${details}`);
+    }
+    return [...versions][0];
+}
+/**
+ * Get the version of a specific tool.
+ * Returns null if the tool is not registered.
+ */
+export function getToolVersion(id) {
+    return TOOL_REGISTRY[id]?.version ?? null;
+}
+/**
+ * Check that all shared patterns from SHARED_PATTERNS are present
+ * in every tool. Returns an array of { toolId, missingPattern } entries.
+ * Empty array means fully consistent.
+ */
+export function checkSharedPatternCoverage() {
+    const gaps = [];
+    for (const [toolId, tool] of Object.entries(TOOL_REGISTRY)) {
+        for (const required of SHARED_PATTERNS) {
+            const found = tool.commonPatterns.some((p) => p.toLowerCase().includes(required.toLowerCase()));
+            if (!found) {
+                gaps.push({ toolId, missingPattern: required });
+            }
+        }
+    }
+    return gaps;
+}
+/**
+ * Get a summary of the registry: tool count, total presets,
+ * premium count, guaranteed count, unique output formats.
+ */
+export function getRegistrySummary() {
+    const tools = Object.values(TOOL_REGISTRY);
+    let totalPresets = 0;
+    let premiumPresets = 0;
+    const formats = new Set();
+    for (const tool of tools) {
+        for (const info of Object.values(tool.presets)) {
+            totalPresets++;
+            if (info.isPremium)
+                premiumPresets++;
+            if (info.outputFormat)
+                formats.add(info.outputFormat.toUpperCase());
+        }
+    }
+    return {
+        toolCount: tools.length,
+        totalPresets,
+        premiumPresets,
+        guaranteedPresets: totalPresets - premiumPresets,
+        uniqueOutputFormats: [...formats].sort(),
+        version: tools[0]?.version ?? "unknown",
+    };
+}

package/dist/registry/engine.test.d.ts

@@ -0,0 +1 @@
+export {};