@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chevrotain-parser/connect-parser.js

@@ -1,136 +0,0 @@
-/**
- * @module chevrotain-parser/connect-parser
- *
- * Parser for @connect declarations using Chevrotain.
- */
-import { CstParser } from 'chevrotain';
-import { JSDocLexer, ConnectTag, Identifier, Arrow, Dot, Colon, AsKeyword, allTokens } from './tokens.js';
-// =============================================================================
-// Parser Definition
-// =============================================================================
-class ConnectParser extends CstParser {
-    constructor() {
-        super(allTokens);
-        this.performSelfAnalysis();
-    }
-    // Entry rule for connect line: @connect A.port -> B.port [as type]
-    connectLine = this.RULE('connectLine', () => {
-        this.CONSUME(ConnectTag);
-        this.SUBRULE(this.portRef, { LABEL: 'sourceRef' });
-        this.CONSUME(Arrow);
-        this.SUBRULE2(this.portRef, { LABEL: 'targetRef' });
-        this.OPTION(() => {
-            this.CONSUME(AsKeyword);
-            this.CONSUME(Identifier, { LABEL: 'coerceType' });
-        });
-    });
-    // node.port, node.port:scope, or pseudo-node (secret:NAME)
-    portRef = this.RULE('portRef', () => {
-        this.CONSUME(Identifier, { LABEL: 'nodeId' });
-        this.OR([
-            {
-                ALT: () => {
-                    this.CONSUME(Dot);
-                    this.CONSUME2(Identifier, { LABEL: 'portName' });
-                    this.OPTION(() => {
-                        this.CONSUME(Colon);
-                        this.CONSUME3(Identifier, { LABEL: 'scopeName' });
-                    });
-                },
-            },
-            {
-                // pseudo-node: secret:NAME (nodeId="secret", colon, pseudoName="NAME")
-                ALT: () => {
-                    this.CONSUME2(Colon, { LABEL: 'pseudoColon' });
-                    this.CONSUME4(Identifier, { LABEL: 'pseudoName' });
-                },
-            },
-        ]);
-    });
-}
-// =============================================================================
-// Parser Instance (singleton)
-// =============================================================================
-const parserInstance = new ConnectParser();
-// =============================================================================
-// CST Visitor
-// =============================================================================
-const BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
-class ConnectVisitor extends BaseVisitor {
-    constructor() {
-        super();
-        this.validateVisitor();
-    }
-    connectLine(ctx) {
-        const source = this.visit(ctx.sourceRef);
-        const target = this.visit(ctx.targetRef);
-        const result = { source, target };
-        if (ctx.coerceType?.[0]) {
-            const validTypes = new Set(['string', 'number', 'boolean', 'json', 'object']);
-            const raw = ctx.coerceType[0].image;
-            if (validTypes.has(raw)) {
-                result.coerce = raw;
-            }
-            else {
-                result.invalidCoerceType = raw;
-            }
-        }
-        return result;
-    }
-    portRef(ctx) {
-        const nodeId = ctx.nodeId[0].image;
-        // Pseudo-node branch: secret:NAME -> { nodeId: "secret:NAME", portName: "value" }
-        if (ctx.pseudoColon) {
-            const pseudoName = ctx.pseudoName[0].image;
-            return { nodeId: `${nodeId}:${pseudoName}`, portName: 'value' };
-        }
-        const portName = ctx.portName[0].image;
-        const scope = ctx.scopeName?.[0]?.image;
-        return { nodeId, portName, scope };
-    }
-}
-const visitorInstance = new ConnectVisitor();
-// =============================================================================
-// Public API
-// =============================================================================
-/**
- * Parse a @connect line and return structured result.
- * Returns null if the line is not a connect declaration.
- */
-export function parseConnectLine(input, warnings) {
-    const lexResult = JSDocLexer.tokenize(input);
-    if (lexResult.errors.length > 0) {
-        return null;
-    }
-    // Check if starts with @connect
-    if (lexResult.tokens.length === 0) {
-        return null;
-    }
-    const firstToken = lexResult.tokens[0];
-    if (firstToken.tokenType !== ConnectTag) {
-        return null;
-    }
-    parserInstance.input = lexResult.tokens;
-    const cst = parserInstance.connectLine();
-    if (parserInstance.errors.length > 0) {
-        const firstError = parserInstance.errors[0];
-        const truncatedInput = input.length > 60 ? input.substring(0, 60) + '...' : input;
-        warnings.push(`Failed to parse connect line: "${truncatedInput}"\n` +
-            `  Error: ${firstError.message}\n` +
-            `  Expected format: @connect sourceNode.port -> targetNode.port`);
-        return null;
-    }
-    const result = visitorInstance.visit(cst);
-    if (result.invalidCoerceType) {
-        warnings.push(`Invalid coerce type "${result.invalidCoerceType}" in @connect. Valid types: string, number, boolean, json, object`);
-        delete result.invalidCoerceType;
-    }
-    return result;
-}
-/**
- * Get serialized grammar for documentation/diagram generation.
- */
-export function getConnectGrammar() {
-    return parserInstance.getSerializedGastProductions();
-}
-//# sourceMappingURL=connect-parser.js.map

package/dist/chevrotain-parser/fan-parser.js

@@ -1,149 +0,0 @@
-/**
- * @module chevrotain-parser/fan-parser
- *
- * Parser for @fanOut and @fanIn sugar annotations using Chevrotain.
- *
- * Syntax:
- *   @fanOut Start.data -> a, b, c
- *   @fanOut Start.data -> a.input1, b.input2
- *   @fanIn a.result, b.result, c.result -> merge.inputs
- *   @fanIn a, b, c -> merge.data
- */
-import { CstParser } from 'chevrotain';
-import { JSDocLexer, FanOutTag, FanInTag, Identifier, Arrow, Dot, Comma, allTokens, } from './tokens.js';
-// =============================================================================
-// Parser Definition
-// =============================================================================
-class FanParser extends CstParser {
-    constructor() {
-        super(allTokens);
-        this.performSelfAnalysis();
-    }
-    // @fanOut portRef Arrow portRef (Comma portRef)*
-    fanOutLine = this.RULE('fanOutLine', () => {
-        this.CONSUME(FanOutTag);
-        this.SUBRULE(this.portRef, { LABEL: 'source' });
-        this.CONSUME(Arrow);
-        this.SUBRULE2(this.portRef, { LABEL: 'firstTarget' });
-        this.MANY(() => {
-            this.CONSUME(Comma);
-            this.SUBRULE3(this.portRef, { LABEL: 'moreTargets' });
-        });
-    });
-    // @fanIn portRef (Comma portRef)* Arrow portRef
-    // Note: Because we can't look ahead past the comma-list to the arrow,
-    // we parse as: @fanIn portRefList Arrow portRef
-    // The last element after Arrow is the target; everything before is sources.
-    fanInLine = this.RULE('fanInLine', () => {
-        this.CONSUME(FanInTag);
-        this.SUBRULE(this.portRef, { LABEL: 'firstSource' });
-        this.MANY(() => {
-            this.CONSUME(Comma);
-            this.SUBRULE2(this.portRef, { LABEL: 'moreSources' });
-        });
-        this.CONSUME(Arrow);
-        this.SUBRULE3(this.portRef, { LABEL: 'target' });
-    });
-    // portRef: Identifier (Dot Identifier)?
-    portRef = this.RULE('portRef', () => {
-        this.CONSUME(Identifier, { LABEL: 'nodeName' });
-        this.OPTION(() => {
-            this.CONSUME(Dot);
-            this.CONSUME2(Identifier, { LABEL: 'portName' });
-        });
-    });
-}
-// =============================================================================
-// Parser Instance (singleton)
-// =============================================================================
-const parserInstance = new FanParser();
-// =============================================================================
-// CST Visitor
-// =============================================================================
-const BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
-class FanVisitor extends BaseVisitor {
-    constructor() {
-        super();
-        this.validateVisitor();
-    }
-    fanOutLine(ctx) {
-        const source = this.portRef(ctx.source[0].children);
-        const targets = [];
-        targets.push(this.portRef(ctx.firstTarget[0].children));
-        if (ctx.moreTargets) {
-            for (const t of ctx.moreTargets) {
-                targets.push(this.portRef(t.children));
-            }
-        }
-        return { source, targets };
-    }
-    fanInLine(ctx) {
-        const sources = [];
-        sources.push(this.portRef(ctx.firstSource[0].children));
-        if (ctx.moreSources) {
-            for (const s of ctx.moreSources) {
-                sources.push(this.portRef(s.children));
-            }
-        }
-        const target = this.portRef(ctx.target[0].children);
-        return { sources, target };
-    }
-    portRef(ctx) {
-        const node = ctx.nodeName[0].image;
-        const port = ctx.portName?.[0]?.image;
-        return port ? { node, port } : { node };
-    }
-}
-const visitorInstance = new FanVisitor();
-// =============================================================================
-// Public API
-// =============================================================================
-/**
- * Parse a @fanOut line and return structured result.
- * Returns null if the line is not a valid @fanOut declaration.
- */
-export function parseFanOutLine(input, warnings) {
-    const lexResult = JSDocLexer.tokenize(input);
-    if (lexResult.errors.length > 0 || lexResult.tokens.length === 0)
-        return null;
-    if (lexResult.tokens[0].tokenType !== FanOutTag)
-        return null;
-    parserInstance.input = lexResult.tokens;
-    const cst = parserInstance.fanOutLine();
-    if (parserInstance.errors.length > 0) {
-        const truncatedInput = input.length > 80 ? input.substring(0, 80) + '...' : input;
-        warnings.push(`Failed to parse @fanOut line: "${truncatedInput}"\n` +
-            `  Error: ${parserInstance.errors[0].message}\n` +
-            `  Expected format: @fanOut source.port -> target1, target2, target3`);
-        return null;
-    }
-    return visitorInstance.visit(cst);
-}
-/**
- * Parse a @fanIn line and return structured result.
- * Returns null if the line is not a valid @fanIn declaration.
- */
-export function parseFanInLine(input, warnings) {
-    const lexResult = JSDocLexer.tokenize(input);
-    if (lexResult.errors.length > 0 || lexResult.tokens.length === 0)
-        return null;
-    if (lexResult.tokens[0].tokenType !== FanInTag)
-        return null;
-    parserInstance.input = lexResult.tokens;
-    const cst = parserInstance.fanInLine();
-    if (parserInstance.errors.length > 0) {
-        const truncatedInput = input.length > 80 ? input.substring(0, 80) + '...' : input;
-        warnings.push(`Failed to parse @fanIn line: "${truncatedInput}"\n` +
-            `  Error: ${parserInstance.errors[0].message}\n` +
-            `  Expected format: @fanIn source1.port, source2.port -> target.port`);
-        return null;
-    }
-    return visitorInstance.visit(cst);
-}
-/**
- * Get serialized grammar for documentation/diagram generation.
- */
-export function getFanGrammar() {
-    return parserInstance.getSerializedGastProductions();
-}
-//# sourceMappingURL=fan-parser.js.map

package/dist/chevrotain-parser/grammar-diagrams.js

@@ -1,273 +0,0 @@
-/**
- * @module chevrotain-parser/grammar-diagrams
- *
- * Generates railroad diagrams for all JSDoc grammars using Chevrotain.
- */
-import { createSyntaxDiagramsCode } from 'chevrotain';
-import { getPortGrammar } from './port-parser.js';
-import { getNodeGrammar } from './node-parser.js';
-import { getConnectGrammar } from './connect-parser.js';
-import { getPositionGrammar } from './position-parser.js';
-import { getScopeGrammar } from './scope-parser.js';
-import { getPathGrammar } from './path-parser.js';
-import { getMapGrammar } from './map-parser.js';
-import { getTriggerCancelGrammar } from './trigger-cancel-parser.js';
-import { getFanGrammar } from './fan-parser.js';
-export function serializedToEBNF(productions) {
-    const lines = [];
-    for (const prod of productions) {
-        if (prod.type === 'Rule') {
-            // Access rule properties with type assertion
-            const rule = prod;
-            if (rule.definition && rule.name) {
-                const body = definitionToEBNF(rule.definition);
-                lines.push(`${rule.name} ::= ${body}`);
-            }
-        }
-    }
-    return lines.join('\n\n');
-}
-function definitionToEBNF(definition) {
-    return definition.map((item) => itemToEBNF(item)).join(' ');
-}
-function itemToEBNF(item) {
-    switch (item.type) {
-        case 'Terminal':
-            const pattern = item.pattern || '';
-            // Show readable patterns for known tokens
-            if (pattern.startsWith('@')) {
-                return `"${pattern.replace('\\b', '')}"`;
-            }
-            // Punctuation
-            const punctuation = {
-                '->': '"->"',
-                ':': '":"',
-                ',': '","',
-                '=': '"="',
-                '-': '"-"',
-                '\\.': '"."',
-                '\\[': '"["',
-                '\\]': '"]"',
-                '\\(': '"("',
-                '\\)': '")"',
-            };
-            if (punctuation[pattern])
-                return punctuation[pattern];
-            // Keywords
-            if (pattern === 'scope:')
-                return '"scope:"';
-            if (pattern === 'order:')
-                return '"order:"';
-            if (pattern === 'placement:')
-                return '"placement:"';
-            if (pattern === 'label:')
-                return '"label:"';
-            if (pattern === 'expr:')
-                return '"expr:"';
-            if (pattern === 'portOrder:')
-                return '"portOrder:"';
-            if (pattern === 'pullExecution:')
-                return '"pullExecution:"';
-            if (pattern === 'minimized\\b')
-                return '"minimized"';
-            if (pattern === 'TOP\\b')
-                return '"TOP"';
-            if (pattern === 'BOTTOM\\b')
-                return '"BOTTOM"';
-            // Identifier pattern - use semantic name if available
-            if (pattern === '[a-zA-Z_$][a-zA-Z0-9_$]*' || pattern === '[a-zA-Z_$][a-zA-Z0-9_$\\/-]*') {
-                const semanticName = item.terminalLabel || 'IDENTIFIER';
-                return semanticName;
-            }
-            // Integer pattern
-            if (pattern === '-?\\d+') {
-                return item.terminalLabel || 'INTEGER';
-            }
-            // String literal
-            if (pattern.includes('(?:[^"\\\\]|\\\\.)*')) {
-                return item.terminalLabel || 'STRING';
-            }
-            // Fallback
-            return item.terminalLabel || item.name || 'unknown';
-        case 'NonTerminal':
-            return `<${item.name || 'unknown'}>`;
-        case 'Alternation':
-            const alts = (item.definition || []).map((alt) => {
-                if (alt.type === 'Alternative' && alt.definition) {
-                    return definitionToEBNF(alt.definition);
-                }
-                return itemToEBNF(alt);
-            });
-            return `( ${alts.join(' | ')} )`;
-        case 'Option':
-            return `[ ${definitionToEBNF(item.definition || [])} ]`;
-        case 'Repetition':
-            return `{ ${definitionToEBNF(item.definition || [])} }`;
-        case 'RepetitionMandatory':
-            return `${definitionToEBNF(item.definition || [])}+`;
-        case 'RepetitionMandatoryWithSeparator':
-            const sepName = item.separator?.name || ',';
-            return `${definitionToEBNF(item.definition || [])} { "${sepName === 'Comma' ? ',' : sepName}" ${definitionToEBNF(item.definition || [])} }`;
-        case 'RepetitionWithSeparator':
-            const sep = item.separator?.name || ',';
-            return `[ ${definitionToEBNF(item.definition || [])} { "${sep === 'Comma' ? ',' : sep}" ${definitionToEBNF(item.definition || [])} } ]`;
-        default:
-            return `/* ${item.type} */`;
-    }
-}
-// =============================================================================
-// Public API
-// =============================================================================
-/**
- * Get all grammar productions as serialized GAST (Grammar AST).
- */
-export function getAllGrammars() {
-    return {
-        port: getPortGrammar(),
-        node: getNodeGrammar(),
-        connect: getConnectGrammar(),
-        position: getPositionGrammar(),
-        scope: getScopeGrammar(),
-        path: getPathGrammar(),
-        map: getMapGrammar(),
-        fan: getFanGrammar(),
-        triggerCancel: getTriggerCancelGrammar(),
-    };
-}
-/**
- * Generate standalone HTML with railroad diagrams for all grammars.
- * Uses Chevrotain's createSyntaxDiagramsCode which returns a complete HTML page.
- */
-export function generateGrammarDiagrams() {
-    const grammars = getAllGrammars();
-    // Combine all grammars for unified diagram
-    const allProductions = [
-        ...grammars.port,
-        ...grammars.node,
-        ...grammars.connect,
-        ...grammars.position,
-        ...grammars.scope,
-        ...grammars.path,
-        ...grammars.map,
-        ...grammars.fan,
-        ...grammars.triggerCancel,
-    ];
-    // createSyntaxDiagramsCode returns a complete HTML document
-    const html = createSyntaxDiagramsCode(allProductions);
-    // Generate EBNF text
-    const ebnf = serializedToEBNF(allProductions);
-    // Inject custom styling and header into the generated HTML
-    const customStyles = `
-<style>
-  body {
-    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
-    max-width: 1400px;
-    margin: 0 auto;
-    padding: 2rem;
-    background-color: #f8f9fa !important;
-  }
-  h1.grammar-title {
-    text-align: center;
-    color: #333;
-    margin-bottom: 0.5rem;
-    font-size: 2rem;
-  }
-  .back-link {
-    display: block;
-    text-align: center;
-    margin-bottom: 2rem;
-    color: #4a90d9;
-    text-decoration: none;
-  }
-  .back-link:hover { text-decoration: underline; }
-  .tabs {
-    display: flex;
-    gap: 0;
-    margin-bottom: 0;
-    border-bottom: 2px solid #ddd;
-  }
-  .tab {
-    padding: 0.75rem 1.5rem;
-    cursor: pointer;
-    background: #e9ecef;
-    border: none;
-    border-bottom: 2px solid transparent;
-    margin-bottom: -2px;
-    font-size: 1rem;
-    color: #666;
-  }
-  .tab:hover { background: #dee2e6; }
-  .tab.active {
-    background: #fff;
-    border-bottom-color: #4a90d9;
-    color: #333;
-    font-weight: 500;
-  }
-  .tab-content { display: none; padding: 1rem 0; }
-  .tab-content.active { display: block; }
-  .ebnf-container {
-    background: #1e1e1e;
-    color: #d4d4d4;
-    padding: 1.5rem;
-    border-radius: 8px;
-    overflow-x: auto;
-    font-family: 'Fira Code', 'Consolas', monospace;
-    font-size: 0.9rem;
-    line-height: 1.6;
-    white-space: pre-wrap;
-  }
-  .ebnf-container .rule-name { color: #569cd6; }
-  .ebnf-container .terminal { color: #ce9178; }
-  .ebnf-container .nonterminal { color: #4ec9b0; }
-  .ebnf-container .operator { color: #d4d4d4; }
-</style>
-`;
-    // Escape HTML first, then apply syntax highlighting
-    const escaped = ebnf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-    // Use placeholders to avoid regex conflicts
-    const ebnfHtml = escaped
-        .replace(/"([^"]+)"/g, '___TERM_START___$1___TERM_END___')
-        .replace(/&lt;(\w+)&gt;/g, '___NT_START___$1___NT_END___')
-        .replace(/^(\w+)\s*::=/gm, '___RULE_START___$1___RULE_END___ ::=')
-        .replace(/___TERM_START___/g, '<span class="terminal">"')
-        .replace(/___TERM_END___/g, '"</span>')
-        .replace(/___NT_START___/g, '<span class="nonterminal">&lt;')
-        .replace(/___NT_END___/g, '&gt;</span>')
-        .replace(/___RULE_START___/g, '<span class="rule-name">')
-        .replace(/___RULE_END___/g, '</span>');
-    const header = `
-<h1 class="grammar-title">Flow Weaver JSDoc Grammar</h1>
-<a href="index.html" class="back-link">← Back to API Documentation</a>
-<div class="tabs">
-  <button class="tab active" onclick="showTab('diagrams')">Railroad Diagrams</button>
-  <button class="tab" onclick="showTab('ebnf')">EBNF Text</button>
-</div>
-<div id="ebnf" class="tab-content">
-  <div class="ebnf-container">${ebnfHtml}</div>
-</div>
-<script>
-function showTab(id) {
-  document.querySelectorAll('.tab-content').forEach(el => el.classList.remove('active'));
-  document.querySelectorAll('.tab').forEach(el => el.classList.remove('active'));
-  document.getElementById(id).classList.add('active');
-  event.target.classList.add('active');
-}
-</script>
-`;
-    // Insert styles after existing style block, header before diagrams
-    return html
-        .replace('</style>', `</style>${customStyles}`)
-        .replace('<div id="diagrams"', `${header}<div id="diagrams" class="tab-content active"`);
-}
-/**
- * Generate diagram HTML for a specific grammar.
- */
-export function generateGrammarDiagramFor(grammarName) {
-    const grammars = getAllGrammars();
-    const grammar = grammars[grammarName];
-    const html = createSyntaxDiagramsCode(grammar);
-    const title = grammarName.charAt(0).toUpperCase() + grammarName.slice(1);
-    const header = `<h1 style="text-align:center;color:#333">${title} Grammar</h1>`;
-    return html.replace('<div id="diagrams"', `${header}<div id="diagrams"`);
-}
-//# sourceMappingURL=grammar-diagrams.js.map

package/dist/chevrotain-parser/index.js

@@ -1,31 +0,0 @@
-/**
- * @module chevrotain-parser
- *
- * Chevrotain-based parsers for JSDoc annotations.
- * Provides structured parsing for @input, @output, @node, @connect, and @position.
- */
-// Token exports (for advanced use cases)
-export { JSDocLexer, allTokens, InputTag, OutputTag, NodeTag, ConnectTag, PositionTag, ScopeTag, MapTag, PathTag, FanOutTag, FanInTag, CoerceTag, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, } from './tokens.js';
-// Port parser
-export { parsePortLine, getPortGrammar } from './port-parser.js';
-// Node parser
-export { parseNodeLine, getNodeGrammar } from './node-parser.js';
-// Connect parser
-export { parseConnectLine, getConnectGrammar } from './connect-parser.js';
-// Position parser
-export { parsePositionLine, getPositionGrammar } from './position-parser.js';
-// Scope parser
-export { parseScopeLine, getScopeGrammar } from './scope-parser.js';
-// Map parser
-export { parseMapLine, getMapGrammar } from './map-parser.js';
-// Path parser
-export { parsePathLine, getPathGrammar } from './path-parser.js';
-// Fan-out / Fan-in parser
-export { parseFanOutLine, parseFanInLine } from './fan-parser.js';
-// Coerce parser
-export { parseCoerceLine } from './coerce-parser.js';
-// Trigger/cancel/retries/timeout/throttle parser
-export { parseTriggerLine, parseCancelOnLine, parseRetriesLine, parseTimeoutLine, parseThrottleLine } from './trigger-cancel-parser.js';
-// Grammar diagram generation
-export { generateGrammarDiagrams, getAllGrammars, serializedToEBNF } from './grammar-diagrams.js';
-//# sourceMappingURL=index.js.map