@synergenius/flow-weaver 0.2.0

package/dist/chevrotain-parser/trigger-cancel-parser.js

@@ -0,0 +1,282 @@
+/**
+ * @module chevrotain-parser/trigger-cancel-parser
+ *
+ * Shared Chevrotain parser for @trigger, @cancelOn, @retries, @timeout, @throttle annotations.
+ */
+import { CstParser } from 'chevrotain';
+import { JSDocLexer, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, EventEq, CronEq, MatchEq, TimeoutEq, LimitEq, PeriodEq, StringLiteral, Integer, allTokens, } from './tokens.js';
+// =============================================================================
+// Helpers
+// =============================================================================
+function stripQuotes(s) {
+    if (s.startsWith('"') && s.endsWith('"')) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+const CRON_REGEX = /^(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)$/;
+// =============================================================================
+// Parser Definition
+// =============================================================================
+class TriggerCancelParser extends CstParser {
+    constructor() {
+        super(allTokens);
+        this.performSelfAnalysis();
+    }
+    // @trigger event="agent/request" cron="0 9 * * *"
+    triggerLine = this.RULE('triggerLine', () => {
+        this.CONSUME(TriggerTag);
+        this.MANY(() => {
+            this.OR([
+                { ALT: () => {
+                        this.CONSUME(EventEq);
+                        this.CONSUME(StringLiteral, { LABEL: 'eventValue' });
+                    } },
+                { ALT: () => {
+                        this.CONSUME(CronEq);
+                        this.CONSUME2(StringLiteral, { LABEL: 'cronValue' });
+                    } },
+            ]);
+        });
+    });
+    // @cancelOn event="app/user.deleted" match="data.userId" timeout="1h"
+    cancelOnLine = this.RULE('cancelOnLine', () => {
+        this.CONSUME(CancelOnTag);
+        this.CONSUME(EventEq);
+        this.CONSUME(StringLiteral, { LABEL: 'eventValue' });
+        this.OPTION(() => {
+            this.CONSUME(MatchEq);
+            this.CONSUME2(StringLiteral, { LABEL: 'matchValue' });
+        });
+        this.OPTION2(() => {
+            this.CONSUME(TimeoutEq);
+            this.CONSUME3(StringLiteral, { LABEL: 'timeoutValue' });
+        });
+    });
+    // @retries 5
+    retriesLine = this.RULE('retriesLine', () => {
+        this.CONSUME(RetriesTag);
+        this.CONSUME(Integer, { LABEL: 'retriesValue' });
+    });
+    // @timeout "30m"
+    timeoutLine = this.RULE('timeoutLine', () => {
+        this.CONSUME(TimeoutTag);
+        this.CONSUME(StringLiteral, { LABEL: 'timeoutValue' });
+    });
+    // @throttle limit=3 period="1m"
+    throttleLine = this.RULE('throttleLine', () => {
+        this.CONSUME(ThrottleTag);
+        this.CONSUME(LimitEq);
+        this.CONSUME(Integer, { LABEL: 'limitValue' });
+        this.OPTION(() => {
+            this.CONSUME(PeriodEq);
+            this.CONSUME(StringLiteral, { LABEL: 'periodValue' });
+        });
+    });
+}
+// =============================================================================
+// Parser Instance (singleton)
+// =============================================================================
+const parserInstance = new TriggerCancelParser();
+// =============================================================================
+// CST Visitor
+// =============================================================================
+const BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
+class TriggerCancelVisitor extends BaseVisitor {
+    constructor() {
+        super();
+        this.validateVisitor();
+    }
+    triggerLine(ctx) {
+        const result = {};
+        if (ctx.eventValue?.[0]) {
+            result.event = stripQuotes(ctx.eventValue[0].image);
+        }
+        if (ctx.cronValue?.[0]) {
+            result.cron = stripQuotes(ctx.cronValue[0].image);
+        }
+        return result;
+    }
+    cancelOnLine(ctx) {
+        const result = {
+            event: stripQuotes(ctx.eventValue[0].image),
+        };
+        if (ctx.matchValue?.[0]) {
+            result.match = stripQuotes(ctx.matchValue[0].image);
+        }
+        if (ctx.timeoutValue?.[0]) {
+            result.timeout = stripQuotes(ctx.timeoutValue[0].image);
+        }
+        return result;
+    }
+    retriesLine(ctx) {
+        return { retries: parseInt(ctx.retriesValue[0].image, 10) };
+    }
+    timeoutLine(ctx) {
+        return { timeout: stripQuotes(ctx.timeoutValue[0].image) };
+    }
+    throttleLine(ctx) {
+        const result = {
+            limit: parseInt(ctx.limitValue[0].image, 10),
+        };
+        if (ctx.periodValue?.[0]) {
+            result.period = stripQuotes(ctx.periodValue[0].image);
+        }
+        return result;
+    }
+}
+const visitorInstance = new TriggerCancelVisitor();
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Parse a @trigger line and return structured result.
+ * Returns null if the line is not a trigger declaration.
+ */
+export function parseTriggerLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0) {
+        return null;
+    }
+    if (lexResult.tokens.length === 0) {
+        return null;
+    }
+    const firstToken = lexResult.tokens[0];
+    if (firstToken.tokenType !== TriggerTag) {
+        return null;
+    }
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.triggerLine();
+    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 trigger line: "${truncatedInput}"\n` +
+            `  Error: ${firstError.message}\n` +
+            `  Expected format: @trigger event="name" or @trigger cron="expr"`);
+        return null;
+    }
+    const result = visitorInstance.visit(cst);
+    // Validate cron expression
+    if (result.cron && !CRON_REGEX.test(result.cron)) {
+        warnings.push(`Invalid cron expression: "${result.cron}". Expected 5 fields (minute hour day month weekday).`);
+    }
+    return result;
+}
+/**
+ * Parse a @cancelOn line and return structured result.
+ * Returns null if the line is not a cancelOn declaration.
+ */
+export function parseCancelOnLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0) {
+        return null;
+    }
+    if (lexResult.tokens.length === 0) {
+        return null;
+    }
+    const firstToken = lexResult.tokens[0];
+    if (firstToken.tokenType !== CancelOnTag) {
+        return null;
+    }
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.cancelOnLine();
+    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 cancelOn line: "${truncatedInput}"\n` +
+            `  Error: ${firstError.message}\n` +
+            `  Expected format: @cancelOn event="name" match="field" timeout="duration"`);
+        return null;
+    }
+    return visitorInstance.visit(cst);
+}
+/**
+ * Parse a @retries line and return structured result.
+ * Returns null if the line is not a retries declaration.
+ */
+export function parseRetriesLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0) {
+        return null;
+    }
+    if (lexResult.tokens.length === 0) {
+        return null;
+    }
+    const firstToken = lexResult.tokens[0];
+    if (firstToken.tokenType !== RetriesTag) {
+        return null;
+    }
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.retriesLine();
+    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 retries line: "${truncatedInput}"\n` +
+            `  Error: ${firstError.message}\n` +
+            `  Expected format: @retries <integer>`);
+        return null;
+    }
+    const result = visitorInstance.visit(cst);
+    // Validate non-negative
+    if (result.retries < 0) {
+        warnings.push(`Invalid @retries value: ${result.retries}. Expected non-negative integer.`);
+    }
+    return result;
+}
+/**
+ * Parse a @timeout line and return structured result.
+ * Returns null if the line is not a timeout declaration.
+ */
+export function parseTimeoutLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0) {
+        return null;
+    }
+    if (lexResult.tokens.length === 0) {
+        return null;
+    }
+    const firstToken = lexResult.tokens[0];
+    if (firstToken.tokenType !== TimeoutTag) {
+        return null;
+    }
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.timeoutLine();
+    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 timeout line: "${truncatedInput}"\n` +
+            `  Error: ${firstError.message}\n` +
+            `  Expected format: @timeout "duration"`);
+        return null;
+    }
+    return visitorInstance.visit(cst);
+}
+/**
+ * Parse a @throttle line and return structured result.
+ * Returns null if the line is not a throttle declaration.
+ */
+export function parseThrottleLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0) {
+        return null;
+    }
+    if (lexResult.tokens.length === 0) {
+        return null;
+    }
+    const firstToken = lexResult.tokens[0];
+    if (firstToken.tokenType !== ThrottleTag) {
+        return null;
+    }
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.throttleLine();
+    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 throttle line: "${truncatedInput}"\n` +
+            `  Error: ${firstError.message}\n` +
+            `  Expected format: @throttle limit=<number> period="duration"`);
+        return null;
+    }
+    return visitorInstance.visit(cst);
+}
+//# sourceMappingURL=trigger-cancel-parser.js.map

package/dist/cli/commands/changelog.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Changelog command - generates changelog from git history
+ *
+ * Categorizes commits by changed file paths — no conventional commits needed.
+ * Works with any commit message style.
+ */
+export interface ChangelogOptions {
+    lastTag?: boolean;
+    since?: string;
+    range?: string;
+}
+export declare function changelogCommand(options?: ChangelogOptions): Promise<void>;
+//# sourceMappingURL=changelog.d.ts.map

package/dist/cli/commands/changelog.js

@@ -0,0 +1,135 @@
+/**
+ * Changelog command - generates changelog from git history
+ *
+ * Categorizes commits by changed file paths — no conventional commits needed.
+ * Works with any commit message style.
+ */
+import { execSync } from 'child_process';
+import { logger } from '../utils/logger.js';
+const CATEGORIES = [
+    { name: 'Grammar', match: (f) => /parser|chevrotain|grammar/.test(f) },
+    { name: 'Code Generation', match: (f) => /generator|body-generator|generate/.test(f) },
+    { name: 'Differ', match: (f) => f.includes('diff/') },
+    { name: 'CLI', match: (f) => f.includes('cli/commands/') },
+    { name: 'MCP Tools', match: (f) => f.includes('mcp/') },
+    { name: 'Deployment', match: (f) => /deployment|export/.test(f) },
+    { name: 'Runtime', match: (f) => f.includes('runtime/') },
+    { name: 'Migration', match: (f) => f.includes('migration/') },
+    { name: 'Tests', match: (f) => f.includes('tests/') || f.includes('.test.') },
+    { name: 'Documentation', match: (f) => /doc|readme|changelog/i.test(f) },
+];
+function categorize(files) {
+    for (const category of CATEGORIES) {
+        if (files.some(category.match)) {
+            return category.name;
+        }
+    }
+    return 'Other';
+}
+function getGitRange(options) {
+    if (options.range) {
+        return options.range;
+    }
+    if (options.lastTag) {
+        try {
+            const lastTag = execSync('git describe --tags --abbrev=0', {
+                encoding: 'utf8',
+            }).trim();
+            return `${lastTag}..HEAD`;
+        }
+        catch {
+            logger.warn('No git tags found, showing all commits');
+            return 'HEAD';
+        }
+    }
+    if (options.since) {
+        return `--since="${options.since}"`;
+    }
+    // Default: last 20 commits
+    return '-20';
+}
+function getCommits(rangeArg) {
+    const isSinceArg = rangeArg.startsWith('--since');
+    const isCountArg = rangeArg.startsWith('-');
+    let logCmd;
+    if (isSinceArg) {
+        logCmd = `git log ${rangeArg} --format="%H %s" --no-merges`;
+    }
+    else if (isCountArg) {
+        logCmd = `git log ${rangeArg} --format="%H %s" --no-merges`;
+    }
+    else {
+        logCmd = `git log ${rangeArg} --format="%H %s" --no-merges`;
+    }
+    const logOutput = execSync(logCmd, { encoding: 'utf8' }).trim();
+    if (!logOutput) {
+        return [];
+    }
+    const entries = [];
+    for (const line of logOutput.split('\n')) {
+        if (!line.trim())
+            continue;
+        const spaceIdx = line.indexOf(' ');
+        const hash = line.slice(0, spaceIdx);
+        const message = line.slice(spaceIdx + 1);
+        // Get changed files for this commit
+        let files;
+        try {
+            const filesOutput = execSync(`git diff-tree --no-commit-id --name-only -r ${hash}`, {
+                encoding: 'utf8',
+            }).trim();
+            files = filesOutput ? filesOutput.split('\n') : [];
+        }
+        catch {
+            files = [];
+        }
+        entries.push({ hash: hash.slice(0, 7), message, files });
+    }
+    return entries;
+}
+export async function changelogCommand(options = {}) {
+    const rangeArg = getGitRange(options);
+    const rangeLabel = options.range || (options.lastTag ? 'last tag' : options.since ? `since ${options.since}` : 'recent');
+    const commits = getCommits(rangeArg);
+    if (commits.length === 0) {
+        logger.info('No commits found in the specified range.');
+        return;
+    }
+    // Group by category
+    const grouped = new Map();
+    for (const commit of commits) {
+        const category = categorize(commit.files);
+        if (!grouped.has(category)) {
+            grouped.set(category, []);
+        }
+        grouped.get(category).push(commit);
+    }
+    // Output as markdown
+    // eslint-disable-next-line no-console
+    console.log(`## Changes (${rangeLabel})\n`);
+    // Sort categories: defined order first, then "Other"
+    const categoryOrder = CATEGORIES.map((c) => c.name);
+    const sortedCategories = [...grouped.keys()].sort((a, b) => {
+        const idxA = categoryOrder.indexOf(a);
+        const idxB = categoryOrder.indexOf(b);
+        if (idxA === -1 && idxB === -1)
+            return a.localeCompare(b);
+        if (idxA === -1)
+            return 1;
+        if (idxB === -1)
+            return -1;
+        return idxA - idxB;
+    });
+    for (const category of sortedCategories) {
+        const categoryCommits = grouped.get(category);
+        // eslint-disable-next-line no-console
+        console.log(`### ${category} (${categoryCommits.length} commit${categoryCommits.length !== 1 ? 's' : ''})\n`);
+        for (const commit of categoryCommits) {
+            // eslint-disable-next-line no-console
+            console.log(`- ${commit.hash} ${commit.message}`);
+        }
+        // eslint-disable-next-line no-console
+        console.log('');
+    }
+}
+//# sourceMappingURL=changelog.js.map

package/dist/cli/commands/compile.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Compile command - compiles workflow files to TypeScript
+ */
+export interface CompileOptions {
+    output?: string;
+    production?: boolean;
+    sourceMap?: boolean;
+    strict?: boolean;
+    verbose?: boolean;
+    workflowName?: string;
+    dryRun?: boolean;
+    /**
+     * Module format for generated code.
+     * - 'esm': ECMAScript modules (import/export)
+     * - 'cjs': CommonJS modules (require/module.exports)
+     * - 'auto': Auto-detect from project's package.json (default)
+     */
+    format?: 'esm' | 'cjs' | 'auto';
+    /**
+     * Force inline runtime even when @synergenius/flow-weaver package is installed.
+     * By default, the compiler uses external runtime imports when the package is available.
+     */
+    inlineRuntime?: boolean;
+    /**
+     * Omit redundant @param/@returns annotations from compiled output.
+     * Useful for vibe coders who don't use the visual editor.
+     */
+    clean?: boolean;
+    /**
+     * Compilation target.
+     * - 'typescript' (default): Standard in-place compilation
+     * - 'inngest': Generate Inngest function with per-node step.run() for durability
+     */
+    target?: 'typescript' | 'inngest';
+    /** Override @trigger cron from CLI (Inngest target only) */
+    cron?: string;
+    /** Generate serve() handler */
+    serve?: boolean;
+    /** Framework adapter for serve handler */
+    framework?: 'next' | 'express' | 'hono' | 'fastify' | 'remix';
+    /** Generate Zod event schemas from @param annotations */
+    typedEvents?: boolean;
+    /** Override @retries from CLI */
+    retries?: number;
+    /** Override @timeout from CLI */
+    timeout?: string;
+}
+export declare function compileCommand(input: string, options?: CompileOptions): Promise<void>;
+/**
+ * Compile a workflow file to Inngest function code with per-node step.run().
+ */
+export declare function compileInngestTarget(input: string, options: {
+    production: boolean;
+    verbose?: boolean;
+    workflowName?: string;
+    dryRun?: boolean;
+    cron?: string;
+    serve?: boolean;
+    framework?: 'next' | 'express' | 'hono' | 'fastify' | 'remix';
+    typedEvents?: boolean;
+    retries?: number;
+    timeout?: string;
+}): Promise<void>;
+//# sourceMappingURL=compile.d.ts.map