@synergenius/flow-weaver 0.30.5 → 0.30.7

package/dist/cli/flow-weaver.mjs

@@ -5987,7 +5987,7 @@ var VERSION;
 var init_generated_version = __esm({
   "src/generated-version.ts"() {
     "use strict";
-    VERSION = "0.30.5";
+    VERSION = "0.30.7";
   }
 });
 
@@ -88935,7 +88935,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.30.5" : "0.0.0-dev";
+var version2 = true ? "0.30.7" : "0.0.0-dev";
 var program2 = new Command();
 program2.name("fw").description("Flow Weaver Annotations - Compile and validate workflow files").option("-v, --version", "Output the current version").option("--no-color", "Disable colors").option("--color", "Force colors").on("option:version", () => {
   logger.banner(version2);

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.30.5";
+export declare const VERSION = "0.30.7";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.30.5';
+export const VERSION = '0.30.7';
 //# sourceMappingURL=generated-version.js.map

package/dist/npm-packages.d.ts

@@ -15,6 +15,8 @@ export type TNpmPackagePort = {
     type: TDataType;
     direction: 'INPUT' | 'OUTPUT';
     scope?: string;
+    defaultOrder?: number;
+    failure?: boolean;
 };
 /**
  * Node type for npm package functions
@@ -46,12 +48,16 @@ export declare function getTypedPackages(workdir: string, nodeModulesOverride?:
     }>;
 };
 /**
- * Get function exports from a package's .d.ts file and return as TNodeType[].
+ * Get callable exports from a package's .d.ts file and return as TNodeType[].
+ *
+ * Uses ts-morph's symbol-based export enumeration to handle all export
+ * patterns: declare function, declare const with function types,
+ * re-exports from submodules, star exports, etc.
  *
  * @param packageName - The npm package name
  * @param workdir - Directory to start searching from
  * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
- * @returns Array of node types for the package's exported functions
+ * @returns Array of node types for the package's callable exports
  */
 export declare function getPackageExports(packageName: string, workdir: string, nodeModulesOverride?: string): TNpmNodeType[];
 //# sourceMappingURL=npm-packages.d.ts.map

package/dist/npm-packages.js

@@ -115,6 +115,7 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
         reference: 'execute',
         type: 'STEP',
         direction: 'INPUT',
+        defaultOrder: 0,
     });
     // Infer inputs from parameters
     for (const param of fn.getParameters()) {
@@ -184,6 +185,7 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
         reference: 'onSuccess',
         type: 'STEP',
         direction: 'OUTPUT',
+        defaultOrder: 100,
     });
     ports.push({
         name: 'onFailure',
@@ -191,6 +193,8 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
         reference: 'onFailure',
         type: 'STEP',
         direction: 'OUTPUT',
+        defaultOrder: 101,
+        failure: true,
     });
     return {
         name: `npm/${packageName}/${fnName}`,
@@ -205,12 +209,16 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
     };
 }
 /**
- * Get function exports from a package's .d.ts file and return as TNodeType[].
+ * Get callable exports from a package's .d.ts file and return as TNodeType[].
+ *
+ * Uses ts-morph's symbol-based export enumeration to handle all export
+ * patterns: declare function, declare const with function types,
+ * re-exports from submodules, star exports, etc.
  *
  * @param packageName - The npm package name
  * @param workdir - Directory to start searching from
  * @param nodeModulesOverride - Optional explicit node_modules path (for testing)
- * @returns Array of node types for the package's exported functions
+ * @returns Array of node types for the package's callable exports
  */
 export function getPackageExports(packageName, workdir, nodeModulesOverride) {
     const typesPath = resolvePackageTypesPath(packageName, workdir, nodeModulesOverride);
@@ -220,25 +228,194 @@ export function getPackageExports(packageName, workdir, nodeModulesOverride) {
     try {
         const project = getSharedProject();
         const dtsContent = fs.readFileSync(typesPath, 'utf-8');
-        // Create source file with unique path to avoid conflicts
-        const virtualPath = `__npm_exports__/${packageName}/${Date.now()}.d.ts`;
-        const dtsFile = project.createSourceFile(virtualPath, dtsContent, { overwrite: true });
-        const functions = extractFunctionLikes(dtsFile);
+        // Add the .d.ts file and nearby declaration files to the project so
+        // ts-morph can resolve re-exports (including `export * from './submodule'`).
+        const pkgDir = path.dirname(typesPath);
+        const addedFiles = [];
+        try {
+            const globPattern = path.join(pkgDir, '**/*.d.{ts,cts,mts}');
+            for (const file of project.addSourceFilesAtPaths(globPattern)) {
+                addedFiles.push(file.getFilePath());
+            }
+        }
+        catch {
+            // Glob may fail on some filesystems; fall back to single file
+        }
+        let dtsFile = project.getSourceFile(typesPath);
+        if (!dtsFile) {
+            dtsFile = project.addSourceFileAtPath(typesPath);
+        }
         const nodeTypes = [];
         const seenFunctionNames = new Set();
-        for (const fn of functions) {
-            const fnName = fn.getName();
-            // Skip duplicates (can happen with re-exports or declaration merging)
-            if (!fnName || seenFunctionNames.has(fnName))
+        // First pass: try symbol-based enumeration (handles re-exports, declare const, etc.)
+        const fileSymbol = dtsFile.getSymbol();
+        if (fileSymbol) {
+            for (const exportSymbol of fileSymbol.getExports()) {
+                const exportName = exportSymbol.getName();
+                if (seenFunctionNames.has(exportName))
+                    continue;
+                // Check if this export is callable (has call signatures)
+                const exportType = exportSymbol.getTypeAtLocation(dtsFile);
+                const callSignatures = exportType.getCallSignatures();
+                if (callSignatures.length === 0)
+                    continue;
+                seenFunctionNames.add(exportName);
+                // Use the first call signature to infer ports
+                const sig = callSignatures[0];
+                const ports = [];
+                // Execute input port
+                ports.push({
+                    name: 'execute', defaultLabel: 'Execute', reference: 'execute',
+                    type: 'STEP', direction: 'INPUT', defaultOrder: 0,
+                });
+                // Input ports from parameters
+                let inputOrder = 1;
+                for (const param of sig.getParameters()) {
+                    const paramName = param.getName();
+                    const paramType = param.getTypeAtLocation(dtsFile);
+                    const dataType = inferDataTypeFromTS(paramType.getText());
+                    ports.push({
+                        name: paramName, defaultLabel: capitalize(paramName), reference: paramName,
+                        type: dataType, direction: 'INPUT', defaultOrder: inputOrder++,
+                    });
+                }
+                // Output ports from return type
+                let returnType = sig.getReturnType();
+                const returnText = returnType.getText();
+                let isAsync = false;
+                if (returnText.startsWith('Promise<')) {
+                    isAsync = true;
+                    const typeArgs = returnType.getTypeArguments();
+                    if (typeArgs.length > 0)
+                        returnType = typeArgs[0];
+                }
+                let outputOrder = 0;
+                const unwrapped = returnType.getText();
+                if (unwrapped !== 'void' && unwrapped !== 'undefined') {
+                    const isPrimitive = PRIMITIVE_TYPES.has(unwrapped);
+                    const isArray = unwrapped.endsWith('[]') || unwrapped.startsWith('Array<');
+                    const properties = returnType.getProperties();
+                    const isObjectLike = !isPrimitive && !isArray && returnType.isObject() && properties.length > 0;
+                    if (isObjectLike) {
+                        for (const prop of properties) {
+                            const propName = prop.getName();
+                            if (propName === 'onSuccess' || propName === 'onFailure')
+                                continue;
+                            const propType = prop.getTypeAtLocation(dtsFile);
+                            ports.push({
+                                name: propName, defaultLabel: capitalize(propName), reference: propName,
+                                type: inferDataTypeFromTS(propType.getText()), direction: 'OUTPUT', defaultOrder: outputOrder++,
+                            });
+                        }
+                    }
+                    else {
+                        ports.push({
+                            name: 'result', defaultLabel: 'Result', reference: 'result',
+                            type: inferDataTypeFromTS(unwrapped), direction: 'OUTPUT', defaultOrder: outputOrder++,
+                        });
+                    }
+                }
+                ports.push({
+                    name: 'onSuccess', defaultLabel: 'On Success', reference: 'onSuccess',
+                    type: 'STEP', direction: 'OUTPUT', defaultOrder: 100,
+                });
+                ports.push({
+                    name: 'onFailure', defaultLabel: 'On Failure', reference: 'onFailure',
+                    type: 'STEP', direction: 'OUTPUT', defaultOrder: 101, failure: true,
+                });
+                nodeTypes.push({
+                    name: `npm/${packageName}/${exportName}`,
+                    variant: 'FUNCTION',
+                    category: 'NPM Packages',
+                    function: exportName,
+                    label: exportName,
+                    importSource: packageName,
+                    ports,
+                    synchronicity: isAsync ? 'ASYNC' : 'SYNC',
+                    description: `${exportName} from ${packageName}`,
+                });
+            }
+        }
+        // Follow star re-exports (`export * from './submodule'`) which the symbol
+        // API surfaces as a single __export pseudo-symbol instead of individual names.
+        for (const exportDecl of dtsFile.getExportDeclarations()) {
+            if (!exportDecl.isNamespaceExport())
                 continue;
-            seenFunctionNames.add(fnName);
-            const nodeType = inferNodeTypeFromDtsFunction(fn, packageName);
-            if (nodeType) {
-                nodeTypes.push(nodeType);
+            const targetFile = exportDecl.getModuleSpecifierSourceFile();
+            if (!targetFile)
+                continue;
+            const targetSymbol = targetFile.getSymbol();
+            if (!targetSymbol)
+                continue;
+            for (const exportSymbol of targetSymbol.getExports()) {
+                const exportName = exportSymbol.getName();
+                if (seenFunctionNames.has(exportName))
+                    continue;
+                const exportType = exportSymbol.getTypeAtLocation(targetFile);
+                const callSignatures = exportType.getCallSignatures();
+                if (callSignatures.length === 0)
+                    continue;
+                seenFunctionNames.add(exportName);
+                const sig = callSignatures[0];
+                const ports = [];
+                ports.push({ name: 'execute', defaultLabel: 'Execute', reference: 'execute', type: 'STEP', direction: 'INPUT', defaultOrder: 0 });
+                let starInputOrder = 1;
+                for (const param of sig.getParameters()) {
+                    const paramName = param.getName();
+                    const paramType = param.getTypeAtLocation(targetFile);
+                    ports.push({
+                        name: paramName, defaultLabel: capitalize(paramName), reference: paramName,
+                        type: inferDataTypeFromTS(paramType.getText()), direction: 'INPUT', defaultOrder: starInputOrder++,
+                    });
+                }
+                let returnType = sig.getReturnType();
+                const returnText = returnType.getText();
+                let isAsync = false;
+                if (returnText.startsWith('Promise<')) {
+                    isAsync = true;
+                    const typeArgs = returnType.getTypeArguments();
+                    if (typeArgs.length > 0)
+                        returnType = typeArgs[0];
+                }
+                const unwrapped = returnType.getText();
+                if (unwrapped !== 'void' && unwrapped !== 'undefined') {
+                    ports.push({ name: 'result', defaultLabel: 'Result', reference: 'result', type: inferDataTypeFromTS(unwrapped), direction: 'OUTPUT', defaultOrder: 0 });
+                }
+                ports.push({ name: 'onSuccess', defaultLabel: 'On Success', reference: 'onSuccess', type: 'STEP', direction: 'OUTPUT', defaultOrder: 100 });
+                ports.push({ name: 'onFailure', defaultLabel: 'On Failure', reference: 'onFailure', type: 'STEP', direction: 'OUTPUT', defaultOrder: 101, failure: true });
+                nodeTypes.push({
+                    name: `npm/${packageName}/${exportName}`,
+                    variant: 'FUNCTION',
+                    category: 'NPM Packages',
+                    function: exportName,
+                    label: exportName,
+                    importSource: packageName,
+                    ports,
+                    synchronicity: isAsync ? 'ASYNC' : 'SYNC',
+                    description: `${exportName} from ${packageName}`,
+                });
             }
         }
-        // Clean up the temporary source file
-        project.removeSourceFile(dtsFile);
+        // Fallback: if symbol-based enumeration found nothing, try extractFunctionLikes
+        // (handles edge cases where symbols aren't available)
+        if (nodeTypes.length === 0) {
+            const functions = extractFunctionLikes(dtsFile);
+            for (const fn of functions) {
+                const fnName = fn.getName();
+                if (!fnName || seenFunctionNames.has(fnName))
+                    continue;
+                seenFunctionNames.add(fnName);
+                const nodeType = inferNodeTypeFromDtsFunction(fn, packageName);
+                if (nodeType)
+                    nodeTypes.push(nodeType);
+            }
+        }
+        // Clean up added source files to avoid project bloat
+        for (const filePath of addedFiles) {
+            const sf = project.getSourceFile(filePath);
+            if (sf)
+                project.removeSourceFile(sf);
+        }
         return nodeTypes;
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flow-weaver",
-  "version": "0.30.5",
+  "version": "0.30.7",
   "description": "Flow Weaver: deterministic TypeScript workflow compiler. Define workflows with JSDoc annotations, compile to standalone functions with zero runtime dependencies.",
   "private": false,
   "type": "module",