@synergenius/flow-weaver 0.2.0

package/dist/server/workflow-registry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Workflow registry for discovering and managing workflow endpoints
+ */
+import type { WorkflowEndpoint } from './types.js';
+/**
+ * Registry that discovers, caches, and manages workflow endpoints
+ */
+export declare class WorkflowRegistry {
+    private workflowDir;
+    private options;
+    private endpoints;
+    private watcher;
+    private debounceTimers;
+    private parser;
+    private startTime;
+    constructor(workflowDir: string, options?: {
+        precompile?: boolean;
+        production?: boolean;
+    });
+    /**
+     * Initialize the registry by discovering all workflows
+     */
+    initialize(): Promise<void>;
+    /**
+     * Discover all workflow files in the configured directory
+     */
+    discoverWorkflows(): Promise<void>;
+    /**
+     * Extract JSON Schema for workflow input ports
+     */
+    private extractInputSchema;
+    /**
+     * Extract JSON Schema for workflow output ports
+     */
+    private extractOutputSchema;
+    /**
+     * Convert Flow Weaver data type to JSON Schema type
+     */
+    private dataTypeToJsonSchema;
+    /**
+     * Get a specific endpoint by workflow name
+     */
+    getEndpoint(name: string): WorkflowEndpoint | undefined;
+    /**
+     * Get all registered endpoints
+     */
+    getAllEndpoints(): WorkflowEndpoint[];
+    /**
+     * Get server uptime in seconds
+     */
+    getUptime(): number;
+    /**
+     * Start watching for file changes
+     */
+    startWatching(onChange: () => void): Promise<void>;
+    /**
+     * Stop watching for file changes
+     */
+    stopWatching(): Promise<void>;
+}
+//# sourceMappingURL=workflow-registry.d.ts.map

package/dist/server/workflow-registry.js

@@ -0,0 +1,202 @@
+/**
+ * Workflow registry for discovering and managing workflow endpoints
+ */
+import * as fs from 'fs';
+import { glob } from 'glob';
+import { AnnotationParser } from '../parser.js';
+/**
+ * Registry that discovers, caches, and manages workflow endpoints
+ */
+export class WorkflowRegistry {
+    workflowDir;
+    options;
+    endpoints = new Map();
+    watcher = null;
+    debounceTimers = new Map();
+    parser = new AnnotationParser();
+    startTime = Date.now();
+    constructor(workflowDir, options = {}) {
+        this.workflowDir = workflowDir;
+        this.options = options;
+    }
+    /**
+     * Initialize the registry by discovering all workflows
+     */
+    async initialize() {
+        await this.discoverWorkflows();
+    }
+    /**
+     * Discover all workflow files in the configured directory
+     */
+    async discoverWorkflows() {
+        const files = await glob('**/*.ts', {
+            cwd: this.workflowDir,
+            absolute: true,
+            ignore: [
+                '**/*.generated.ts',
+                '**/node_modules/**',
+                '**/*.d.ts',
+                '**/*.test.ts',
+                '**/*.spec.ts',
+            ],
+        });
+        this.endpoints.clear();
+        for (const file of files) {
+            try {
+                // Quick check for @flowWeaver annotation before parsing
+                const content = fs.readFileSync(file, 'utf8');
+                if (!content.includes('@flowWeaver')) {
+                    continue;
+                }
+                const result = this.parser.parse(file);
+                for (const workflow of result.workflows) {
+                    const endpoint = {
+                        name: workflow.name,
+                        functionName: workflow.functionName,
+                        filePath: file,
+                        method: 'POST',
+                        path: `/workflows/${workflow.name}`,
+                        inputSchema: this.extractInputSchema(workflow),
+                        outputSchema: this.extractOutputSchema(workflow),
+                        description: workflow.description,
+                    };
+                    this.endpoints.set(workflow.name, endpoint);
+                }
+            }
+            catch {
+                // Skip files that fail to parse - they may have syntax errors
+                // In a server context, we don't want one bad file to break everything
+            }
+        }
+    }
+    /**
+     * Extract JSON Schema for workflow input ports
+     */
+    extractInputSchema(workflow) {
+        const schema = {
+            type: 'object',
+            properties: {},
+        };
+        const required = [];
+        for (const [portName, port] of Object.entries(workflow.startPorts || {})) {
+            // Skip the execute port - it's internal
+            if (portName === 'execute')
+                continue;
+            schema.properties[portName] = {
+                type: this.dataTypeToJsonSchema(port.dataType),
+                ...(port.label && { description: port.label }),
+            };
+            if (!port.optional) {
+                required.push(portName);
+            }
+        }
+        if (required.length > 0) {
+            schema.required = required;
+        }
+        return schema;
+    }
+    /**
+     * Extract JSON Schema for workflow output ports
+     */
+    extractOutputSchema(workflow) {
+        const schema = {
+            type: 'object',
+            properties: {},
+        };
+        for (const [portName, port] of Object.entries(workflow.exitPorts || {})) {
+            // Skip control flow ports
+            if (portName === 'onSuccess' || portName === 'onFailure')
+                continue;
+            schema.properties[portName] = {
+                type: this.dataTypeToJsonSchema(port.dataType),
+                ...(port.label && { description: port.label }),
+            };
+        }
+        return schema;
+    }
+    /**
+     * Convert Flow Weaver data type to JSON Schema type
+     */
+    dataTypeToJsonSchema(dataType) {
+        const mapping = {
+            STRING: 'string',
+            NUMBER: 'number',
+            BOOLEAN: 'boolean',
+            OBJECT: 'object',
+            ARRAY: 'array',
+            ANY: 'any',
+            STEP: 'boolean',
+        };
+        return mapping[dataType] || 'any';
+    }
+    /**
+     * Get a specific endpoint by workflow name
+     */
+    getEndpoint(name) {
+        return this.endpoints.get(name);
+    }
+    /**
+     * Get all registered endpoints
+     */
+    getAllEndpoints() {
+        return Array.from(this.endpoints.values());
+    }
+    /**
+     * Get server uptime in seconds
+     */
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime) / 1000);
+    }
+    /**
+     * Start watching for file changes
+     */
+    async startWatching(onChange) {
+        try {
+            const chokidar = await import('chokidar');
+            const watcher = chokidar.watch(this.workflowDir, {
+                persistent: true,
+                ignoreInitial: true,
+                ignored: ['**/*.generated.ts', '**/node_modules/**', '**/*.d.ts'],
+                awaitWriteFinish: {
+                    stabilityThreshold: 300,
+                    pollInterval: 100,
+                },
+            });
+            this.watcher = watcher;
+            watcher.on('all', (event, filePath) => {
+                if (!filePath.endsWith('.ts'))
+                    return;
+                // Debounce changes to avoid rapid re-parsing
+                const existingTimer = this.debounceTimers.get(filePath);
+                if (existingTimer) {
+                    clearTimeout(existingTimer);
+                }
+                const timer = setTimeout(async () => {
+                    this.debounceTimers.delete(filePath);
+                    await this.discoverWorkflows();
+                    onChange();
+                }, 500);
+                this.debounceTimers.set(filePath, timer);
+            });
+        }
+        catch {
+            // File watching not available (chokidar not installed)
+        }
+    }
+    /**
+     * Stop watching for file changes
+     */
+    async stopWatching() {
+        // Clear all pending timers
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        // Close watcher
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+    }
+}
+//# sourceMappingURL=workflow-registry.js.map

package/dist/shared-project.d.ts

@@ -0,0 +1,9 @@
+import { Project } from 'ts-morph';
+export declare function getSharedProject(): Project;
+/**
+ * Reset the shared project. Intended for test teardown or
+ * extreme memory-pressure scenarios. After calling this,
+ * the next getSharedProject() call will create a fresh instance.
+ */
+export declare function resetSharedProject(): void;
+//# sourceMappingURL=shared-project.d.ts.map

package/dist/shared-project.js

@@ -0,0 +1,28 @@
+import { Project } from 'ts-morph';
+// Consolidated singleton ts-morph Project.
+// Creating a Project is expensive (~2-3s), so we reuse one across all consumers.
+let sharedProject = null;
+export function getSharedProject() {
+    if (!sharedProject) {
+        sharedProject = new Project({
+            skipFileDependencyResolution: true, // Parser handles imports manually — no need for ts-morph to resolve
+            compilerOptions: {
+                target: 99,
+                experimentalDecorators: true,
+                allowJs: true,
+                types: [], // Don't auto-load @types/* packages — saves Program creation time
+                skipLibCheck: true, // Skip diagnostic checking of .d.ts files
+            },
+        });
+    }
+    return sharedProject;
+}
+/**
+ * Reset the shared project. Intended for test teardown or
+ * extreme memory-pressure scenarios. After calling this,
+ * the next getSharedProject() call will create a fresh instance.
+ */
+export function resetSharedProject() {
+    sharedProject = null;
+}
+//# sourceMappingURL=shared-project.js.map

package/dist/sugar-optimizer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Sugar Optimizer - Auto-detect @path routes from connections.
+ *
+ * Analyzes control-flow connections and identifies routes through the graph
+ * that can be expressed as @path macros. @connect is the escape hatch for
+ * connections that @path can't cover.
+ */
+import type { TConnectionAST, TNodeInstanceAST, TNodeTypeAST, TWorkflowMacro, TPathMacro, TPortDefinition } from './ast/types.js';
+export interface DetectedSugar {
+    paths: TPathMacro[];
+}
+/**
+ * Validate that a @path macro's control-flow connections still exist
+ * in the actual connection set. Also checks that all step nodes exist
+ * as instances (or are Start/Exit).
+ *
+ * Returns true if the path is still valid, false if it should be dropped.
+ */
+export declare function validatePathMacro(path: TPathMacro, connections: TConnectionAST[], instances: TNodeInstanceAST[]): boolean;
+/**
+ * Filter existing macros, removing any @path macros whose control-flow
+ * connections no longer exist in the connection set.
+ * Non-path macros are passed through unchanged.
+ */
+export declare function filterStaleMacros(macros: TWorkflowMacro[], connections: TConnectionAST[], instances: TNodeInstanceAST[]): TWorkflowMacro[];
+/**
+ * Detect @path routes from a set of connections.
+ *
+ * Algorithm:
+ * 1. Build control-flow adjacency from unscoped connections
+ * 2. DFS from Start to enumerate all Start-to-Exit routes
+ * 3. Validate data connections for each candidate (scope walking safety)
+ * 4. Greedy route selection to cover all control-flow edges
+ */
+export declare function detectSugarPatterns(connections: TConnectionAST[], instances: TNodeInstanceAST[], existingMacros: TWorkflowMacro[], nodeTypes: TNodeTypeAST[], startPorts: Record<string, TPortDefinition>, exitPorts: Record<string, TPortDefinition>): DetectedSugar;
+/**
+ * Check if a connection is covered by detected sugar and should be omitted from @connect output.
+ */
+export declare function isConnectionCoveredBySugar(conn: TConnectionAST, sugar: DetectedSugar): boolean;
+//# sourceMappingURL=sugar-optimizer.d.ts.map