@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/cli/commands/diagram.js

@@ -1,39 +0,0 @@
-/* eslint-disable no-console */
-/**
- * Diagram command — generates SVG, interactive HTML, or ASCII diagrams from workflow files.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileToSVG, fileToHTML, fileToASCII } from '../../diagram/index.js';
-import { parser } from '../../parser.js';
-import { logger } from '../utils/logger.js';
-import { safeWriteFile } from '../utils/safe-write.js';
-const ASCII_FORMATS = new Set(['ascii', 'ascii-compact', 'text']);
-export async function diagramCommand(input, options = {}) {
-    const { output, format = 'svg', ...diagramOptions } = options;
-    const filePath = path.resolve(input);
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    // Load marketplace pack tag handlers before parsing
-    await parser.loadPackHandlers(path.dirname(filePath));
-    let result;
-    if (ASCII_FORMATS.has(format)) {
-        result = fileToASCII(filePath, { ...diagramOptions, format });
-    }
-    else if (format === 'html') {
-        result = fileToHTML(filePath, { ...diagramOptions, format });
-    }
-    else {
-        result = fileToSVG(filePath, diagramOptions);
-    }
-    if (output) {
-        const outputPath = path.resolve(output);
-        safeWriteFile(outputPath, result);
-        logger.success(`Diagram written to ${outputPath}`);
-    }
-    else {
-        process.stdout.write(result);
-    }
-}
-//# sourceMappingURL=diagram.js.map

package/dist/cli/commands/diff.js

@@ -1,57 +0,0 @@
-/**
- * Diff command - compares two workflow files semantically
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseWorkflow } from '../../api/index.js';
-import { WorkflowDiffer, formatDiff } from '../../diff/index.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
-export async function diffCommand(file1, file2, options = {}) {
-    const { format = 'text', workflowName, exitZero = false } = options;
-    const filePath1 = path.resolve(file1);
-    const filePath2 = path.resolve(file2);
-    // Validate files exist
-    if (!fs.existsSync(filePath1)) {
-        throw new Error(`File not found: ${filePath1}`);
-    }
-    if (!fs.existsSync(filePath2)) {
-        throw new Error(`File not found: ${filePath2}`);
-    }
-    try {
-        // Parse both workflows
-        const [result1, result2] = await Promise.all([
-            parseWorkflow(filePath1, { workflowName, projectDir: path.dirname(filePath1) }),
-            parseWorkflow(filePath2, { workflowName, projectDir: path.dirname(filePath2) }),
-        ]);
-        if (result1.errors.length > 0) {
-            throw new Error(`Parse errors in ${file1}:\n${result1.errors.map((err) => `  ${err}`).join('\n')}`);
-        }
-        if (result2.errors.length > 0) {
-            throw new Error(`Parse errors in ${file2}:\n${result2.errors.map((err) => `  ${err}`).join('\n')}`);
-        }
-        // Compare workflows
-        const diff = WorkflowDiffer.compare(result1.ast, result2.ast);
-        // Output based on format
-        if (diff.identical) {
-            if (format === 'json') {
-                console.log(JSON.stringify({ identical: true }));
-            }
-            else {
-                logger.success('Workflows are identical');
-            }
-        }
-        else {
-            // eslint-disable-next-line no-console
-            console.log(formatDiff(diff, format));
-            // Throw if there are differences (useful for CI)
-            if (!exitZero) {
-                throw new Error('Workflows have differences');
-            }
-        }
-    }
-    catch (error) {
-        throw new Error(`Failed to diff workflows: ${getErrorMessage(error)}`);
-    }
-}
-//# sourceMappingURL=diff.js.map

package/dist/cli/commands/docs.js

@@ -1,74 +0,0 @@
-import { listTopics, readTopic, readTopicStructured, searchDocs } from '../../docs/index.js';
-import { logger } from '../utils/logger.js';
-export async function docsListCommand(options) {
-    const topics = listTopics();
-    if (topics.length === 0) {
-        throw new Error('No documentation topics found.');
-    }
-    if (options.json) {
-        process.stdout.write(JSON.stringify({ topics }, null, 2) + '\n');
-        return;
-    }
-    logger.section('Flow Weaver Documentation');
-    logger.newline();
-    const maxSlug = Math.max(...topics.map((t) => t.slug.length));
-    for (const topic of topics) {
-        logger.log(`  ${topic.slug.padEnd(maxSlug + 2)} ${topic.description}`);
-    }
-    logger.newline();
-    logger.log('  Usage: fw docs <topic>');
-    logger.log('  Search: fw docs search <query>');
-    logger.newline();
-}
-export async function docsReadCommand(topic, options) {
-    if (options.json) {
-        const structured = readTopicStructured(topic);
-        if (!structured) {
-            throw new Error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
-        }
-        process.stdout.write(JSON.stringify(structured, null, 2) + '\n');
-        return;
-    }
-    const doc = readTopic(topic, options.compact);
-    if (!doc) {
-        throw new Error(`Unknown topic: "${topic}". Run "fw docs" to see available topics.`);
-    }
-    process.stdout.write(doc.content + '\n');
-}
-export async function docsSearchCommand(query, options) {
-    const results = searchDocs(query);
-    if (options.json) {
-        process.stdout.write(JSON.stringify({ query, results }, null, 2) + '\n');
-        return;
-    }
-    if (results.length === 0) {
-        logger.log(`No results found for "${query}".`);
-        return;
-    }
-    logger.section(`Search results for "${query}"`);
-    logger.newline();
-    // Deduplicate by topic+heading, show top results
-    const seen = new Set();
-    let shown = 0;
-    for (const result of results) {
-        const key = `${result.slug}:${result.heading}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        logger.log(`  [${result.slug}] ${result.heading}`);
-        if (result.excerpt) {
-            const excerptLines = result.excerpt.split('\n').slice(0, 2);
-            for (const line of excerptLines) {
-                logger.log(`    ${line}`);
-            }
-        }
-        logger.newline();
-        shown++;
-        if (shown >= 15)
-            break;
-    }
-    logger.log(`  ${results.length} matching section(s) across ${new Set(results.map((r) => r.slug)).size} topic(s).`);
-    logger.log('  Read a topic: fw docs <topic>');
-    logger.newline();
-}
-//# sourceMappingURL=docs.js.map

package/dist/cli/commands/export.js

@@ -1,153 +0,0 @@
-/**
- * Export command - generate serverless function handlers for deployment
- */
-import { exportWorkflow } from '../../export/index.js';
-import { logger } from '../utils/logger.js';
-/**
- * Export a workflow as a serverless function.
- *
- * @param input - Path to the workflow file
- * @param options - Export options
- *
- * @example
- * ```bash
- * # Export for a target (install the corresponding pack first)
- * fw export workflow.ts --target <target> --output dist/
- *
- * # Export specific workflow from multi-workflow file
- * fw export multi-workflow.ts --target <target> --output api/ --workflow calculate
- *
- * # Export all workflows as a single service
- * fw export workflows.ts --target <target> --output dist/ --multi
- *
- * # Export with API documentation routes
- * fw export workflow.ts --target <target> --output dist/ --docs
- * ```
- */
-export async function exportCommand(input, options) {
-    // Validate target is provided
-    if (!options.target) {
-        throw new Error('--target is required. Install a target pack first.');
-    }
-    const isDryRun = options.dryRun ?? false;
-    const t = logger.timer();
-    const isMulti = options.multi ?? false;
-    const workflowsList = options.workflows
-        ? options.workflows.split(',').map((w) => w.trim())
-        : undefined;
-    logger.section(isDryRun ? 'Export Preview (Dry Run)' : 'Exporting Workflow');
-    logger.info(`Input: ${input}`);
-    logger.info(`Target: ${options.target}`);
-    logger.info(`Output: ${options.output}`);
-    if (isMulti) {
-        logger.info('Mode: Multi-workflow service');
-        if (workflowsList) {
-            logger.info(`Workflows: ${workflowsList.join(', ')}`);
-        }
-        else {
-            logger.info('Workflows: All workflows in file');
-        }
-    }
-    else if (options.workflow) {
-        logger.info(`Workflow: ${options.workflow}`);
-    }
-    if (options.docs) {
-        logger.info('Include docs: Yes (/docs and /openapi.json routes)');
-    }
-    if (options.durableSteps) {
-        logger.info('Durable steps: Yes');
-    }
-    if (isDryRun) {
-        logger.info('Mode: DRY RUN (no files will be written)');
-    }
-    logger.newline();
-    const result = await exportWorkflow({
-        target: options.target,
-        input,
-        output: options.output,
-        workflow: options.workflow,
-        production: options.production ?? false,
-        bundle: options.bundle,
-        dryRun: isDryRun,
-        multi: isMulti,
-        workflows: workflowsList,
-        includeDocs: options.docs,
-        durableSteps: options.durableSteps,
-    });
-    if (isDryRun) {
-        if (result.workflows && result.workflows.length > 1) {
-            logger.success(`Preview for multi-workflow service "${result.workflow}" with ${result.workflows.length} workflows (${result.target})`);
-        }
-        else {
-            logger.success(`Preview for workflow "${result.workflow}" (${result.target})`);
-        }
-    }
-    else {
-        if (result.workflows && result.workflows.length > 1) {
-            logger.success(`Exported multi-workflow service "${result.workflow}" with ${result.workflows.length} workflows for ${result.target}`);
-            logger.info(`Workflows: ${result.workflows.join(', ')}`);
-        }
-        else {
-            logger.success(`Exported workflow "${result.workflow}" for ${result.target}`);
-        }
-        logger.info(`done in ${t.elapsed()}`);
-    }
-    logger.newline();
-    logger.section(isDryRun ? 'Files That Would Be Generated' : 'Generated Files');
-    for (const file of result.files) {
-        logger.log(`  ${file.path}`);
-    }
-    // In dry-run mode, show a preview of the handler file
-    if (isDryRun) {
-        logger.newline();
-        logger.section('Handler Preview');
-        const handlerFile = result.files.find((f) => f.path.endsWith('handler.ts') ||
-            f.path.endsWith(`${result.workflow}.ts`) ||
-            f.path.endsWith('index.ts') ||
-            f.path.endsWith('.yml') ||
-            f.path.endsWith('.yaml'));
-        if (handlerFile) {
-            // Show first 40 lines of handler
-            const lines = handlerFile.content.split('\n');
-            const preview = lines.slice(0, 40).join('\n');
-            logger.log(preview);
-            if (lines.length > 40) {
-                logger.info(`... (${lines.length - 40} more lines)`);
-            }
-        }
-    }
-    // Show warnings about unsupported annotations
-    if (result.warnings && result.warnings.length > 0) {
-        logger.newline();
-        logger.section('Warnings');
-        for (const warning of result.warnings) {
-            logger.warn(warning);
-        }
-    }
-    // Get deploy instructions from the target
-    logger.newline();
-    logger.section('Next Steps');
-    const { createTargetRegistry } = await import('../../deployment/index.js');
-    const registry = await createTargetRegistry(process.cwd());
-    const target = registry.get(result.target);
-    if (target) {
-        // Use the target's own deploy instructions
-        const instructions = target.getDeployInstructions({
-            files: [],
-            target: result.target,
-            workflowName: result.workflow,
-            entryPoint: '',
-        });
-        for (let i = 0; i < instructions.steps.length; i++) {
-            logger.log(`  ${i + 1}. ${instructions.steps[i]}`);
-        }
-        if (instructions.prerequisites.length > 0) {
-            logger.newline();
-            logger.info(`Requires: ${instructions.prerequisites.join(', ')}`);
-        }
-    }
-    else {
-        logger.log('  See target documentation for deployment instructions.');
-    }
-}
-//# sourceMappingURL=export.js.map

package/dist/cli/commands/grammar.js

@@ -1,40 +0,0 @@
-/**
- * Grammar command - output JSDoc grammar as HTML railroad diagrams or EBNF text
- */
-import { generateGrammarDiagrams, getAllGrammars, serializedToEBNF, } from '../../chevrotain-parser/grammar-diagrams.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
-import { safeWriteFile } from '../utils/safe-write.js';
-export async function grammarCommand(options = {}) {
-    // Default to ebnf on TTY (readable in terminal), html when writing to file
-    const defaultFormat = options.output ? 'html' : (process.stdout.isTTY ? 'ebnf' : 'html');
-    const { format = defaultFormat, output } = options;
-    try {
-        let content;
-        if (format === 'ebnf') {
-            const grammars = getAllGrammars();
-            const allProductions = [
-                ...grammars.port,
-                ...grammars.node,
-                ...grammars.connect,
-                ...grammars.position,
-                ...grammars.scope,
-            ];
-            content = serializedToEBNF(allProductions);
-        }
-        else {
-            content = generateGrammarDiagrams();
-        }
-        if (output) {
-            safeWriteFile(output, content);
-            logger.success(`Grammar written to ${output}`);
-        }
-        else {
-            process.stdout.write(content);
-        }
-    }
-    catch (error) {
-        throw new Error(`Grammar generation failed: ${getErrorMessage(error)}`);
-    }
-}
-//# sourceMappingURL=grammar.js.map

package/dist/cli/commands/implement.js

@@ -1,91 +0,0 @@
-/**
- * Implement command — replaces a stub node with a real function skeleton
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { parseWorkflow } from '../../api/index.js';
-import { generateFunctionSignature } from '../../annotation-generator.js';
-import { logger } from '../utils/logger.js';
-import { getErrorMessage } from '../../utils/error-utils.js';
-import { safeWriteFile } from '../utils/safe-write.js';
-/**
- * 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 escaped = functionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const startPattern = new RegExp(`^(\\s*)declare\\s+function\\s+${escaped}\\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 async function implementCommand(input, nodeName, options = {}) {
-    const { workflowName, preview = false } = options;
-    try {
-        const filePath = path.resolve(input);
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${input}`);
-        }
-        const parseResult = await parseWorkflow(filePath, { workflowName });
-        if (parseResult.errors.length > 0) {
-            throw new Error(`Parse errors:\n${parseResult.errors.map((e) => `  ${e}`).join('\n')}`);
-        }
-        const ast = parseResult.ast;
-        // Find the stub node type
-        const stubNodeType = ast.nodeTypes.find((nt) => nt.variant === 'STUB' && (nt.functionName === nodeName || nt.name === nodeName));
-        if (!stubNodeType) {
-            const existingNt = ast.nodeTypes.find((nt) => nt.functionName === nodeName || nt.name === nodeName);
-            if (existingNt) {
-                logger.warn(`Node "${nodeName}" is already implemented.`);
-                process.exit(0);
-            }
-            const available = ast.nodeTypes
-                .filter((nt) => nt.variant === 'STUB')
-                .map((nt) => nt.functionName);
-            if (available.length === 0) {
-                throw new Error('No stub nodes found in this workflow.');
-            }
-            else {
-                throw new Error(`Stub node "${nodeName}" not found. Available stubs: ${available.join(', ')}`);
-            }
-        }
-        const source = fs.readFileSync(filePath, 'utf8');
-        const found = findDeclareFunction(source, stubNodeType.functionName);
-        if (!found) {
-            throw new Error(`Could not find "declare function ${stubNodeType.functionName}" in source file.`);
-        }
-        // Generate the real function signature
-        const implementedType = { ...stubNodeType, variant: 'FUNCTION' };
-        const signatureLines = generateFunctionSignature(implementedType);
-        const replacement = signatureLines.map((line) => found.indent + line).join('\n');
-        if (preview) {
-            logger.section(`Preview: ${stubNodeType.functionName}`);
-            logger.newline();
-            // eslint-disable-next-line no-console
-            console.log(replacement);
-        }
-        else {
-            const updated = source.replace(found.match, replacement);
-            safeWriteFile(filePath, updated);
-            logger.success(`Implemented ${stubNodeType.functionName} in ${path.basename(filePath)}`);
-        }
-    }
-    catch (error) {
-        throw new Error(`Implement failed: ${getErrorMessage(error)}`);
-    }
-}
-//# sourceMappingURL=implement.js.map