@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-3MKUQP3D.mjs

@@ -0,0 +1,547 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  getGeneratedBranding
+} from "./flow-weaver-chunk-BHCC5FE5.mjs";
+
+// src/deployment/targets/base.ts
+import * as path from "path";
+
+// src/deployment/targets/openapi-parts.ts
+var SCHEMA_TYPE = {
+  STRING: "string",
+  NUMBER: "number",
+  BOOLEAN: "boolean",
+  OBJECT: "object",
+  ARRAY: "array",
+  FUNCTION: "object",
+  STEP: "boolean"
+};
+function portSchema(name, port) {
+  const type = port.dataType ? SCHEMA_TYPE[port.dataType] : void 0;
+  return {
+    ...type && { type },
+    description: port.label || name,
+    ...port.tsType && { "x-ts-type": port.tsType }
+  };
+}
+function portProperties(ports) {
+  const properties = {};
+  const required = [];
+  for (const [name, port] of Object.entries(ports)) {
+    if (port.dataType === "STEP") continue;
+    properties[name] = portSchema(name, port);
+    if (!port.optional) required.push(name);
+  }
+  return { properties, required };
+}
+var jsonBody = (schema) => ({ content: { "application/json": { schema } } });
+function executeOperation(op) {
+  return {
+    post: {
+      operationId: op.operationId,
+      summary: op.summary,
+      description: op.description,
+      tags: [op.tag],
+      requestBody: { description: op.requestDescription, required: true, ...jsonBody(op.requestSchema) },
+      responses: {
+        "200": {
+          description: op.subject === "Workflow" ? "Successful workflow execution" : "Successful execution",
+          ...jsonBody({
+            type: "object",
+            properties: {
+              success: { type: "boolean" },
+              result: op.resultSchema,
+              executionTime: { type: "number" },
+              requestId: { type: "string" }
+            }
+          })
+        },
+        "404": {
+          description: `${op.subject} not found`,
+          ...jsonBody({ type: "object", properties: { error: { type: "string" } } })
+        },
+        "500": {
+          description: "Execution error",
+          ...jsonBody({
+            type: "object",
+            properties: { success: { type: "boolean" }, error: { type: "string" }, requestId: { type: "string" } }
+          })
+        }
+      }
+    }
+  };
+}
+function nodeTypeOperation(nodeType, operationId) {
+  const inputs = portProperties(nodeType.inputs);
+  const outputs = portProperties(nodeType.outputs);
+  return executeOperation({
+    operationId,
+    summary: `Execute ${nodeType.name}`,
+    description: nodeType.description || `Execute the ${nodeType.name} node type function`,
+    tag: "node-types",
+    subject: "Node type",
+    requestDescription: "Node type input parameters",
+    requestSchema: {
+      type: "object",
+      properties: inputs.properties,
+      required: inputs.required.length > 0 ? inputs.required : void 0
+    },
+    resultSchema: { type: "object", properties: outputs.properties }
+  });
+}
+function workflowOperation(workflow, operationId, parametersDescription) {
+  return executeOperation({
+    operationId,
+    summary: `Execute ${workflow.name} workflow`,
+    description: workflow.description || `Execute the ${workflow.name} workflow`,
+    tag: "workflows",
+    subject: "Workflow",
+    requestDescription: "Workflow input parameters",
+    requestSchema: { type: "object", description: parametersDescription, additionalProperties: true },
+    resultSchema: { type: "object" }
+  });
+}
+var FUNCTION_CATEGORIES = ["transform", "filter", "validate", "format", "custom"];
+function functionsEndpoint() {
+  return {
+    get: {
+      operationId: "list_functions",
+      summary: "List available functions",
+      description: "Returns all registered functions that can be used as parameters",
+      tags: ["functions"],
+      parameters: [
+        {
+          name: "category",
+          in: "query",
+          required: false,
+          schema: { type: "string", enum: FUNCTION_CATEGORIES },
+          description: "Filter by function category"
+        }
+      ],
+      responses: {
+        "200": {
+          description: "List of registered functions",
+          ...jsonBody({
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string", example: "string:uppercase" },
+                name: { type: "string" },
+                description: { type: "string" },
+                category: { type: "string", enum: FUNCTION_CATEGORIES },
+                inputType: { type: "string" },
+                outputType: { type: "string" }
+              }
+            }
+          })
+        }
+      }
+    }
+  };
+}
+function specEndpoint() {
+  return {
+    get: {
+      operationId: "get_openapi",
+      summary: "OpenAPI Specification",
+      description: "Returns this OpenAPI 3.0 specification",
+      tags: ["documentation"],
+      responses: { "200": { description: "OpenAPI specification", content: { "application/json": {} } } }
+    }
+  };
+}
+var FUNCTION_REFERENCE_SCHEMA = {
+  oneOf: [
+    { type: "string", description: 'Registry function ID (e.g., "string:uppercase")' },
+    {
+      type: "object",
+      properties: {
+        registryId: { type: "string", description: "Registry function ID" },
+        partialArgs: { type: "object", description: "Pre-bound arguments", additionalProperties: true }
+      },
+      required: ["registryId"]
+    }
+  ],
+  description: "Function parameter - can be a registry ID or object with partial arguments"
+};
+var TAGS = {
+  workflows: { name: "workflows", description: "Workflow execution endpoints" },
+  nodeTypes: { name: "node-types", description: "Node type execution endpoints" },
+  functions: { name: "functions", description: "Function registry endpoints" },
+  documentation: { name: "documentation", description: "API documentation" }
+};
+function openApiDocument(opts) {
+  return structuredClone({
+    openapi: "3.0.3",
+    info: { title: opts.title, version: opts.version, description: opts.description },
+    servers: [{ url: opts.baseUrl || "/", description: "Current deployment" }],
+    paths: opts.paths,
+    tags: opts.tags,
+    ...opts.components && { components: opts.components }
+  });
+}
+
+// src/deployment/targets/base.ts
+var BaseExportTarget = class {
+  /**
+   * Generate a standard package.json
+   */
+  generatePackageJson(options) {
+    const pkg = {
+      name: `fw-${options.name}`,
+      version: "1.0.0",
+      description: options.description || `Flow Weaver workflow: ${options.name}`,
+      type: "module",
+      main: options.main || "index.js",
+      scripts: options.scripts || {},
+      dependencies: options.dependencies || {},
+      devDependencies: {
+        typescript: "^5.0.0",
+        ...options.devDependencies
+      }
+    };
+    return JSON.stringify(pkg, null, 2);
+  }
+  /**
+   * Generate a standard tsconfig.json
+   */
+  generateTsConfig(options = {}) {
+    const config = {
+      compilerOptions: {
+        target: "ES2022",
+        module: options.module || "NodeNext",
+        moduleResolution: options.moduleResolution || "NodeNext",
+        outDir: options.outDir || "./dist",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        ...options.types && { types: options.types }
+      },
+      include: ["**/*.ts"]
+    };
+    return JSON.stringify(config, null, 2);
+  }
+  /**
+   * Create a file object
+   */
+  createFile(outputDir, relativePath, content, type) {
+    return {
+      relativePath,
+      absolutePath: path.join(outputDir, relativePath),
+      content,
+      type
+    };
+  }
+  /**
+   * Generate content files for workflows and node types in a bundle.
+   * Creates files under workflows/ and node-types/ subdirectories.
+   */
+  generateBundleContentFiles(workflows, nodeTypes, outputDir, workflowDir = "workflows", nodeTypeDir = "node-types") {
+    const files = [];
+    for (const w of workflows) {
+      if (w.code) {
+        files.push(this.createFile(outputDir, `${workflowDir}/${w.name}.ts`, w.code, "workflow"));
+      }
+    }
+    for (const nt of nodeTypes) {
+      if (nt.code) {
+        files.push(this.createFile(outputDir, `${nodeTypeDir}/${nt.functionName.toLowerCase()}.ts`, nt.code, "nodeType"));
+      }
+    }
+    return files;
+  }
+  /**
+   * Generate content files for compiled workflows.
+   * Creates files under the workflows/ subdirectory.
+   */
+  generateWorkflowContentFiles(workflows, outputDir, workflowDir = "workflows") {
+    const files = [];
+    for (const w of workflows) {
+      if (w.code) {
+        files.push(this.createFile(outputDir, `${workflowDir}/${w.name}.ts`, w.code, "workflow"));
+      }
+    }
+    return files;
+  }
+  /**
+   * Generate content files for node types.
+   * Creates files under the node-types/ subdirectory.
+   */
+  generateNodeTypeContentFiles(nodeTypes, outputDir, nodeTypeDir = "node-types") {
+    const files = [];
+    for (const nt of nodeTypes) {
+      if (nt.code) {
+        files.push(this.createFile(outputDir, `${nodeTypeDir}/${nt.functionName.toLowerCase()}.ts`, nt.code, "nodeType"));
+      }
+    }
+    return files;
+  }
+  /**
+   * Get relative import path for the workflow
+   */
+  getWorkflowImport(workflowFile) {
+    const basename2 = path.basename(workflowFile, path.extname(workflowFile));
+    return `./${basename2}.js`;
+  }
+  /**
+   * The OpenAPI document of a node-type service: one POST per node type.
+   */
+  generateNodeTypeOpenAPI(nodeTypes, options) {
+    const paths = {};
+    for (const nodeType of nodeTypes) {
+      paths[`/api/${nodeType.name}`] = nodeTypeOperation(nodeType, `execute_${nodeType.functionName}`);
+    }
+    paths["/api/openapi.json"] = specEndpoint();
+    return openApiDocument({
+      ...options,
+      description: `Node type service with ${nodeTypes.length} endpoints`,
+      paths,
+      tags: [TAGS.nodeTypes, TAGS.documentation]
+    });
+  }
+  /**
+   * The OpenAPI document of a multi-workflow service: one POST per workflow,
+   * plus the function registry.
+   */
+  generateConsolidatedOpenAPI(workflows, options) {
+    const paths = {};
+    for (const workflow of workflows) {
+      paths[`/api/${workflow.name}`] = workflowOperation(
+        workflow,
+        `execute_${workflow.functionName}`,
+        "Workflow-specific parameters. Function parameters can be registry IDs."
+      );
+    }
+    paths["/api/functions"] = functionsEndpoint();
+    paths["/api/openapi.json"] = specEndpoint();
+    return openApiDocument({
+      ...options,
+      description: `Multi-workflow service with ${workflows.length} workflows`,
+      paths,
+      tags: [TAGS.workflows, TAGS.functions, TAGS.documentation],
+      components: { schemas: { FunctionReference: FUNCTION_REFERENCE_SCHEMA } }
+    });
+  }
+  /**
+   * The OpenAPI document of a bundle: a POST for each exposed workflow and
+   * node type, plus the function registry.
+   */
+  generateBundleOpenAPI(workflows, nodeTypes, options) {
+    const exposedWorkflows = workflows.filter((w) => w.expose);
+    const exposedNodeTypes = nodeTypes.filter((nt) => nt.expose);
+    const paths = {};
+    const tags = [];
+    if (exposedWorkflows.length > 0) tags.push(TAGS.workflows);
+    for (const workflow of exposedWorkflows) {
+      paths[`/api/workflows/${workflow.name}`] = workflowOperation(
+        workflow,
+        `execute_workflow_${workflow.functionName}`,
+        "Workflow-specific parameters"
+      );
+    }
+    if (exposedNodeTypes.length > 0) tags.push(TAGS.nodeTypes);
+    for (const nodeType of exposedNodeTypes) {
+      paths[`/api/nodes/${nodeType.name}`] = nodeTypeOperation(nodeType, `execute_node_${nodeType.functionName}`);
+    }
+    paths["/api/functions"] = functionsEndpoint();
+    paths["/api/openapi.json"] = specEndpoint();
+    tags.push(TAGS.functions, TAGS.documentation);
+    const count = (n, noun) => `${n} ${noun}${n !== 1 ? "s" : ""}`;
+    const exposed = [
+      ...exposedWorkflows.length > 0 ? [count(exposedWorkflows.length, "workflow")] : [],
+      ...exposedNodeTypes.length > 0 ? [count(exposedNodeTypes.length, "node type")] : []
+    ];
+    return openApiDocument({
+      ...options,
+      description: exposed.length > 0 ? `Bundle service with ${exposed.join(" and ")} exposed` : "Bundle service with no workflows or node types exposed",
+      paths,
+      tags
+    });
+  }
+  /**
+   * Generate a README.md from deploy instructions
+   */
+  generateReadme(instructions, workflowName, target) {
+    const lines = [];
+    lines.push(`# Deploy ${workflowName} to ${target}`);
+    lines.push("");
+    if (instructions.prerequisites.length > 0) {
+      lines.push("## Prerequisites");
+      lines.push("");
+      instructions.prerequisites.forEach((p) => lines.push(`- ${p}`));
+      lines.push("");
+    }
+    if (instructions.steps.length > 0) {
+      lines.push("## Deployment Steps");
+      lines.push("");
+      instructions.steps.forEach((step, i) => {
+        if (step.startsWith("  ")) {
+          lines.push(`   \`${step.trim()}\``);
+        } else {
+          lines.push(`${i + 1}. \`${step}\``);
+        }
+      });
+      lines.push("");
+    }
+    if (instructions.localTestSteps && instructions.localTestSteps.length > 0) {
+      lines.push("## Local Testing");
+      lines.push("");
+      lines.push("Test your deployment locally before pushing to production:");
+      lines.push("");
+      lines.push("```bash");
+      instructions.localTestSteps.forEach((step) => lines.push(step));
+      lines.push("```");
+      lines.push("");
+    }
+    if (instructions.links && instructions.links.length > 0) {
+      lines.push("## Useful Links");
+      lines.push("");
+      instructions.links.forEach((link) => lines.push(`- [${link.label}](${link.url})`));
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push(getGeneratedBranding().markdown);
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate placeholder runtime files under `runtime/`: a function registry
+   * listing the bundled workflows and node types, a builtin-functions module
+   * that only imports it, and a trivial parameter resolver. They are not the
+   * Flow Weaver runtime; a target that needs the real one must bundle it.
+   */
+  generateRuntimeFiles(outputDir, workflows, nodeTypes) {
+    const files = [];
+    files.push(
+      this.createFile(
+        outputDir,
+        "runtime/function-registry.ts",
+        this.generateFunctionRegistryContent(workflows, nodeTypes),
+        "other"
+      )
+    );
+    files.push(
+      this.createFile(
+        outputDir,
+        "runtime/builtin-functions.ts",
+        `// Builtin functions, auto-registers known functions
+import './function-registry.js';
+`,
+        "other"
+      )
+    );
+    files.push(
+      this.createFile(
+        outputDir,
+        "runtime/parameter-resolver.ts",
+        `// Parameter resolver
+export function resolveFunction(param: unknown) { return typeof param === 'function' ? param : undefined; }
+`,
+        "other"
+      )
+    );
+    return files;
+  }
+  /**
+   * Generate function registry content with workflow/nodeType metadata.
+   * Used as fallback when real runtime source files aren't available.
+   */
+  generateFunctionRegistryContent(workflows, nodeTypes) {
+    return `// Generated function registry
+type FunctionInfo = {
+  name: string;
+  type: 'workflow' | 'nodeType';
+  exposed: boolean;
+};
+
+const functions: FunctionInfo[] = [
+${workflows.map((w) => `  { name: '${w.name}', type: 'workflow', exposed: ${w.expose} },`).join("\n")}
+${nodeTypes.map((nt) => `  { name: '${nt.name}', type: 'nodeType', exposed: ${nt.expose} },`).join("\n")}
+];
+
+// Query helpers over the function list above.
+export const functionRegistry = {
+  list(category?: 'workflow' | 'nodeType'): FunctionInfo[] {
+    return category ? functions.filter((f) => f.type === category) : functions;
+  },
+  get(name: string): FunctionInfo | undefined {
+    return functions.find((f) => f.name === name);
+  },
+};
+`;
+  }
+};
+var ExportTargetRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  /**
+   * Register a target factory. The target is only instantiated on first use.
+   * Also accepts a pre-instantiated target.
+   */
+  register(nameOrTarget, factory) {
+    if (typeof nameOrTarget === "string") {
+      this.factories.set(nameOrTarget, factory);
+    } else {
+      const target = nameOrTarget;
+      this.instances.set(target.name, target);
+      this.factories.set(target.name, () => target);
+    }
+  }
+  get(name) {
+    if (!this.instances.has(name)) {
+      const factory = this.factories.get(name);
+      if (factory) this.instances.set(name, factory());
+    }
+    return this.instances.get(name);
+  }
+  getAll() {
+    for (const [name, factory] of this.factories) {
+      if (!this.instances.has(name)) this.instances.set(name, factory());
+    }
+    return Array.from(this.instances.values());
+  }
+  getNames() {
+    return Array.from(this.factories.keys());
+  }
+  /** Get deploy schemas from all registered targets (for validation/autocomplete) */
+  getDeploySchemas() {
+    const schemas = {};
+    for (const target of this.getAll()) {
+      if (target.deploySchema) schemas[target.name] = target.deploySchema;
+    }
+    return schemas;
+  }
+};
+
+// src/deployment/index.ts
+import * as path2 from "path";
+import { pathToFileURL } from "url";
+async function createTargetRegistry(projectDir) {
+  const registry = new ExportTargetRegistry();
+  if (projectDir) {
+    const { listInstalledPackages } = await import("./flow-weaver-registry-5MLFRPPT.mjs");
+    const packages = await listInstalledPackages(projectDir);
+    for (const pkg of packages) {
+      for (const def of pkg.manifest.exportTargets ?? []) {
+        const filePath = path2.join(pkg.path, def.file);
+        const mod = await import(pathToFileURL(filePath).href);
+        const TargetClass = def.exportName ? mod[def.exportName] : mod.default;
+        if (typeof TargetClass !== "function") {
+          const what = def.exportName ? `export "${def.exportName}"` : "a default export";
+          console.warn(`Export target "${def.name}" of pack ${pkg.name} skipped: ${filePath} has no ${what} that is a class or function`);
+          continue;
+        }
+        registry.register(def.name, () => new TargetClass());
+      }
+    }
+  }
+  return registry;
+}
+
+export {
+  BaseExportTarget,
+  ExportTargetRegistry,
+  createTargetRegistry
+};

package/dist/cli/flow-weaver-chunk-3ZLMPQTH.mjs

@@ -0,0 +1,27 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+
+// src/marketplace/install.ts
+import { execFileSync } from "node:child_process";
+var NAME = "(?:@[a-z0-9][a-z0-9._-]*/)?[a-z0-9][a-z0-9._-]*";
+var PACKAGE_NAME = new RegExp(`^${NAME}$`);
+var REGISTRY_SPEC = new RegExp(`^${NAME}(?:@[A-Za-z0-9._^~<>=|*+-]+)?$`);
+var LOCAL_SPEC = /^(?:file:|\.{1,2}\/|\/)[^\s;&|<>`$(){}[\]'"\\]+$/;
+function isPackageSpec(spec) {
+  return REGISTRY_SPEC.test(spec) || LOCAL_SPEC.test(spec);
+}
+function runNpm(args, options = {}) {
+  const win = process.platform === "win32";
+  execFileSync(win ? "npm.cmd" : "npm", args, { cwd: options.cwd, stdio: options.stdio ?? "pipe", shell: win });
+}
+function npmInstall(spec, options = {}) {
+  if (!isPackageSpec(spec)) {
+    throw new Error(`"${spec}" is not a package name, name@version, or local path`);
+  }
+  runNpm(["install", spec], options);
+}
+
+export {
+  runNpm,
+  npmInstall
+};