@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-chunk-T7X5A23H.mjs

@@ -0,0 +1,558 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  getAllWorkflowTemplates
+} from "./flow-weaver-chunk-MMV2XGD3.mjs";
+import {
+  buildContext
+} from "./flow-weaver-chunk-MKAFQWLP.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+
+// src/cli/commands/init-personas.ts
+import { execSync } from "child_process";
+var PERSONA_CHOICES = [
+  { value: "nocode", name: "AI does everything", description: "Describe in plain language, AI builds the workflow. Guided setup included." },
+  { value: "vibecoder", name: "AI-assisted coding", description: "Collaborate with AI, iterate by describing changes. Hands-on setup with AI." },
+  { value: "lowcode", name: "Template-based", description: "Pick a template, customize the code. AI helps with initial setup." },
+  { value: "expert", name: "Full TypeScript", description: "Write workflows from scratch. Minimal setup, full control." }
+];
+var PERSONA_CONFIRMATIONS = {
+  nocode: "AI will handle the code. You describe, it builds.",
+  vibecoder: "You and AI will build this together.",
+  lowcode: "Starting from a template, you customize from there.",
+  expert: null
+};
+var USE_CASE_CHOICES = [
+  { value: "data", name: "Data pipeline", description: "Process, transform, and validate data" },
+  { value: "ai", name: "AI agent", description: "LLM with tools, reasoning, or retrieval" },
+  { value: "api", name: "API / webhook", description: "HTTP endpoints and integrations" },
+  { value: "automation", name: "Automation", description: "Conditional logic, error handling, routing" },
+  { value: "minimal", name: "Something else", description: "Start with a minimal template" }
+];
+var USE_CASE_TEMPLATES = {
+  data: { default: "sequential", all: ["sequential", "foreach", "aggregator"] },
+  ai: { default: "ai-agent", all: ["ai-agent", "ai-react", "ai-rag", "ai-chat"] },
+  api: { default: "webhook", all: ["webhook"] },
+  automation: { default: "conditional", all: ["conditional", "error-handler"] },
+  minimal: { default: "sequential", all: ["sequential"] }
+};
+function registerPackUseCase(useCase, templates) {
+  if (!USE_CASE_CHOICES.some((c) => c.value === useCase.id)) {
+    const minimalIdx = USE_CASE_CHOICES.findIndex((c) => c.value === "minimal");
+    const entry = { value: useCase.id, name: useCase.name, description: useCase.description };
+    if (minimalIdx >= 0) {
+      USE_CASE_CHOICES.splice(minimalIdx, 0, entry);
+    } else {
+      USE_CASE_CHOICES.push(entry);
+    }
+  }
+  if (!USE_CASE_TEMPLATES[useCase.id] && templates.length > 0) {
+    USE_CASE_TEMPLATES[useCase.id] = {
+      default: templates[0],
+      all: templates
+    };
+  }
+}
+function selectTemplateForPersona(persona, useCase) {
+  const mapping = USE_CASE_TEMPLATES[useCase];
+  if (!mapping) {
+    return { template: "sequential" };
+  }
+  if (persona === "lowcode" && mapping.all.length > 1) {
+    return { template: mapping.default, choices: mapping.all };
+  }
+  return { template: mapping.default };
+}
+function getTemplateSubChoices(templateIds) {
+  return templateIds.map((id) => {
+    const tmpl = getAllWorkflowTemplates().find((t) => t.id === id);
+    return {
+      value: id,
+      name: id,
+      description: tmpl?.description ?? ""
+    };
+  });
+}
+function extractWorkflowPreview(workflowCode) {
+  const pathMatches = workflowCode.match(/@path\s+(.+)/g);
+  if (pathMatches && pathMatches.length > 0) {
+    const raw = pathMatches[0].replace(/@path\s+/, "").trim();
+    const steps = raw.split(/\s*->\s*/);
+    const labelMap = buildLabelMap(workflowCode);
+    const labeled = steps.map((step) => labelMap.get(step) ?? step);
+    return labeled.join(" \u2500\u2500\u25B6 ");
+  }
+  const nodeAnnotations = workflowCode.match(/@node\s+(\w+)\s+\w+/g);
+  if (nodeAnnotations && nodeAnnotations.length > 0) {
+    const labelMap = buildLabelMap(workflowCode);
+    const names = nodeAnnotations.map((m) => {
+      const id = m.replace(/@node\s+/, "").split(/\s+/)[0];
+      return labelMap.get(id) ?? id;
+    });
+    return ["Start", ...names, "Exit"].join(" \u2500\u2500\u25B6 ");
+  }
+  return null;
+}
+function buildLabelMap(code) {
+  const map = /* @__PURE__ */ new Map();
+  map.set("Start", "Start");
+  map.set("Exit", "Exit");
+  const nodeRegex = /@node\s+(\w+)\s+(\w+)/g;
+  const instanceToType = /* @__PURE__ */ new Map();
+  let match;
+  while ((match = nodeRegex.exec(code)) !== null) {
+    instanceToType.set(match[1], match[2]);
+  }
+  const labelRegex = /@label\s+(.+)\n[\s\S]*?function\s+(\w+)/g;
+  const typeToLabel = /* @__PURE__ */ new Map();
+  while ((match = labelRegex.exec(code)) !== null) {
+    typeToLabel.set(match[2], match[1].trim());
+  }
+  for (const [instanceId, typeName] of instanceToType) {
+    const label = typeToLabel.get(typeName);
+    if (label) {
+      map.set(instanceId, label);
+    }
+  }
+  return map;
+}
+var FILE_DESCRIPTIONS = {
+  "package.json": "Dependencies and npm scripts",
+  "tsconfig.json": "TypeScript configuration",
+  ".gitignore": "Git ignore rules",
+  ".flowweaver/config.yaml": "Flow Weaver project settings",
+  "src/main.ts": "Runs the workflow with sample input"
+};
+function workflowFileDesc(persona) {
+  if (persona === "nocode") return "Your workflow (AI will modify this for you)";
+  return "Your workflow definition";
+}
+function generateReadme(projectName, persona, _template) {
+  const lines = [`# ${projectName}`, ""];
+  if (persona === "nocode") {
+    lines.push(
+      "A Flow Weaver workflow project configured for AI-assisted development.",
+      "",
+      "## Working with AI",
+      "",
+      "Open this project in your AI editor (Claude Code, Cursor, VS Code) and describe",
+      "what you want to build:",
+      "",
+      '- "Create a workflow that processes customer orders"',
+      '- "Add retry logic to the data pipeline"',
+      '- "Show me a diagram of the current workflow"',
+      "",
+      "Through the Flow Weaver MCP server the AI creates, modifies, validates and runs",
+      "workflows for you, and `fw console --open` shows you what it made.",
+      ""
+    );
+  } else if (persona === "vibecoder") {
+    lines.push(
+      "A Flow Weaver workflow project.",
+      "",
+      "## Development",
+      "",
+      "```sh",
+      "npm run dev       # Compile and run",
+      "npm run compile   # Compile only",
+      "npm run validate  # Check for errors",
+      "```",
+      "",
+      "## AI-Assisted Editing",
+      "",
+      "With your AI editor connected, you can describe changes in plain language:",
+      "",
+      '- "Add error handling to the pipeline"',
+      '- "Replace the mock LLM with OpenAI"',
+      '- "Add a validation step before processing"',
+      ""
+    );
+  } else if (persona === "lowcode") {
+    lines.push(
+      "A Flow Weaver workflow project.",
+      "",
+      "## Development",
+      "",
+      "```sh",
+      "npm run dev       # Compile and run",
+      "npm run compile   # Compile only",
+      "npm run validate  # Check for errors",
+      "```",
+      "",
+      "## Templates",
+      "",
+      "Browse and add more workflows:",
+      "",
+      "```sh",
+      "fw templates                         # List all templates",
+      "fw create workflow <template> <file>  # Add a workflow",
+      "fw describe src/*.ts --format ascii   # See workflow structure",
+      "```",
+      ""
+    );
+  } else {
+    lines.push(
+      "A Flow Weaver workflow project.",
+      "",
+      "## Commands",
+      "",
+      "```sh",
+      "npm run dev       # Compile and run",
+      "npm run compile   # Compile only",
+      "npm run validate  # Check for errors",
+      "```",
+      ""
+    );
+  }
+  lines.push(
+    "## Learn more",
+    "",
+    "- `fw console --open` to see the workflow as a process, run it and watch it from the browser",
+    "- `fw docs` to browse reference documentation",
+    "- `fw mcp-setup` to connect AI editors",
+    ""
+  );
+  return lines.join("\n");
+}
+function generateExampleWorkflow(projectName) {
+  const name = projectName.replace(/[-_.]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[^a-zA-Z_$]+/, "").replace(/^./, (c) => c.toLowerCase());
+  const fnName = (name || "example") + "Example";
+  return `/**
+ * Example: a minimal workflow to study and experiment with.
+ * Copy patterns from here into your main workflow.
+ */
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Greet
+ * @input name [order:0] - Name to greet
+ * @output greeting [order:0] - Greeting message
+ */
+function greet(name: string): { greeting: string } {
+  return { greeting: \`Hello, \${name}!\` };
+}
+
+/**
+ * @flowWeaver nodeType
+ * @expression
+ * @label Uppercase
+ * @input text [order:0] - Text to uppercase
+ * @output result [order:0] - Uppercased text
+ */
+function uppercase(text: string): { result: string } {
+  return { result: text.toUpperCase() };
+}
+
+/**
+ * @flowWeaver workflow
+ * @node greeter greet
+ * @node upper uppercase
+ * @path Start -> greeter -> upper -> Exit
+ * @connect greeter.greeting -> upper.text
+ * @param execute [order:0] - Execute
+ * @param name [order:1] - Name to greet
+ * @returns onSuccess [order:0] - On Success
+ * @returns onFailure [order:1] - On Failure
+ * @returns result [order:2] - Final greeting
+ */
+export function ${fnName}(
+  execute: boolean,
+  params: { name: string }
+): { onSuccess: boolean; onFailure: boolean; result: string } {
+  throw new Error("Compile with: fw compile <file>");
+}
+`;
+}
+function printNextSteps(opts) {
+  const { projectName, persona, displayDir, installSkipped, workflowCode, workflowFile, agentLaunched, compiled } = opts;
+  if (workflowCode) {
+    const preview = extractWorkflowPreview(workflowCode);
+    if (preview) {
+      logger.newline();
+      logger.log(`  ${logger.bold("Your workflow")}`);
+      logger.newline();
+      logger.log(`    ${logger.dim(preview)}`);
+    }
+  }
+  if (persona !== "expert") {
+    logger.newline();
+    logger.log(`  ${logger.bold("Project files")}`);
+    logger.newline();
+    const wfDesc = workflowFileDesc(persona);
+    logger.log(`    ${logger.highlight(`src/${workflowFile}`)}${pad(`src/${workflowFile}`, 32)}${wfDesc}`);
+    logger.log(`    ${logger.highlight("src/main.ts")}${pad("src/main.ts", 32)}${FILE_DESCRIPTIONS["src/main.ts"]}`);
+    logger.log(`    ${logger.highlight("package.json")}${pad("package.json", 32)}${FILE_DESCRIPTIONS["package.json"]}`);
+    logger.log(`    ${logger.highlight("tsconfig.json")}${pad("tsconfig.json", 32)}${FILE_DESCRIPTIONS["tsconfig.json"]}`);
+  }
+  logger.newline();
+  logger.log(`  ${logger.bold("Next steps")}`);
+  logger.newline();
+  if (displayDir) {
+    logger.log(`    cd ${displayDir}`);
+  }
+  if (installSkipped) {
+    logger.log("    npm install");
+  }
+  if (compiled) {
+    logger.log(`    npm start${" ".repeat(14)}${logger.dim("Run your compiled workflow")}`);
+    logger.log(`    npm run dev${" ".repeat(12)}${logger.dim("Recompile + run (after editing)")}`);
+  } else {
+    logger.log("    npm run dev");
+  }
+  logger.log(`    npx fw console --open${" ".repeat(2)}${logger.dim("See it as a process. Run it and watch it from the browser")}`);
+  if (!agentLaunched) {
+    if (persona === "nocode") {
+      printNocodeGuidance(projectName);
+    } else if (persona === "vibecoder") {
+      printVibecoderGuidance();
+    } else if (persona === "lowcode") {
+      printLowcodeGuidance();
+    } else {
+      printExpertGuidance();
+    }
+  }
+  logger.newline();
+}
+function printNocodeGuidance(_projectName) {
+  logger.newline();
+  logger.log(`  ${logger.bold("Your project is ready for AI-assisted building.")}`);
+  logger.log("  Open it in your AI editor and describe what you want:");
+  logger.newline();
+  logger.log(`    ${logger.dim('"Change this to fetch data from an API and validate the response"')}`);
+  logger.log(`    ${logger.dim('"Add error handling so failures get logged and retried"')}`);
+  logger.log(`    ${logger.dim('"Show me a diagram of my workflow"')}`);
+  logger.newline();
+  logger.log(`  ${logger.bold("Useful commands")}`);
+  logger.newline();
+  logger.log(`    npx fw run src/*.ts         ${logger.dim("Run your workflow")}`);
+  logger.log(`    npx fw diagram src/*.ts     ${logger.dim("See a visual diagram")}`);
+  logger.log(`    npx fw mcp-setup            ${logger.dim("Connect more AI editors")}`);
+}
+function printVibecoderGuidance() {
+  logger.newline();
+  logger.log(`  ${logger.bold("Describe what you want, AI handles the code.")}`);
+  logger.newline();
+  logger.log(`    ${logger.dim('"Add a retry loop when the model call fails"')}`);
+  logger.log(`    ${logger.dim('"Connect this to a Postgres database"')}`);
+  logger.log(`    ${logger.dim('"Show me a diagram of the current workflow"')}`);
+  logger.newline();
+  logger.log(`  ${logger.bold("When you want to see the structure")}`);
+  logger.newline();
+  logger.log(`    npm run diagram                  ${logger.dim("Visual diagram of your workflow")}`);
+}
+function printLowcodeGuidance() {
+  logger.newline();
+  logger.log(`  ${logger.bold("Explore and customize")}`);
+  logger.newline();
+  logger.log(`    npx fw templates            ${logger.dim("List the workflow and node templates")}`);
+  logger.log(`    npx fw describe src/*.ts     ${logger.dim("See the workflow structure")}`);
+  logger.log(`    npx fw docs annotations     ${logger.dim("Annotation reference")}`);
+  logger.newline();
+  logger.log(`  Your project includes an example in ${logger.highlight("examples/")} to study.`);
+  logger.log(`  With MCP connected, AI can help modify nodes and connections.`);
+}
+function printExpertGuidance() {
+  logger.newline();
+  logger.log(`    npx fw mcp-setup            ${logger.dim("Connect AI editors (Claude, Cursor, VS Code)")}`);
+  logger.log(`    npx fw docs                 ${logger.dim("Browse reference docs")}`);
+}
+function pad(displayName, width) {
+  const padding = Math.max(1, width - displayName.length);
+  return " ".repeat(padding);
+}
+var AGENT_CONTEXT_PRESETS = {
+  nocode: "core",
+  vibecoder: "core",
+  lowcode: "core",
+  expert: "core"
+};
+var BOOTSTRAP = 'Before doing anything else, call fw_context(preset="core", profile="assistant"). It is a short map of Flow Weaver. When a task needs more, load the topic it points to with fw_docs rather than reading everything up front.';
+var AGENT_PROMPTS = {
+  nocode: `${BOOTSTRAP}
+
+I just created a new Flow Weaver project called "{name}" using the {template} template.
+Help me set it up step by step:
+
+1. Show the current workflow as a diagram (use fw_diagram, ascii-compact)
+2. Walk me through what each step does in plain language
+3. Ask me what I want this workflow to do
+4. Based on my answer:
+   - Customize the workflow (add/remove/rename steps with fw_modify)
+   - Implement each step with real working code in its node function
+   - Set up supporting files if needed (.env template, basic tests)
+5. Show the final result as a step list and diagram
+
+Keep everything in plain language. Don't show code unless I ask.`,
+  vibecoder: `${BOOTSTRAP}
+
+I just created a new Flow Weaver project called "{name}" using the {template} template.
+Let's set it up together:
+
+1. Show the workflow diagram and briefly explain the structure
+2. Ask what I want to build, then iterate with me
+3. Customize the workflow, implement the nodes, add supporting files
+4. Show code when it's relevant, I'm comfortable reading and tweaking it
+5. Show the final diagram when we're done`,
+  lowcode: `${BOOTSTRAP}
+
+I just created a new Flow Weaver project called "{name}" using the {template} template.
+Help me customize it:
+
+1. Show the workflow diagram and explain what the template gives me
+2. Ask what I want this workflow to do
+3. Customize: rename nodes, adjust connections, implement the functions
+4. Add supporting files if needed (.env, tests)
+5. Show the final diagram
+
+I prefer working from templates and making targeted changes.`,
+  expert: `${BOOTSTRAP}
+
+New Flow Weaver project "{name}" (template: {template}).
+Show the workflow diagram (fw_diagram, ascii-compact) and validate it (fw_validate).
+Then ask what I'd like to build.`
+};
+function generateAgentPrompt(projectName, persona, template, useCaseDescription) {
+  let prompt = AGENT_PROMPTS[persona].replace(/\{name\}/g, projectName).replace(/\{template\}/g, template);
+  if (useCaseDescription) {
+    prompt = prompt.replace(
+      /(using the .+ template\.?\n)/,
+      `$1The user wants to build: ${useCaseDescription}
+`
+    );
+  }
+  return prompt;
+}
+function generateEditorPrompt(projectName, persona, template, useCaseDescription) {
+  const preset = AGENT_CONTEXT_PRESETS[persona];
+  const bootstrap = `Start by calling fw_context(preset="${preset}", profile="assistant") for a short map of Flow Weaver, then read further topics with fw_docs as the task needs them.`;
+  const desc = useCaseDescription ? ` I want to build: ${useCaseDescription}.` : "";
+  if (persona === "nocode") {
+    return `${bootstrap}
+This is a Flow Weaver project called "${projectName}" using the ${template} template.${desc} Show me the workflow diagram, walk me through what each step does in plain language, then ask me what I want to build. Keep it simple, no code.`;
+  }
+  if (persona === "vibecoder") {
+    return `${bootstrap}
+This is a Flow Weaver project called "${projectName}" using the ${template} template.${desc} Show me the workflow diagram, then let's iterate on it together. I'll describe what I want and you handle the implementation.`;
+  }
+  if (persona === "lowcode") {
+    return `${bootstrap}
+This is a Flow Weaver project called "${projectName}" using the ${template} template.${desc} Show me the workflow diagram and explain the template, then help me customize it for my use case.`;
+  }
+  return `${bootstrap}
+Flow Weaver project "${projectName}" (template: ${template}). Show the workflow diagram and implementation status.`;
+}
+function generateSetupPromptFile(projectName, persona, template, filesCreated, useCaseDescription) {
+  const prompt = generateAgentPrompt(projectName, persona, template, useCaseDescription);
+  const contextResult = buildContext({ preset: "core", profile: "assistant" });
+  const lines = [
+    `# ${projectName} Setup`,
+    "",
+    'Paste this into your AI editor chat, or ask it to "follow the instructions in PROJECT_SETUP.md".',
+    "",
+    "---",
+    "",
+    prompt,
+    "",
+    "---",
+    "",
+    "## Flow Weaver Reference",
+    "",
+    "The following is embedded Flow Weaver documentation so you can work with this project",
+    "even before MCP tools are connected. For deeper topics, call `fw_docs` once MCP is available.",
+    "",
+    contextResult.content,
+    "",
+    "---",
+    "",
+    "## Project context",
+    "",
+    `- **Template**: ${template}`,
+    `- **Persona**: ${persona}`,
+    "",
+    "### Files created",
+    "",
+    ...filesCreated.map((f) => `- \`${f}\``),
+    "",
+    "### Available Flow Weaver MCP tools",
+    "",
+    "Your AI editor has access to the Flow Weaver MCP tools, including:",
+    '- `fw_diagram` - Generate workflow diagrams (use format "ascii-compact" in chat)',
+    "- `fw_modify` / `fw_modify_batch` - Add/remove/rename nodes and connections",
+    "- `fw_validate` - Check for errors",
+    "- `fw_compile` - Generate executable code",
+    "- `fw_describe` - Inspect workflow structure",
+    "- `fw_run` / `fw_resume` - Run a workflow and answer any gate it pauses at",
+    "- `fw_docs` - Look up any topic; `fw_docs read mcp-tools` lists every tool",
+    "",
+    "*Delete this file after your initial setup is complete.*",
+    ""
+  ];
+  return lines.join("\n");
+}
+function printCopyablePrompt(prompt) {
+  const maxInner = 70;
+  const wrapped = [];
+  for (const raw of prompt.split("\n")) {
+    if (raw.length <= maxInner) {
+      wrapped.push(raw);
+    } else {
+      let remaining = raw;
+      while (remaining.length > maxInner) {
+        let breakAt = remaining.lastIndexOf(" ", maxInner);
+        if (breakAt <= 0) breakAt = maxInner;
+        wrapped.push(remaining.slice(0, breakAt));
+        remaining = remaining.slice(breakAt).replace(/^ /, "");
+      }
+      if (remaining) wrapped.push(remaining);
+    }
+  }
+  const width = maxInner + 2;
+  logger.newline();
+  logger.log(`  ${logger.bold("Paste this into your AI editor to get started:")}`);
+  logger.newline();
+  logger.log(`  ${"\u250C" + "\u2500".repeat(width) + "\u2510"}`);
+  for (const line of wrapped) {
+    const padded = line + " ".repeat(Math.max(0, maxInner - line.length));
+    logger.log(`  \u2502 ${padded} \u2502`);
+  }
+  logger.log(`  ${"\u2514" + "\u2500".repeat(width) + "\u2518"}`);
+  try {
+    const clipCmd = process.platform === "darwin" ? "pbcopy" : process.platform === "linux" ? "xclip -selection clipboard" : null;
+    if (clipCmd) {
+      execSync(clipCmd, { input: prompt, stdio: ["pipe", "pipe", "pipe"], timeout: 3e3 });
+      logger.newline();
+      logger.success("Copied to clipboard");
+    }
+  } catch {
+  }
+}
+var AGENT_LAUNCH_DEFAULTS = {
+  nocode: true,
+  vibecoder: true,
+  lowcode: true,
+  expert: false
+};
+
+export {
+  PERSONA_CHOICES,
+  PERSONA_CONFIRMATIONS,
+  USE_CASE_CHOICES,
+  USE_CASE_TEMPLATES,
+  registerPackUseCase,
+  selectTemplateForPersona,
+  getTemplateSubChoices,
+  extractWorkflowPreview,
+  FILE_DESCRIPTIONS,
+  generateReadme,
+  generateExampleWorkflow,
+  printNextSteps,
+  AGENT_CONTEXT_PRESETS,
+  generateAgentPrompt,
+  generateEditorPrompt,
+  generateSetupPromptFile,
+  printCopyablePrompt,
+  AGENT_LAUNCH_DEFAULTS
+};

package/dist/cli/flow-weaver-chunk-TLV3VZUN.mjs

@@ -0,0 +1,2 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);