@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/mcp/tools-export.js

@@ -1,222 +0,0 @@
-/**
- * MCP Export Tool - fw_export
- *
- * Allows Claude Code to export workflows as serverless deployments
- * without the GUI. Generates handler code, platform config, and deploy instructions.
- */
-import { z } from 'zod';
-import * as path from 'path';
-import * as fs from 'fs';
-import { parseWorkflow } from '../api/index.js';
-import { createTargetRegistry } from '../deployment/index.js';
-import { makeToolResult, makeErrorResult } from './response-utils.js';
-export function registerExportTools(mcp) {
-    mcp.tool('fw_export', 'Export workflows as serverless deployments. Generates platform-native config files and deploy instructions. Available targets depend on installed packs.', {
-        filePath: z.string().describe('Path to the workflow .ts file'),
-        target: z
-            .string()
-            .describe('Deployment target platform. Run with --list-targets to see installed targets.'),
-        outputDir: z.string().optional().describe('Output directory for generated files (default: ./dist relative to workflow)'),
-        serviceName: z
-            .string()
-            .optional()
-            .describe('Service name (default: derived from filename)'),
-        workflows: z
-            .array(z.string())
-            .optional()
-            .describe('Specific workflow function names to include (default: all)'),
-        nodeTypes: z
-            .array(z.string())
-            .optional()
-            .describe('Specific node type names to include'),
-        includeDocs: z
-            .boolean()
-            .optional()
-            .describe('Include OpenAPI/Swagger routes (default: true)'),
-        preview: z
-            .boolean()
-            .optional()
-            .describe('Preview without writing files to disk (default: false)'),
-        durableSteps: z
-            .boolean()
-            .optional()
-            .describe('Use deep generator with per-node durable steps'),
-    }, async (args) => {
-        try {
-            const filePath = path.resolve(args.filePath);
-            const outputDir = path.resolve(args.outputDir || path.join(path.dirname(filePath), 'dist'));
-            const preview = args.preview ?? false;
-            const includeDocs = args.includeDocs ?? true;
-            // 1. Validate file exists
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return makeErrorResult('FILE_NOT_FOUND', `File not found: ${filePath}`);
-            }
-            // 2. Discover targets from installed packs
-            const registry = await createTargetRegistry(process.cwd());
-            const exportTarget = registry.get(args.target);
-            if (!exportTarget) {
-                const available = registry.getNames();
-                return makeErrorResult('INVALID_TARGET', available.length === 0
-                    ? `No export targets installed. Install a target pack (e.g. npm install flow-weaver-pack-${args.target})`
-                    : `Unknown target: "${args.target}". Installed: ${available.join(', ')}`);
-            }
-            // 3. Parse the file to discover workflows and node types
-            let parseResult;
-            try {
-                parseResult = await parseWorkflow(filePath, { nodeTypesOnly: false, projectDir: path.dirname(filePath) });
-            }
-            catch (err) {
-                return makeErrorResult('PARSE_ERROR', `Failed to parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            if (parseResult.errors.length > 0) {
-                // Try node-types-only parse
-                try {
-                    const ntResult = await parseWorkflow(filePath, { nodeTypesOnly: true, projectDir: path.dirname(filePath) });
-                    if (ntResult.errors.length === 0) {
-                        parseResult = ntResult;
-                    }
-                }
-                catch {
-                    // Use original errors
-                }
-                if (parseResult.errors.length > 0) {
-                    return makeErrorResult('PARSE_ERROR', `Parse errors in ${filePath}: ${parseResult.errors.join('; ')}`);
-                }
-            }
-            // CI/CD targets use generate() directly — they read the AST, not compiled code
-            if (!exportTarget.generateBundle) {
-                const serviceName = args.serviceName || path.basename(filePath, '.ts').replace(/[^a-zA-Z0-9-]/g, '-');
-                const artifacts = await exportTarget.generate({
-                    sourceFile: filePath,
-                    workflowName: args.workflows?.[0] || serviceName,
-                    displayName: serviceName,
-                    outputDir,
-                    production: true,
-                });
-                // Write files if not preview
-                if (!preview) {
-                    await fs.promises.mkdir(outputDir, { recursive: true });
-                    for (const file of artifacts.files) {
-                        const fullPath = path.join(outputDir, file.relativePath);
-                        await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
-                        await fs.promises.writeFile(fullPath, file.content, 'utf-8');
-                    }
-                }
-                const instructions = exportTarget.getDeployInstructions(artifacts);
-                return makeToolResult({
-                    preview,
-                    target: args.target,
-                    serviceName,
-                    outputDir,
-                    files: artifacts.files.map((f) => ({
-                        path: f.relativePath,
-                        type: f.type,
-                        size: f.content.length,
-                    })),
-                    instructions: {
-                        title: instructions.title,
-                        steps: instructions.steps,
-                        prerequisites: instructions.prerequisites,
-                    },
-                    summary: preview
-                        ? `Preview: ${artifacts.files.length} files would be generated in ${outputDir}`
-                        : `Exported ${artifacts.files.length} files to ${outputDir}`,
-                });
-            }
-            // 4. Build workflow and node type lists
-            const allWorkflows = parseResult.allWorkflows || [];
-            const allNodeTypes = allWorkflows.flatMap((w) => w.nodeTypes || []);
-            // Deduplicate node types by name
-            const uniqueNodeTypes = [
-                ...new Map(allNodeTypes.map((nt) => [nt.name, nt])).values(),
-            ];
-            const serviceName = args.serviceName || path.basename(filePath, '.ts').replace(/[^a-zA-Z0-9-]/g, '-');
-            // Filter to requested items
-            const bundleWorkflows = allWorkflows
-                .filter((w) => (args.workflows ? args.workflows.includes(w.name) : true))
-                .map((w) => ({
-                name: w.name,
-                functionName: w.functionName,
-                description: w.description,
-                expose: true,
-            }));
-            const bundleNodeTypes = uniqueNodeTypes
-                .filter((nt) => (args.nodeTypes ? args.nodeTypes.includes(nt.name) : false))
-                .map((nt) => ({
-                name: nt.name,
-                functionName: nt.functionName,
-                description: undefined,
-                inputs: Object.fromEntries(Object.entries(nt.inputs).map(([k, v]) => [
-                    k,
-                    { dataType: v.dataType, tsType: v.tsType, label: v.label, optional: v.optional },
-                ])),
-                outputs: Object.fromEntries(Object.entries(nt.outputs).map(([k, v]) => [
-                    k,
-                    { dataType: v.dataType, tsType: v.tsType, label: v.label },
-                ])),
-                expose: true,
-            }));
-            if (bundleWorkflows.length === 0 && bundleNodeTypes.length === 0) {
-                return makeErrorResult('EXPORT_ERROR', 'No workflows or node types selected for export. ' +
-                    `Found ${allWorkflows.length} workflows and ${allNodeTypes.length} node types in file.`);
-            }
-            // 5. Generate the bundle
-            const artifacts = await exportTarget.generateBundle(bundleWorkflows, bundleNodeTypes, {
-                sourceFile: filePath,
-                workflowName: serviceName,
-                displayName: serviceName,
-                outputDir,
-                production: true,
-                includeDocs,
-                targetOptions: {
-                    ...(args.durableSteps && { durableSteps: true }),
-                    // Pass @deploy config from workflow AST so targets can read their annotations
-                    ...(allWorkflows[0]?.options?.deploy && { deploy: allWorkflows[0].options.deploy }),
-                },
-            });
-            // 6. Write files if not preview
-            if (!preview) {
-                await fs.promises.mkdir(outputDir, { recursive: true });
-                for (const file of artifacts.files) {
-                    const fullPath = path.join(outputDir, file.relativePath);
-                    await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
-                    await fs.promises.writeFile(fullPath, file.content, 'utf-8');
-                }
-            }
-            // 7. Get deploy instructions
-            const instructions = exportTarget.getDeployInstructions(artifacts);
-            // 8. Return result
-            return makeToolResult({
-                preview,
-                target: args.target,
-                serviceName,
-                outputDir,
-                files: artifacts.files.map((f) => ({
-                    path: f.relativePath,
-                    type: f.type,
-                    size: f.content.length,
-                })),
-                endpoints: bundleWorkflows.map((w) => ({
-                    method: 'POST',
-                    path: `/workflows/${w.functionName}`,
-                    name: w.name,
-                })),
-                instructions: {
-                    title: instructions.title,
-                    steps: instructions.steps,
-                    prerequisites: instructions.prerequisites,
-                },
-                summary: preview
-                    ? `Preview: ${artifacts.files.length} files would be generated in ${outputDir}`
-                    : `Exported ${artifacts.files.length} files to ${outputDir}`,
-            });
-        }
-        catch (err) {
-            return makeErrorResult('EXPORT_ERROR', `Export failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    });
-}
-//# sourceMappingURL=tools-export.js.map

package/dist/mcp/tools-marketplace.js

@@ -1,132 +0,0 @@
-/**
- * MCP Marketplace Tools — fw_market_search, fw_market_install, fw_market_list
- *
- * Allows Claude Code to discover, install, and inspect marketplace packages
- * during vibe coding sessions.
- */
-import { z } from 'zod';
-import { execSync } from 'child_process';
-import { searchPackages, listInstalledPackages, getInstalledPackageManifest, } from '../marketplace/index.js';
-import { makeToolResult, makeErrorResult } from './response-utils.js';
-export function registerMarketplaceTools(mcp) {
-    // ── fw_market_search ─────────────────────────────────────────────────────
-    mcp.tool('fw_market_search', 'Search npm for Flow Weaver marketplace packages (node types, workflows, patterns). Returns package name, version, and description.', {
-        query: z.string().optional().describe('Search query text (optional — omit to browse all)'),
-        limit: z
-            .number()
-            .optional()
-            .describe('Maximum number of results (default: 20)'),
-        registryUrl: z
-            .string()
-            .optional()
-            .describe('Custom registry search URL for private registries (default: public npm)'),
-    }, async (args) => {
-        try {
-            const results = await searchPackages({
-                query: args.query,
-                limit: args.limit,
-                registryUrl: args.registryUrl,
-            });
-            return makeToolResult({
-                count: results.length,
-                packages: results.map((pkg) => ({
-                    name: pkg.name,
-                    version: pkg.version,
-                    description: pkg.description,
-                    official: pkg.official,
-                    publisher: pkg.publisher,
-                })),
-                hint: results.length > 0
-                    ? 'Use fw_market_install to install a package'
-                    : 'No packages found — try a different query or browse all with no query',
-            });
-        }
-        catch (err) {
-            return makeErrorResult('SEARCH_FAILED', err instanceof Error ? err.message : String(err));
-        }
-    });
-    // ── fw_market_install ────────────────────────────────────────────────────
-    mcp.tool('fw_market_install', 'Install a Flow Weaver marketplace package via npm. After installation, the package\'s node types, workflows, and patterns become available for use.', {
-        package: z.string().describe('Package name or specifier (e.g., "flow-weaver-pack-openai" or "flow-weaver-pack-openai@1.0.0")'),
-    }, async (args) => {
-        try {
-            // Run npm install
-            execSync(`npm install ${args.package}`, {
-                cwd: process.cwd(),
-                stdio: 'pipe',
-            });
-            // Try to read the manifest
-            const packageName = resolvePackageName(args.package);
-            const manifest = getInstalledPackageManifest(process.cwd(), packageName);
-            if (manifest) {
-                return makeToolResult({
-                    installed: packageName,
-                    version: manifest.version,
-                    nodeTypes: manifest.nodeTypes.map((nt) => ({
-                        name: nt.name,
-                        description: nt.description,
-                        inputs: Object.keys(nt.inputs),
-                        outputs: Object.keys(nt.outputs),
-                    })),
-                    workflows: manifest.workflows.map((wf) => ({
-                        name: wf.name,
-                        description: wf.description,
-                    })),
-                    patterns: manifest.patterns.map((p) => ({
-                        name: p.name,
-                        description: p.description,
-                    })),
-                });
-            }
-            return makeToolResult({
-                installed: packageName,
-                note: 'Package installed but no flowweaver.manifest.json found',
-            });
-        }
-        catch (err) {
-            return makeErrorResult('INSTALL_FAILED', err instanceof Error ? err.message : String(err));
-        }
-    });
-    // ── fw_market_list ───────────────────────────────────────────────────────
-    mcp.tool('fw_market_list', 'List installed Flow Weaver marketplace packages in the current project. Shows available node types, workflows, and patterns from each package.', {}, async () => {
-        try {
-            const packages = await listInstalledPackages(process.cwd());
-            return makeToolResult({
-                count: packages.length,
-                packages: packages.map((pkg) => ({
-                    name: pkg.name,
-                    version: pkg.version,
-                    path: pkg.path,
-                    nodeTypes: pkg.manifest.nodeTypes.map((nt) => ({
-                        name: nt.name,
-                        description: nt.description,
-                    })),
-                    workflows: pkg.manifest.workflows.map((wf) => ({
-                        name: wf.name,
-                        description: wf.description,
-                    })),
-                    patterns: pkg.manifest.patterns.map((p) => ({
-                        name: p.name,
-                        description: p.description,
-                    })),
-                })),
-                hint: packages.length === 0
-                    ? 'No marketplace packages installed. Use fw_market_search to find packages.'
-                    : undefined,
-            });
-        }
-        catch (err) {
-            return makeErrorResult('LIST_FAILED', err instanceof Error ? err.message : String(err));
-        }
-    });
-}
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function resolvePackageName(spec) {
-    if (spec.startsWith('@')) {
-        const atIndex = spec.indexOf('@', 1);
-        return atIndex > 0 ? spec.slice(0, atIndex) : spec;
-    }
-    const atIndex = spec.indexOf('@');
-    return atIndex > 0 ? spec.slice(0, atIndex) : spec;
-}
-//# sourceMappingURL=tools-marketplace.js.map

package/dist/mcp/tools-model.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerModelTools(mcp: McpServer): void;
-//# sourceMappingURL=tools-model.d.ts.map

package/dist/mcp/tools-model.js

@@ -1,279 +0,0 @@
-import { z } from 'zod';
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseWorkflow, validateWorkflow } from '../api/index.js';
-import { generateFunctionSignature } from '../annotation-generator.js';
-import { makeToolResult, makeErrorResult } from './response-utils.js';
-const stepSchema = z.object({
-    name: z.string().describe('Function name for this node'),
-    description: z.string().optional().describe('Brief description of what this node does'),
-    inputs: z.record(z.string()).describe('Input ports as { portName: dataType } (e.g. { email: "STRING" })'),
-    outputs: z.record(z.string()).describe('Output ports as { portName: dataType }'),
-});
-/**
- * Find a `declare function <name>(...): ...;` declaration in source text,
- * handling multiline signatures. Returns the full matched text and its
- * leading indentation, or null if not found.
- */
-function findDeclareFunction(source, functionName) {
-    const lines = source.split('\n');
-    const startPattern = new RegExp(`^(\\s*)declare\\s+function\\s+${escapeRegex(functionName)}\\s*\\(`);
-    for (let i = 0; i < lines.length; i++) {
-        const m = lines[i].match(startPattern);
-        if (!m)
-            continue;
-        const indent = m[1] || '';
-        // Accumulate lines until we find one ending with ;
-        let accumulated = lines[i];
-        let j = i;
-        while (!accumulated.trimEnd().endsWith(';') && j < lines.length - 1) {
-            j++;
-            accumulated += '\n' + lines[j];
-        }
-        return { match: accumulated, indent };
-    }
-    return null;
-}
-export function registerModelTools(mcp) {
-    mcp.tool('fw_create_model', 'Create a new stub workflow model from a structured description. ' +
-        'Generates a TypeScript file with declare function stubs and workflow annotations. ' +
-        'The model can be validated structurally before any node is implemented.', {
-        name: z.string().describe('Workflow name (used as export name)'),
-        description: z.string().optional().describe('Workflow description'),
-        steps: z.array(stepSchema).min(1).describe('Node definitions in execution order'),
-        flow: z
-            .string()
-            .describe('Execution path, e.g. "Start -> validateEmail -> checkUserExists -> Exit"'),
-        filePath: z.string().describe('Output file path'),
-    }, async (args) => {
-        try {
-            const outputPath = path.resolve(args.filePath);
-            const lines = [];
-            // Generate declare function stubs
-            for (const step of args.steps) {
-                lines.push('/** @flowWeaver node */');
-                const params = Object.entries(step.inputs)
-                    .map(([name, type]) => `${name}: ${mapTypeToTS(type)}`)
-                    .join(', ');
-                const outputEntries = Object.entries(step.outputs);
-                const returnType = outputEntries.length === 1
-                    ? mapTypeToTS(outputEntries[0][1])
-                    : `{ ${outputEntries.map(([name, type]) => `${name}: ${mapTypeToTS(type)}`).join('; ')} }`;
-                lines.push(`declare function ${step.name}(${params}): ${returnType};`);
-                lines.push('');
-            }
-            // Build @node annotations using full name as both ID and type
-            const nodeAnnotations = args.steps.map((step) => `@node ${step.name} ${step.name}`);
-            // Split comma-separated flow into separate @path annotations
-            const pathAnnotations = args.flow.split(',').map((segment) => {
-                const steps = segment
-                    .split('->')
-                    .map((s) => s.trim())
-                    .filter(Boolean);
-                return `@path ${steps.join(' -> ')}`;
-            });
-            // Generate @connect annotations for DATA ports between adjacent steps in the flow
-            const stepMap = new Map(args.steps.map((s) => [s.name, s]));
-            const connectAnnotations = [];
-            for (const segment of args.flow.split(',')) {
-                const flowNodes = segment.split('->').map((s) => s.trim()).filter(Boolean);
-                for (let i = 0; i < flowNodes.length - 1; i++) {
-                    const fromStep = stepMap.get(flowNodes[i]);
-                    const toStep = stepMap.get(flowNodes[i + 1]);
-                    if (!fromStep || !toStep)
-                        continue;
-                    // Connect matching output->input port names
-                    for (const outputName of Object.keys(fromStep.outputs)) {
-                        if (outputName in toStep.inputs) {
-                            connectAnnotations.push(`@connect ${fromStep.name}.${outputName} -> ${toStep.name}.${outputName}`);
-                        }
-                    }
-                }
-            }
-            // Generate workflow annotation
-            const jsdocLines = ['/**'];
-            if (args.description) {
-                jsdocLines.push(` * ${args.description}`);
-                jsdocLines.push(' *');
-            }
-            jsdocLines.push(' * @flowWeaver workflow @autoConnect');
-            for (const nodeAnn of nodeAnnotations) {
-                jsdocLines.push(` * ${nodeAnn}`);
-            }
-            for (const pathAnn of pathAnnotations) {
-                jsdocLines.push(` * ${pathAnn}`);
-            }
-            for (const connAnn of connectAnnotations) {
-                jsdocLines.push(` * ${connAnn}`);
-            }
-            jsdocLines.push(' */');
-            jsdocLines.push(`export async function ${args.name}() {`);
-            jsdocLines.push(`  // stub - compile to generate workflow body`);
-            jsdocLines.push(`}`);
-            lines.push(...jsdocLines);
-            lines.push('');
-            const content = lines.join('\n');
-            const dir = path.dirname(outputPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(outputPath, content, 'utf8');
-            return makeToolResult({
-                filePath: outputPath,
-                workflowName: args.name,
-                stubCount: args.steps.length,
-                nodes: args.steps.map((s) => s.name),
-            });
-        }
-        catch (err) {
-            return makeErrorResult('CREATE_MODEL_ERROR', `fw_create_model failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    });
-    mcp.tool('fw_workflow_status', 'Report implementation progress for a workflow — which nodes are stubs, ' +
-        'which are implemented, and whether the graph structure is valid.', {
-        filePath: z.string().describe('Path to the workflow file'),
-        workflowName: z.string().optional().describe('Specific workflow name if file has multiple'),
-    }, async (args) => {
-        try {
-            const filePath = path.resolve(args.filePath);
-            const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
-            if (parseResult.errors.length > 0) {
-                return makeErrorResult('PARSE_ERROR', `Parse errors:\n${parseResult.errors.join('\n')}`);
-            }
-            const ast = parseResult.ast;
-            const instanceTypeMap = new Map();
-            for (const nt of ast.nodeTypes) {
-                instanceTypeMap.set(nt.name, nt);
-                if (nt.functionName !== nt.name) {
-                    instanceTypeMap.set(nt.functionName, nt);
-                }
-            }
-            const nodes = [];
-            const seen = new Set();
-            for (const instance of ast.instances) {
-                const nt = instanceTypeMap.get(instance.nodeType);
-                if (!nt || seen.has(nt.functionName))
-                    continue;
-                seen.add(nt.functionName);
-                const inputs = {};
-                const outputs = {};
-                for (const [name, port] of Object.entries(nt.inputs)) {
-                    if (name === 'execute')
-                        continue;
-                    inputs[name] = port.dataType;
-                }
-                for (const [name, port] of Object.entries(nt.outputs)) {
-                    if (name === 'onSuccess' || name === 'onFailure')
-                        continue;
-                    outputs[name] = port.dataType;
-                }
-                nodes.push({
-                    name: nt.functionName,
-                    status: nt.variant === 'STUB' ? 'stub' : 'implemented',
-                    inputs,
-                    outputs,
-                });
-            }
-            const implemented = nodes.filter((n) => n.status === 'implemented').length;
-            const total = nodes.length;
-            // Draft validation for structural issues
-            const validation = validateWorkflow(ast, { mode: 'draft' });
-            const structuralErrors = validation.errors
-                .filter((e) => e.code !== 'STUB_NODE')
-                .map((e) => ({ message: e.message, code: e.code, node: e.node }));
-            return makeToolResult({
-                workflowName: ast.name,
-                implemented,
-                total,
-                percentage: total > 0 ? Math.round((implemented / total) * 100) : 100,
-                nodes,
-                structurallyValid: structuralErrors.length === 0,
-                structuralErrors,
-            });
-        }
-        catch (err) {
-            return makeErrorResult('STATUS_ERROR', `fw_workflow_status failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    });
-    mcp.tool('fw_implement_node', 'Replace a stub node (declare function) with a real function skeleton, ' +
-        'or write a provided implementation directly. Preserves existing JSDoc annotations.', {
-        filePath: z.string().describe('Path to the workflow file'),
-        nodeName: z.string().describe('Function name of the stub node to implement'),
-        implementation: z
-            .string()
-            .optional()
-            .describe('Full function body to write. If omitted, generates a skeleton.'),
-        workflowName: z.string().optional().describe('Specific workflow name'),
-    }, async (args) => {
-        try {
-            const filePath = path.resolve(args.filePath);
-            if (!fs.existsSync(filePath)) {
-                return makeErrorResult('FILE_NOT_FOUND', `File not found: ${args.filePath}`);
-            }
-            const parseResult = await parseWorkflow(filePath, { workflowName: args.workflowName });
-            if (parseResult.errors.length > 0) {
-                return makeErrorResult('PARSE_ERROR', `Parse errors:\n${parseResult.errors.join('\n')}`);
-            }
-            const ast = parseResult.ast;
-            const stubNt = ast.nodeTypes.find((nt) => nt.variant === 'STUB' && (nt.functionName === args.nodeName || nt.name === args.nodeName));
-            if (!stubNt) {
-                const existing = ast.nodeTypes.find((nt) => nt.functionName === args.nodeName || nt.name === args.nodeName);
-                if (existing) {
-                    return makeErrorResult('ALREADY_IMPLEMENTED', `Node "${args.nodeName}" is already implemented.`);
-                }
-                const stubs = ast.nodeTypes
-                    .filter((nt) => nt.variant === 'STUB')
-                    .map((nt) => nt.functionName);
-                return makeErrorResult('NODE_NOT_FOUND', `Stub "${args.nodeName}" not found. Available stubs: ${stubs.join(', ') || 'none'}`);
-            }
-            const source = fs.readFileSync(filePath, 'utf8');
-            const found = findDeclareFunction(source, stubNt.functionName);
-            if (!found) {
-                return makeErrorResult('SOURCE_MISMATCH', `Could not find "declare function ${stubNt.functionName}" in source file.`);
-            }
-            let replacement;
-            if (args.implementation) {
-                replacement = args.implementation
-                    .split('\n')
-                    .map((line) => found.indent + line)
-                    .join('\n');
-            }
-            else {
-                const implementedType = { ...stubNt, variant: 'FUNCTION' };
-                const signatureLines = generateFunctionSignature(implementedType);
-                replacement = signatureLines.map((line) => found.indent + line).join('\n');
-            }
-            const updated = source.replace(found.match, replacement);
-            fs.writeFileSync(filePath, updated, 'utf8');
-            return makeToolResult({
-                nodeName: stubNt.functionName,
-                filePath,
-                action: args.implementation ? 'implemented' : 'scaffolded',
-            });
-        }
-        catch (err) {
-            return makeErrorResult('IMPLEMENT_ERROR', `fw_implement_node failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    });
-}
-function mapTypeToTS(dataType) {
-    const upper = dataType.toUpperCase();
-    switch (upper) {
-        case 'STRING':
-            return 'string';
-        case 'NUMBER':
-            return 'number';
-        case 'BOOLEAN':
-            return 'boolean';
-        case 'OBJECT':
-            return 'Record<string, unknown>';
-        case 'ARRAY':
-            return 'unknown[]';
-        default:
-            return 'unknown';
-    }
-}
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-//# sourceMappingURL=tools-model.js.map

package/dist/mcp/tools-pattern.d.ts

@@ -1,3 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerPatternTools(mcp: McpServer): void;
-//# sourceMappingURL=tools-pattern.d.ts.map