@synergenius/flow-weaver 0.30.9 → 0.31.0

package/dist/api/command-runner.js

@@ -14,6 +14,8 @@ import { generateWorkflowFromTemplate } from './templates.js';
 import { getNodes, getConnections, getTopologicalOrder, findIsolatedNodes, findDeadEnds, countNodes, countConnections, } from './query.js';
 import { WorkflowDiffer } from '../diff/WorkflowDiffer.js';
 import { formatDiff } from '../diff/formatDiff.js';
+import { searchPackages, listInstalledPackages } from '../marketplace/registry.js';
+import { applyMigrations, getRegisteredMigrations } from '../migration/registry.js';
 function resolveFile(args, cwd) {
     const file = String(args.file);
     return cwd ? path.resolve(cwd, file) : path.resolve(file);
@@ -203,6 +205,213 @@ const handlers = {
         });
         return { data: result };
     },
+    // ─── status ─────────────────────────────────────────────────────
+    status: async (args) => {
+        const filePath = resolveFile(args, args.cwd);
+        const parseResult = await parseWorkflow(filePath, {
+            workflowName: args.workflow,
+        });
+        if (parseResult.errors.length > 0) {
+            return { data: { valid: false, errors: parseResult.errors } };
+        }
+        const ast = parseResult.ast;
+        const nodeTypes = ast.nodeTypes ?? [];
+        const stubs = nodeTypes.filter((nt) => nt.variant === 'STUB').map((nt) => nt.name);
+        const implemented = nodeTypes.filter((nt) => nt.variant !== 'STUB').map((nt) => nt.name);
+        return {
+            data: {
+                total: nodeTypes.length,
+                implemented,
+                stubs,
+                progress: nodeTypes.length > 0
+                    ? Math.round((implemented.length / nodeTypes.length) * 100)
+                    : 100,
+            },
+        };
+    },
+    // ─── market-search ──────────────────────────────────────────────
+    'market-search': async (args) => {
+        const query = String(args.query ?? '');
+        const results = await searchPackages({ query });
+        return { data: { results, query } };
+    },
+    // ─── market-list ────────────────────────────────────────────────
+    'market-list': async (args) => {
+        const cwd = args.cwd || process.cwd();
+        const packages = await listInstalledPackages(cwd);
+        return {
+            data: {
+                packages: packages.map((p) => ({
+                    name: p.name,
+                    version: p.version,
+                    nodeTypes: p.manifest.nodeTypes?.length ?? 0,
+                    workflows: p.manifest.workflows?.length ?? 0,
+                    cliCommands: p.manifest.cliCommands?.length ?? 0,
+                })),
+            },
+        };
+    },
+    // ─── migrate ────────────────────────────────────────────────────
+    migrate: async (args) => {
+        const filePath = resolveFile(args, args.cwd);
+        const dryRun = Boolean(args.dryRun);
+        const source = fs.readFileSync(filePath, 'utf-8');
+        const parseResult = await parseWorkflow(filePath);
+        if (parseResult.errors.length > 0) {
+            return { data: { migrated: false, errors: parseResult.errors } };
+        }
+        const migrated = applyMigrations(parseResult.ast);
+        const genResult = generateInPlace(source, migrated);
+        const newSource = genResult.code;
+        const changed = newSource !== source;
+        if (changed && !dryRun) {
+            fs.writeFileSync(filePath, newSource);
+        }
+        return {
+            data: {
+                migrated: true,
+                changed,
+                dryRun,
+                file: filePath,
+                availableMigrations: getRegisteredMigrations().map((m) => m.name),
+            },
+        };
+    },
+    // ─── openapi ────────────────────────────────────────────────────
+    openapi: async (args) => {
+        const directory = path.resolve(String(args.directory));
+        const { generateOpenAPIJson, generateOpenAPIYaml } = await import('../deployment/openapi/generator.js');
+        const format = args.format || 'json';
+        // Scan directory for .ts files and parse each for workflows
+        const files = fs.readdirSync(directory).filter((f) => f.endsWith('.ts'));
+        const endpoints = [];
+        for (const file of files) {
+            const filePath = path.join(directory, file);
+            try {
+                const parsed = await parseWorkflow(filePath);
+                if (parsed.errors.length === 0) {
+                    endpoints.push({
+                        name: parsed.ast.name,
+                        functionName: parsed.ast.name,
+                        filePath,
+                        method: 'POST',
+                        path: `/${parsed.ast.name}`,
+                    });
+                }
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        const genOptions = {
+            title: args.title || 'Flow Weaver API',
+            version: args.version || '1.0.0',
+        };
+        const spec = format === 'yaml'
+            ? generateOpenAPIYaml(endpoints, genOptions)
+            : generateOpenAPIJson(endpoints, genOptions);
+        return { data: { spec, format, workflowCount: endpoints.length } };
+    },
+    // ─── login ──────────────────────────────────────────────────────
+    login: async (args) => {
+        try {
+            const { saveCredentials, loadCredentials, getPlatformUrl } = await import('../cli/config/credentials.js');
+            const apiKey = args.apiKey;
+            if (apiKey) {
+                saveCredentials({
+                    token: apiKey,
+                    email: '',
+                    plan: 'free',
+                    platformUrl: getPlatformUrl(),
+                    expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
+                });
+                return { data: { authenticated: true, method: 'apiKey' } };
+            }
+            const existing = loadCredentials();
+            if (existing) {
+                return { data: { authenticated: true, method: 'existing' } };
+            }
+            return { data: { authenticated: false, message: 'Provide an apiKey parameter or run fw login in the terminal for browser auth.' } };
+        }
+        catch {
+            return { data: { authenticated: false, message: 'Auth module not available' } };
+        }
+    },
+    // ─── account ────────────────────────────────────────────────────
+    account: async () => {
+        try {
+            const { loadCredentials, isLoggedIn } = await import('../cli/config/credentials.js');
+            if (!isLoggedIn()) {
+                return { data: { authenticated: false, message: 'Not logged in. Use fw login first.' } };
+            }
+            const creds = loadCredentials();
+            const { PlatformClient } = await import('../cli/config/platform-client.js');
+            const client = new PlatformClient(creds);
+            const user = await client.getUser();
+            const usage = await client.getDetailedUsage();
+            return { data: { authenticated: true, user, usage } };
+        }
+        catch (err) {
+            return { data: { authenticated: false, message: err instanceof Error ? err.message : String(err) } };
+        }
+    },
+    // ─── deploy ─────────────────────────────────────────────────────
+    deploy: async (args) => {
+        try {
+            const { loadCredentials, isLoggedIn } = await import('../cli/config/credentials.js');
+            if (!isLoggedIn()) {
+                return { data: { authenticated: false, message: 'Not logged in. Use fw login first.' } };
+            }
+            const filePath = resolveFile(args, args.cwd);
+            const source = fs.readFileSync(filePath, 'utf-8');
+            const name = args.name || path.basename(filePath, '.ts');
+            const creds = loadCredentials();
+            const { PlatformClient } = await import('../cli/config/platform-client.js');
+            const client = new PlatformClient(creds);
+            const pushed = await client.pushWorkflow(name, source);
+            const deployed = await client.deploy(pushed.slug);
+            return { data: { authenticated: true, slug: deployed.slug, status: deployed.status } };
+        }
+        catch (err) {
+            return { data: { authenticated: false, message: err instanceof Error ? err.message : String(err) } };
+        }
+    },
+    // ─── undeploy ───────────────────────────────────────────────────
+    undeploy: async (args) => {
+        try {
+            const { loadCredentials, isLoggedIn } = await import('../cli/config/credentials.js');
+            if (!isLoggedIn()) {
+                return { data: { authenticated: false, message: 'Not logged in. Use fw login first.' } };
+            }
+            const slug = String(args.slug);
+            const creds = loadCredentials();
+            const { PlatformClient } = await import('../cli/config/platform-client.js');
+            const client = new PlatformClient(creds);
+            await client.undeploy(slug);
+            return { data: { authenticated: true, slug, removed: true } };
+        }
+        catch (err) {
+            return { data: { authenticated: false, message: err instanceof Error ? err.message : String(err) } };
+        }
+    },
+    // ─── cloud-status ───────────────────────────────────────────────
+    'cloud-status': async () => {
+        try {
+            const { loadCredentials, isLoggedIn } = await import('../cli/config/credentials.js');
+            if (!isLoggedIn()) {
+                return { data: { authenticated: false, message: 'Not logged in. Use fw login first.' } };
+            }
+            const creds = loadCredentials();
+            const { PlatformClient } = await import('../cli/config/platform-client.js');
+            const client = new PlatformClient(creds);
+            const deployments = await client.listDeployments();
+            const usage = await client.getUsage();
+            return { data: { authenticated: true, deployments, usage } };
+        }
+        catch (err) {
+            return { data: { authenticated: false, message: err instanceof Error ? err.message : String(err) } };
+        }
+    },
 };
 export async function runCommand(name, args) {
     const handler = handlers[name];

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.9";
+    VERSION = "0.31.0";
   }
 });
 
@@ -43495,6 +43495,21 @@ var init_formatDiff = __esm({
   }
 });
 
+// src/migration/registry.ts
+function applyMigrations(ast) {
+  return migrations.reduce((current2, migration) => migration.apply(current2), ast);
+}
+function getRegisteredMigrations() {
+  return migrations.map((m) => ({ name: m.name }));
+}
+var migrations;
+var init_registry2 = __esm({
+  "src/migration/registry.ts"() {
+    "use strict";
+    migrations = [];
+  }
+});
+
 // src/api/command-runner.ts
 var init_command_runner = __esm({
   "src/api/command-runner.ts"() {
@@ -43508,6 +43523,8 @@ var init_command_runner = __esm({
     init_query();
     init_WorkflowDiffer();
     init_formatDiff();
+    init_registry();
+    init_registry2();
   }
 });
 
@@ -79237,21 +79254,6 @@ var init_tools_template = __esm({
   }
 });
 
-// src/migration/registry.ts
-function applyMigrations(ast) {
-  return migrations.reduce((current2, migration) => migration.apply(current2), ast);
-}
-function getRegisteredMigrations() {
-  return migrations.map((m) => ({ name: m.name }));
-}
-var migrations;
-var init_registry2 = __esm({
-  "src/migration/registry.ts"() {
-    "use strict";
-    migrations = [];
-  }
-});
-
 // src/mcp/tools-pattern.ts
 import * as path24 from "path";
 import * as fs23 from "fs";
@@ -88935,7 +88937,7 @@ function parseIntStrict(value) {
 // src/cli/index.ts
 init_logger();
 init_error_utils();
-var version2 = true ? "0.30.9" : "0.0.0-dev";
+var version2 = true ? "0.31.0" : "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.9";
+export declare const VERSION = "0.31.0";
 //# 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.9';
+export const VERSION = '0.31.0';
 //# sourceMappingURL=generated-version.js.map

package/dist/npm-packages.js

@@ -151,6 +151,7 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
         const dataProps = isObjectLike
             ? properties.filter(p => p.getName() !== 'onSuccess' && p.getName() !== 'onFailure')
             : [];
+        let dataOutputOrder = 2; // after onSuccess(0) and onFailure(1)
         if (isObjectLike && dataProps.length <= 8) {
             for (const prop of dataProps) {
                 const propName = prop.getName();
@@ -161,6 +162,7 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
                     reference: propName,
                     type: inferDataTypeFromTS(propType.getText()),
                     direction: 'OUTPUT',
+                    defaultOrder: dataOutputOrder++,
                 });
             }
         }
@@ -173,17 +175,18 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
                 reference: 'result',
                 type: dataType,
                 direction: 'OUTPUT',
+                defaultOrder: dataOutputOrder++,
             });
         }
     }
-    // Add mandatory control flow output ports
+    // Add mandatory control flow output ports (before data outputs)
     ports.push({
         name: 'onSuccess',
         defaultLabel: 'On Success',
         reference: 'onSuccess',
         type: 'STEP',
         direction: 'OUTPUT',
-        defaultOrder: 100,
+        defaultOrder: 0,
     });
     ports.push({
         name: 'onFailure',
@@ -191,7 +194,7 @@ function inferNodeTypeFromDtsFunction(fn, packageName) {
         reference: 'onFailure',
         type: 'STEP',
         direction: 'OUTPUT',
-        defaultOrder: 101,
+        defaultOrder: 1,
         failure: true,
     });
     return {
@@ -331,7 +334,16 @@ export function getPackageExports(packageName, workdir, nodeModulesOverride) {
                     if (typeArgs.length > 0)
                         returnType = typeArgs[0];
                 }
-                let outputOrder = 0;
+                // Step output ports first (control flow), then data outputs
+                ports.push({
+                    name: 'onSuccess', defaultLabel: 'On Success', reference: 'onSuccess',
+                    type: 'STEP', direction: 'OUTPUT', defaultOrder: 0,
+                });
+                ports.push({
+                    name: 'onFailure', defaultLabel: 'On Failure', reference: 'onFailure',
+                    type: 'STEP', direction: 'OUTPUT', defaultOrder: 1, failure: true,
+                });
+                let outputOrder = 2;
                 const unwrapped = returnType.getText();
                 if (unwrapped !== 'void' && unwrapped !== 'undefined' && unwrapped !== 'never') {
                     const isPrimitive = PRIMITIVE_TYPES.has(unwrapped);
@@ -359,14 +371,6 @@ export function getPackageExports(packageName, workdir, nodeModulesOverride) {
                         });
                     }
                 }
-                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: exportName,
                     variant: 'FUNCTION',
@@ -421,12 +425,12 @@ export function getPackageExports(packageName, workdir, nodeModulesOverride) {
                     if (typeArgs.length > 0)
                         returnType = typeArgs[0];
                 }
+                ports.push({ name: 'onSuccess', defaultLabel: 'On Success', reference: 'onSuccess', type: 'STEP', direction: 'OUTPUT', defaultOrder: 0 });
+                ports.push({ name: 'onFailure', defaultLabel: 'On Failure', reference: 'onFailure', type: 'STEP', direction: 'OUTPUT', defaultOrder: 1, failure: true });
                 const unwrapped = returnType.getText();
                 if (unwrapped !== 'void' && unwrapped !== 'undefined' && unwrapped !== 'never') {
-                    ports.push({ name: 'result', defaultLabel: 'Result', reference: 'result', type: inferDataTypeFromTS(unwrapped), direction: 'OUTPUT', defaultOrder: 0 });
+                    ports.push({ name: 'result', defaultLabel: 'Result', reference: 'result', type: inferDataTypeFromTS(unwrapped), direction: 'OUTPUT', defaultOrder: 2 });
                 }
-                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: exportName,
                     variant: 'FUNCTION',

package/package.json

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