@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/cli/flow-weaver-init-34YZNPQX.mjs

@@ -0,0 +1,972 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  CLI_TOOL_BINARY,
+  ExitPromptError,
+  Separator,
+  ValidationError,
+  createPrompt,
+  cursorHide,
+  detectCliTools,
+  dist_default,
+  dist_default2,
+  isBackspaceKey,
+  isDownKey,
+  isEnterKey,
+  isNonInteractive,
+  isNumberKey,
+  isTabKey,
+  isUpKey,
+  makeTheme,
+  runMcpSetupFromInit,
+  useEffect,
+  useKeypress,
+  useMemo,
+  usePagination,
+  usePrefix,
+  useRef,
+  useState
+} from "./flow-weaver-chunk-PUWZ47H5.mjs";
+import {
+  loadPackTemplates
+} from "./flow-weaver-chunk-QOPRVDES.mjs";
+import {
+  compileCommand
+} from "./flow-weaver-chunk-M6CBWQKJ.mjs";
+import "./flow-weaver-chunk-S63Q3JIU.mjs";
+import "./flow-weaver-chunk-I4APCXYN.mjs";
+import "./flow-weaver-chunk-3ZLMPQTH.mjs";
+import "./flow-weaver-chunk-7ET6N32V.mjs";
+import {
+  AGENT_LAUNCH_DEFAULTS,
+  PERSONA_CHOICES,
+  PERSONA_CONFIRMATIONS,
+  USE_CASE_CHOICES,
+  generateAgentPrompt,
+  generateEditorPrompt,
+  generateExampleWorkflow,
+  generateReadme,
+  generateSetupPromptFile,
+  getTemplateSubChoices,
+  printCopyablePrompt,
+  printNextSteps,
+  selectTemplateForPersona
+} from "./flow-weaver-chunk-T7X5A23H.mjs";
+import {
+  getAllWorkflowTemplates,
+  getWorkflowTemplate
+} from "./flow-weaver-chunk-MMV2XGD3.mjs";
+import "./flow-weaver-chunk-MKAFQWLP.mjs";
+import "./flow-weaver-chunk-XG2WKXYZ.mjs";
+import "./flow-weaver-chunk-NQKKWDGF.mjs";
+import "./flow-weaver-chunk-V6DHWFQG.mjs";
+import "./flow-weaver-chunk-U3EO3X4B.mjs";
+import "./flow-weaver-chunk-MSI2UJES.mjs";
+import "./flow-weaver-chunk-3BSYCWPL.mjs";
+import "./flow-weaver-chunk-4DVY73ML.mjs";
+import "./flow-weaver-chunk-ZQALO25T.mjs";
+import "./flow-weaver-chunk-DM4BBRRU.mjs";
+import "./flow-weaver-chunk-NYZDQYFU.mjs";
+import "./flow-weaver-chunk-A6M5K3W7.mjs";
+import "./flow-weaver-chunk-W3YNK26P.mjs";
+import "./flow-weaver-chunk-BHCC5FE5.mjs";
+import "./flow-weaver-chunk-VXWNLYQU.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import "./flow-weaver-chunk-55QMUZIA.mjs";
+import "./flow-weaver-chunk-EM5HWQ4R.mjs";
+import "./flow-weaver-chunk-Z44JK332.mjs";
+import "./flow-weaver-chunk-APX6MQ5A.mjs";
+import "./flow-weaver-chunk-7G63RR4K.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+import "./flow-weaver-chunk-GAQXZHNO.mjs";
+import "./flow-weaver-chunk-DRN7KPWY.mjs";
+import "./flow-weaver-chunk-N767YRAI.mjs";
+
+// src/cli/commands/init.ts
+import * as path5 from "path";
+
+// src/cli/commands/init/config.ts
+import * as path from "path";
+
+// node_modules/@inquirer/input/dist/index.js
+var inputTheme = {
+  validationFailureMode: "keep"
+};
+var dist_default3 = createPrompt((config, done) => {
+  const { prefill = "tab" } = config;
+  const theme = makeTheme(inputTheme, config.theme);
+  const [status, setStatus] = useState("idle");
+  const [defaultValue, setDefaultValue] = useState(String(config.default ?? ""));
+  const [errorMsg, setError] = useState();
+  const [value, setValue] = useState("");
+  const prefix = usePrefix({ status, theme });
+  async function validate(value2) {
+    const { required, pattern, patternError = "Invalid input" } = config;
+    if (required && !value2) {
+      return "You must provide a value";
+    }
+    if (pattern && !pattern.test(value2)) {
+      return patternError;
+    }
+    if (typeof config.validate === "function") {
+      return await config.validate(value2) || "You must provide a valid value";
+    }
+    return true;
+  }
+  useKeypress(async (key, rl) => {
+    if (status !== "idle") {
+      return;
+    }
+    if (isEnterKey(key)) {
+      const answer = value || defaultValue;
+      setStatus("loading");
+      const isValid = await validate(answer);
+      if (isValid === true) {
+        setValue(answer);
+        setStatus("done");
+        done(answer);
+      } else {
+        if (theme.validationFailureMode === "clear") {
+          setValue("");
+        } else {
+          rl.write(value);
+        }
+        setError(isValid);
+        setStatus("idle");
+      }
+    } else if (isBackspaceKey(key) && !value) {
+      setDefaultValue("");
+    } else if (isTabKey(key) && !value) {
+      setDefaultValue("");
+      rl.clearLine(0);
+      rl.write(defaultValue);
+      setValue(defaultValue);
+    } else {
+      setValue(rl.line);
+      setError(void 0);
+    }
+  });
+  useEffect((rl) => {
+    if (prefill === "editable" && defaultValue) {
+      rl.write(defaultValue);
+      setValue(defaultValue);
+    }
+  }, []);
+  const message = theme.style.message(config.message, status);
+  let formattedValue = value;
+  if (typeof config.transformer === "function") {
+    formattedValue = config.transformer(value, { isFinal: status === "done" });
+  } else if (status === "done") {
+    formattedValue = theme.style.answer(value);
+  }
+  let defaultStr;
+  if (defaultValue && status !== "done" && !value) {
+    defaultStr = theme.style.defaultAnswer(defaultValue);
+  }
+  let error = "";
+  if (errorMsg) {
+    error = theme.style.error(errorMsg);
+  }
+  return [
+    [prefix, message, defaultStr, formattedValue].filter((v) => v !== void 0).join(" "),
+    error
+  ];
+});
+
+// node_modules/@inquirer/select/dist/index.js
+import { styleText } from "node:util";
+var selectTheme = {
+  icon: { cursor: dist_default.pointer },
+  style: {
+    disabled: (text) => styleText("dim", text),
+    description: (text) => styleText("cyan", text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText("bold", key)} ${styleText("dim", action)}`).join(styleText("dim", " \u2022 "))
+  },
+  i18n: { disabledError: "This option is disabled and cannot be selected." },
+  indexMode: "hidden"
+};
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        disabled: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      disabled: choice.disabled ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var dist_default4 = createPrompt((config, done) => {
+  const { loop = true, pageSize = 7 } = config;
+  const theme = makeTheme(selectTheme, config.theme);
+  const { keybindings } = theme;
+  const [status, setStatus] = useState("idle");
+  const prefix = usePrefix({ status, theme });
+  const searchTimeoutRef = useRef();
+  const searchEnabled = !keybindings.includes("vim");
+  const items = useMemo(() => normalizeChoices(config.choices), [config.choices]);
+  const bounds = useMemo(() => {
+    const first = items.findIndex(isNavigable);
+    const last = items.findLastIndex(isNavigable);
+    if (first === -1) {
+      throw new ValidationError("[select prompt] No selectable choices. All choices are disabled.");
+    }
+    return { first, last };
+  }, [items]);
+  const defaultItemIndex = useMemo(() => {
+    if (!("default" in config))
+      return -1;
+    return items.findIndex((item) => isSelectable(item) && item.value === config.default);
+  }, [config.default, items]);
+  const [active, setActive] = useState(defaultItemIndex === -1 ? bounds.first : defaultItemIndex);
+  const selectedChoice = items[active];
+  if (selectedChoice == null || Separator.isSeparator(selectedChoice)) {
+    throw new Error("Active index does not point to a choice");
+  }
+  const [errorMsg, setError] = useState();
+  useKeypress((key, rl) => {
+    clearTimeout(searchTimeoutRef.current);
+    if (errorMsg) {
+      setError(void 0);
+    }
+    if (isEnterKey(key)) {
+      if (selectedChoice.disabled) {
+        setError(theme.i18n.disabledError);
+      } else {
+        setStatus("done");
+        done(selectedChoice.value);
+      }
+    } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+      rl.clearLine(0);
+      if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+        const offset = isUpKey(key, keybindings) ? -1 : 1;
+        let next = active;
+        do {
+          next = (next + offset + items.length) % items.length;
+        } while (!isNavigable(items[next]));
+        setActive(next);
+      }
+    } else if (isNumberKey(key) && !Number.isNaN(Number(rl.line))) {
+      const selectedIndex = Number(rl.line) - 1;
+      let selectableIndex = -1;
+      const position = items.findIndex((item2) => {
+        if (Separator.isSeparator(item2))
+          return false;
+        selectableIndex++;
+        return selectableIndex === selectedIndex;
+      });
+      const item = items[position];
+      if (item != null && isSelectable(item)) {
+        setActive(position);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    } else if (isBackspaceKey(key)) {
+      rl.clearLine(0);
+    } else if (searchEnabled) {
+      const searchTerm = rl.line.toLowerCase();
+      const matchIndex = items.findIndex((item) => {
+        if (Separator.isSeparator(item) || !isSelectable(item))
+          return false;
+        return item.name.toLowerCase().startsWith(searchTerm);
+      });
+      if (matchIndex !== -1) {
+        setActive(matchIndex);
+      }
+      searchTimeoutRef.current = setTimeout(() => {
+        rl.clearLine(0);
+      }, 700);
+    }
+  });
+  useEffect(() => () => {
+    clearTimeout(searchTimeoutRef.current);
+  }, []);
+  const message = theme.style.message(config.message, status);
+  const helpLine = theme.style.keysHelpTip([
+    ["\u2191\u2193", "navigate"],
+    ["\u23CE", "select"]
+  ]);
+  let separatorCount = 0;
+  const page = usePagination({
+    items,
+    active,
+    renderItem({ item, isActive, index }) {
+      if (Separator.isSeparator(item)) {
+        separatorCount++;
+        return ` ${item.separator}`;
+      }
+      const cursor = isActive ? theme.icon.cursor : " ";
+      const indexLabel = theme.indexMode === "number" ? `${index + 1 - separatorCount}. ` : "";
+      if (item.disabled) {
+        const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+        const disabledCursor = isActive ? theme.icon.cursor : "-";
+        return theme.style.disabled(`${disabledCursor} ${indexLabel}${item.name} ${disabledLabel}`);
+      }
+      const color = isActive ? theme.style.highlight : (x) => x;
+      return color(`${cursor} ${indexLabel}${item.name}`);
+    },
+    pageSize,
+    loop
+  });
+  if (status === "done") {
+    return [prefix, message, theme.style.answer(selectedChoice.short)].filter(Boolean).join(" ");
+  }
+  const { description } = selectedChoice;
+  const lines = [
+    [prefix, message].filter(Boolean).join(" "),
+    page,
+    " ",
+    description ? theme.style.description(description) : "",
+    errorMsg ? theme.style.error(errorMsg) : "",
+    helpLine
+  ].filter(Boolean).join("\n").trimEnd();
+  return `${lines}${cursorHide}`;
+});
+
+// src/cli/commands/init/naming.ts
+var PROJECT_NAME_RE = /^[a-zA-Z0-9][-a-zA-Z0-9_.]*$/;
+function validateProjectName(name) {
+  if (!name) return "Project name cannot be empty";
+  if (name.length > 214) return "Project name must be at most 214 characters";
+  if (!PROJECT_NAME_RE.test(name)) {
+    return "Project name must start with a letter or digit and contain only letters, digits, hyphens, dots, and underscores";
+  }
+  return true;
+}
+function toWorkflowName(projectName) {
+  const camel = projectName.replace(/[-_.]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[^a-zA-Z_$]+/, "").replace(/^./, (c) => c.toLowerCase());
+  return (camel || "myProject") + "Workflow";
+}
+function workflowFileName(projectName) {
+  return `${projectName}-workflow.ts`;
+}
+
+// src/cli/commands/init/config.ts
+function getValidTemplates() {
+  return getAllWorkflowTemplates().map((t) => t.id);
+}
+var VALID_PERSONAS = ["nocode", "vibecoder", "lowcode", "expert"];
+function getValidUseCases() {
+  return USE_CASE_CHOICES.map((c) => c.value);
+}
+async function resolveInitConfig(dirArg, options) {
+  const skipPrompts = options.yes || isNonInteractive();
+  const force = options.force ?? false;
+  const projectName = await resolveProjectName(dirArg, options, skipPrompts);
+  const targetDir = path.resolve(dirArg ?? projectName);
+  const persona = await resolvePersona(options, skipPrompts);
+  if (!skipPrompts) announcePersona(persona);
+  const { template, useCase } = await resolveTemplate(options, persona, skipPrompts);
+  const useCaseDescription = await askUseCaseDescription(useCase, persona, skipPrompts);
+  const mcp = await resolveMcp(options, persona, skipPrompts);
+  const installDeps = await resolveExpertToggle(options.install, persona, skipPrompts, "Install dependencies (npm install)?");
+  const gitInit = await resolveExpertToggle(options.git, persona, skipPrompts, "Initialize a git repository?");
+  const format = await resolveFormat(options, persona, skipPrompts);
+  return {
+    projectName,
+    targetDir,
+    template,
+    format,
+    install: installDeps,
+    git: gitInit,
+    force,
+    persona,
+    useCase,
+    useCaseDescription,
+    mcp
+  };
+}
+async function resolveProjectName(dirArg, options, skipPrompts) {
+  let projectName;
+  if (options.name) {
+    projectName = options.name;
+  } else if (dirArg) {
+    projectName = path.basename(dirArg);
+  } else if (skipPrompts) {
+    projectName = "my-project";
+  } else {
+    projectName = await dist_default3({
+      message: "Project name:",
+      default: "my-project",
+      validate: (v) => validateProjectName(v)
+    });
+  }
+  const valid = validateProjectName(projectName);
+  if (valid !== true) {
+    throw new Error(valid);
+  }
+  return projectName;
+}
+async function resolvePersona(options, skipPrompts) {
+  if (options.preset) {
+    if (!VALID_PERSONAS.includes(options.preset)) {
+      throw new Error(`Unknown preset "${options.preset}". Available: ${VALID_PERSONAS.join(", ")}`);
+    }
+    return options.preset;
+  }
+  if (skipPrompts || options.template) {
+    return "expert";
+  }
+  return dist_default4({
+    message: "How do you plan to build?",
+    choices: PERSONA_CHOICES,
+    default: "vibecoder"
+  });
+}
+function announcePersona(persona) {
+  const confirmation = PERSONA_CONFIRMATIONS[persona];
+  if (confirmation) {
+    logger.log(`  ${logger.dim(confirmation)}`);
+    logger.newline();
+  }
+}
+async function resolveTemplate(options, persona, skipPrompts) {
+  if (options.template) {
+    const template = options.template;
+    if (!getValidTemplates().includes(template)) {
+      throw new Error(`Unknown template "${template}". Available: ${getValidTemplates().join(", ")}`);
+    }
+    return { template };
+  }
+  if (persona === "expert") {
+    return { template: skipPrompts ? "sequential" : await askExpertTemplate() };
+  }
+  const useCase = await resolveUseCase(options, skipPrompts);
+  return { template: await pickUseCaseTemplate(persona, useCase, skipPrompts), useCase };
+}
+function askExpertTemplate() {
+  return dist_default4({
+    message: "Workflow template:",
+    choices: [
+      new Separator("\u2500\u2500 Data Processing \u2500\u2500"),
+      { value: "sequential", name: "sequential", description: "Linear pipeline" },
+      { value: "foreach", name: "foreach", description: "Batch iteration" },
+      { value: "aggregator", name: "aggregator", description: "Collect and aggregate results" },
+      new Separator("\u2500\u2500 Automation \u2500\u2500"),
+      { value: "conditional", name: "conditional", description: "Route by condition" },
+      { value: "approval", name: "approval", description: "Pause for a person to approve, then carry on" },
+      new Separator("\u2500\u2500 AI \u2500\u2500"),
+      { value: "ai-agent", name: "ai-agent", description: "LLM agent with tool calling" },
+      { value: "ai-react", name: "ai-react", description: "ReAct pattern" },
+      { value: "ai-rag", name: "ai-rag", description: "Retrieval-Augmented Generation" },
+      { value: "ai-chat", name: "ai-chat", description: "Conversational AI" },
+      new Separator("\u2500\u2500 Integration \u2500\u2500"),
+      { value: "webhook", name: "webhook", description: "HTTP webhook handler" },
+      new Separator("\u2500\u2500 Utility \u2500\u2500"),
+      { value: "error-handler", name: "error-handler", description: "Error handling and recovery" }
+    ],
+    default: "sequential"
+  });
+}
+async function resolveUseCase(options, skipPrompts) {
+  if (options.useCase) {
+    if (!getValidUseCases().includes(options.useCase)) {
+      throw new Error(`Unknown use case "${options.useCase}". Available: ${getValidUseCases().join(", ")}`);
+    }
+    return options.useCase;
+  }
+  if (skipPrompts) {
+    return "data";
+  }
+  return dist_default4({
+    message: "What are you building?",
+    choices: USE_CASE_CHOICES,
+    default: "data"
+  });
+}
+async function pickUseCaseTemplate(persona, useCase, skipPrompts) {
+  const selection = selectTemplateForPersona(persona, useCase);
+  if (selection.choices && !skipPrompts) {
+    return dist_default4({
+      message: "Pick a template:",
+      choices: getTemplateSubChoices(selection.choices),
+      default: selection.template
+    });
+  }
+  return selection.template;
+}
+async function askUseCaseDescription(useCase, persona, skipPrompts) {
+  if (useCase !== "minimal" || skipPrompts || persona === "expert") return void 0;
+  const answer = await dist_default3({
+    message: "Briefly describe what you want to build:"
+  });
+  if (!answer) return void 0;
+  return answer.trim() || void 0;
+}
+async function resolveMcp(options, persona, skipPrompts) {
+  if (options.mcp !== void 0) return options.mcp;
+  if (skipPrompts) return false;
+  if (persona === "nocode" || persona === "vibecoder" || persona === "lowcode") {
+    return dist_default2({
+      message: "Set up AI editor integration? (Claude Code, Cursor, VS Code, etc.)",
+      default: true
+    });
+  }
+  return false;
+}
+async function resolveExpertToggle(flag, persona, skipPrompts, message) {
+  if (flag !== void 0) return flag;
+  if (skipPrompts || persona !== "expert") return true;
+  return dist_default2({ message, default: true });
+}
+async function resolveFormat(options, persona, skipPrompts) {
+  if (options.format) {
+    const format = options.format;
+    if (format !== "esm" && format !== "cjs") {
+      throw new Error(`Invalid format "${format}". Use "esm" or "cjs".`);
+    }
+    return format;
+  }
+  if (skipPrompts || persona !== "expert") {
+    return "esm";
+  }
+  return dist_default4({
+    message: "Module format:",
+    choices: [
+      { value: "esm", name: "ESM (Recommended)", description: "ECMAScript modules (import/export)" },
+      { value: "cjs", name: "CommonJS", description: "CommonJS modules (require/module.exports)" }
+    ],
+    default: "esm"
+  });
+}
+
+// src/cli/commands/init/files.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var GITIGNORE = `node_modules/
+dist/
+.tsbuildinfo
+`;
+var CONFIG_YAML = `defaultFileType: ts
+`;
+function generateProjectFiles(projectName, template, format = "esm", persona = "expert") {
+  const workflowName = toWorkflowName(projectName);
+  const workflowFile = workflowFileName(projectName);
+  const tmpl = getWorkflowTemplate(template);
+  if (!tmpl) {
+    throw new Error(`Unknown template "${template}"`);
+  }
+  const workflowCode = tmpl.generate({ workflowName });
+  const files = {
+    "package.json": buildPackageJson(projectName, workflowFile, format, persona),
+    "tsconfig.json": buildTsconfig(format),
+    [`src/${workflowFile}`]: workflowCode,
+    "src/main.ts": buildMainTs(projectName, workflowName, workflowFile, format),
+    ".gitignore": GITIGNORE,
+    ".flowweaver/config.yaml": CONFIG_YAML
+  };
+  files["README.md"] = generateReadme(projectName, persona, template);
+  if (persona === "lowcode") {
+    files["examples/example-workflow.ts"] = generateExampleWorkflow(projectName);
+  }
+  return files;
+}
+function buildPackageJson(projectName, workflowFile, format, persona) {
+  const scripts = {
+    dev: `npx fw compile src/${workflowFile} -o src && npx tsx src/main.ts`,
+    start: "npx tsx src/main.ts",
+    compile: `npx fw compile src/${workflowFile} -o src`,
+    validate: `npx fw validate src/${workflowFile}`,
+    doctor: "npx fw doctor"
+  };
+  if (persona !== "expert") {
+    scripts.diagram = `npx fw diagram src/${workflowFile} --format ascii-compact`;
+  }
+  const packageJsonContent = {
+    name: projectName,
+    version: "1.0.0",
+    scripts,
+    dependencies: {
+      "@synergenius/flow-weaver": "latest"
+    },
+    devDependencies: {
+      typescript: "^5.3.0",
+      "@types/node": "^22.0.0",
+      tsx: "^4.21.0"
+    }
+  };
+  if (format === "esm") {
+    packageJsonContent.type = "module";
+  }
+  return JSON.stringify(packageJsonContent, null, 2);
+}
+function buildTsconfig(format) {
+  const tsconfigContent = {
+    compilerOptions: {
+      target: "ES2020",
+      module: format === "esm" ? "ES2020" : "CommonJS",
+      moduleResolution: format === "esm" ? "bundler" : "node",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "dist",
+      rootDir: "src",
+      types: ["node"]
+    },
+    include: ["src"]
+  };
+  return JSON.stringify(tsconfigContent, null, 2);
+}
+function buildMainTs(projectName, workflowName, workflowFile, format) {
+  const workflowJsFile = workflowFile.replace(/\.ts$/, ".js");
+  const imports = format === "esm" ? [`import { ${workflowName}, createWorkflowRuntime } from './${workflowJsFile}';`] : [`const { ${workflowName}, createWorkflowRuntime } = require('./${workflowJsFile}');`];
+  return [
+    "/**",
+    ` * ${projectName}: workflow runner`,
+    " *",
+    " * Usage:",
+    " *   npm run dev      compile workflow + run this file",
+    " *   npm start        run without recompiling",
+    " *   npm run compile  compile only",
+    " */",
+    "",
+    ...imports,
+    "",
+    "async function main() {",
+    "  // The runtime names the run and carries the services the generated code",
+    "  // reads (mocks, a debugger, an abort signal). See: fw docs library",
+    `  const runtime = createWorkflowRuntime({ runId: \`run-\${Date.now()}\`, workflowId: '${workflowName}' });`,
+    `  const result = await ${workflowName}(true, { data: { message: 'hello world' } }, runtime);`,
+    "  console.log(JSON.stringify(result, null, 2));",
+    "}",
+    "",
+    "main().catch((e) => {",
+    "  if (e instanceof Error && /generated body was not installed|Compile with:/.test(e.message)) {",
+    "    console.error('Workflow not compiled yet. Run: npm run dev');",
+    "    process.exit(1);",
+    "  }",
+    "  console.error(e);",
+    "  process.exit(1);",
+    "});",
+    ""
+  ].join("\n");
+}
+function assertNoExistingProject(targetDir, force) {
+  const pkgPath = path2.join(targetDir, "package.json");
+  if (fs.existsSync(pkgPath) && !force) {
+    throw new Error(
+      `${targetDir} already contains a package.json. Use --force to overwrite.`
+    );
+  }
+}
+function scaffoldProject(targetDir, files, options) {
+  const filesCreated = [];
+  const filesSkipped = [];
+  for (const [relativePath, content] of Object.entries(files)) {
+    const absPath = path2.join(targetDir, relativePath);
+    const dir = path2.dirname(absPath);
+    fs.mkdirSync(dir, { recursive: true });
+    if (fs.existsSync(absPath) && !options.force) {
+      filesSkipped.push(relativePath);
+      continue;
+    }
+    fs.writeFileSync(absPath, content, "utf8");
+    filesCreated.push(relativePath);
+  }
+  return { filesCreated, filesSkipped };
+}
+
+// src/cli/commands/init/setup.ts
+import * as fs2 from "fs";
+import { execSync } from "child_process";
+function runNpmInstall(targetDir) {
+  try {
+    execSync("npm install", { cwd: targetDir, stdio: "pipe", timeout: 12e4 });
+    return { success: true };
+  } catch (err) {
+    const message = getErrorMessage(err);
+    return { success: false, error: message };
+  }
+}
+function runGitInit(targetDir) {
+  try {
+    execSync("git init", { cwd: targetDir, stdio: "pipe", timeout: 1e4 });
+    return { success: true };
+  } catch (err) {
+    const message = getErrorMessage(err);
+    return { success: false, error: message };
+  }
+}
+function installDependencies(targetDir, showProgress) {
+  const spinner = showProgress ? logger.spinner("Installing dependencies...") : null;
+  const installResult = runNpmInstall(targetDir);
+  if (spinner) {
+    if (installResult.success) spinner.stop("Dependencies installed");
+    else spinner.fail(`npm install failed: ${installResult.error}`);
+  }
+  return installResult;
+}
+async function compileWorkflow(workflowPath, format) {
+  if (!fs2.existsSync(workflowPath)) return void 0;
+  try {
+    await compileCommand(workflowPath, { format });
+    return { success: true };
+  } catch (err) {
+    const message = getErrorMessage(err);
+    return { success: false, error: message };
+  }
+}
+async function setUpEditors() {
+  let mcpResult;
+  const spinner = logger.spinner("Detecting AI editors...");
+  try {
+    mcpResult = await runMcpSetupFromInit();
+    const mcpConfigured = mcpResult.configured;
+    spinner.stop();
+    for (const t of mcpResult.detected) {
+      if (!t.detected) continue;
+      const wasConfigured = mcpConfigured.includes(t.displayName);
+      if (wasConfigured) {
+        logger.success(`${t.displayName} configured`);
+      }
+    }
+    if (mcpResult.failed.length > 0) {
+      for (const name of mcpResult.failed) {
+        logger.warn(`${name} failed to configure`);
+      }
+    }
+    if (mcpResult.detected.every((t) => !t.detected)) {
+      logger.log(`  ${logger.dim("No AI editors detected")}`);
+    }
+  } catch {
+    spinner.fail("MCP setup failed");
+  }
+  return mcpResult;
+}
+
+// src/cli/commands/init/output.ts
+import * as path3 from "path";
+function printStatusLines(config, outcome) {
+  const { filesSkipped, installResult, gitResult, compileResult } = outcome;
+  logger.newline();
+  logger.success(`Created ${logger.highlight(config.projectName)} ${logger.dim(`(${config.template}, ${config.format.toUpperCase()})`)}`);
+  if (filesSkipped.length > 0) {
+    logger.warn(`Skipped ${filesSkipped.length} existing file(s)`);
+  }
+  if (installResult) {
+    if (installResult.success) {
+      logger.success("Dependencies installed");
+    } else {
+      logger.warn(`npm install failed: ${installResult.error}`);
+    }
+  }
+  if (gitResult) {
+    if (gitResult.success) {
+      logger.success("Git initialized");
+    } else {
+      logger.warn(`git init failed: ${gitResult.error}`);
+    }
+  }
+  if (compileResult) {
+    if (compileResult.success) {
+      logger.success("Workflow compiled");
+    } else {
+      logger.warn(`Compile failed: ${compileResult.error}`);
+    }
+  }
+}
+function displayDirFor(targetDir) {
+  const relDir = path3.relative(process.cwd(), targetDir);
+  return !relDir || relDir === "." ? null : relDir.startsWith("../../") ? targetDir : relDir;
+}
+
+// src/cli/commands/init/agent-handoff.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import { spawn } from "child_process";
+async function offerAgentHandoff(config, options, filesCreated, mcpResult) {
+  let cliTools = mcpResult ? mcpResult.cliTools : [];
+  const guiTools = mcpResult ? mcpResult.guiTools : [];
+  const skipAgent = options.agent === false || options.yes || isNonInteractive();
+  if (skipAgent) return false;
+  if (cliTools.length === 0) {
+    try {
+      cliTools = await detectCliTools();
+    } catch {
+    }
+  }
+  const hasTools = cliTools.length > 0 || guiTools.length > 0;
+  if (!hasTools) return false;
+  try {
+    return await handleAgentHandoff({
+      projectName: config.projectName,
+      persona: config.persona,
+      template: config.template,
+      targetDir: config.targetDir,
+      cliTools,
+      guiTools,
+      filesCreated,
+      useCaseDescription: config.useCaseDescription
+    });
+  } catch (err) {
+    if (err instanceof ExitPromptError) return true;
+    return false;
+  }
+}
+async function handleAgentHandoff(opts) {
+  if (opts.cliTools.length > 0 && await offerCliAgentLaunch(opts)) {
+    return true;
+  }
+  if (opts.guiTools.length > 0 || opts.cliTools.length > 0) {
+    await offerEditorPrompt(opts);
+  }
+  return false;
+}
+async function offerCliAgentLaunch(opts) {
+  const { projectName, persona, template, targetDir, cliTools, useCaseDescription } = opts;
+  const toolId = cliTools[0];
+  const binary = CLI_TOOL_BINARY[toolId];
+  const displayName = toolId === "claude" ? "Claude Code" : "Codex";
+  const launchDefault = AGENT_LAUNCH_DEFAULTS[persona];
+  const shouldLaunch = await dist_default2({
+    message: `Launch ${displayName} to set up your project?`,
+    default: launchDefault
+  });
+  if (!shouldLaunch || !binary) return false;
+  const prompt = generateAgentPrompt(projectName, persona, template, useCaseDescription);
+  logger.newline();
+  logger.log(`  ${logger.dim(`Starting ${displayName}...`)}`);
+  logger.newline();
+  const child = spawn(binary, [prompt], {
+    cwd: targetDir,
+    stdio: "inherit",
+    env: { ...process.env }
+  });
+  child.on("error", (err) => {
+    logger.error(`Failed to start ${displayName}: ${err.message}`);
+  });
+  return true;
+}
+async function offerEditorPrompt(opts) {
+  const { projectName, persona, template, useCaseDescription } = opts;
+  const promptAction = await dist_default4({
+    message: "Generate a setup prompt for your editor?",
+    choices: [
+      { value: "terminal", name: "Print to terminal", description: "Copy and paste into your editor" },
+      { value: "file", name: "Save as file", description: "Write PROJECT_SETUP.md to your project" },
+      { value: "both", name: "Both" },
+      { value: "skip", name: "Skip" }
+    ],
+    default: "terminal"
+  });
+  if (promptAction === "skip") return;
+  const editorPrompt = generateEditorPrompt(projectName, persona, template, useCaseDescription);
+  if (promptAction === "terminal" || promptAction === "both") {
+    printCopyablePrompt(editorPrompt);
+  }
+  if (promptAction === "file" || promptAction === "both") {
+    writeSetupPromptFile(opts);
+  }
+}
+function writeSetupPromptFile(opts) {
+  const { projectName, persona, template, targetDir, filesCreated, useCaseDescription } = opts;
+  const setupContent = generateSetupPromptFile(projectName, persona, template, filesCreated, useCaseDescription);
+  const setupPath = path4.join(targetDir, "PROJECT_SETUP.md");
+  fs3.writeFileSync(setupPath, setupContent, "utf8");
+  const gitignorePath = path4.join(targetDir, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const existing = fs3.readFileSync(gitignorePath, "utf8");
+    if (!existing.includes("PROJECT_SETUP.md")) {
+      fs3.appendFileSync(gitignorePath, "PROJECT_SETUP.md\n", "utf8");
+    }
+  }
+  logger.newline();
+  logger.success(`Wrote ${logger.highlight("PROJECT_SETUP.md")} ${logger.dim("(delete after first setup)")}`);
+}
+
+// src/cli/commands/init.ts
+async function initCommand(dirArg, options) {
+  try {
+    await loadPackTemplates(process.cwd());
+    const config = await resolveInitConfig(dirArg, options);
+    assertNoExistingProject(config.targetDir, config.force);
+    const files = generateProjectFiles(config.projectName, config.template, config.format, config.persona);
+    const { filesCreated, filesSkipped } = scaffoldProject(config.targetDir, files, {
+      force: config.force
+    });
+    const installResult = config.install ? installDependencies(config.targetDir, !options.json) : void 0;
+    const gitResult = config.git ? runGitInit(config.targetDir) : void 0;
+    const workflowFile = workflowFileName(config.projectName);
+    const compileResult = options.json ? void 0 : await compileWorkflow(path5.join(config.targetDir, "src", workflowFile), config.format);
+    const mcpResult = config.mcp && !options.json ? await setUpEditors() : void 0;
+    const mcpConfigured = mcpResult?.configured;
+    if (options.json) {
+      const report = {
+        projectDir: config.targetDir,
+        filesCreated,
+        filesSkipped,
+        template: config.template,
+        format: config.format,
+        persona: config.persona,
+        installResult,
+        gitResult,
+        mcpConfigured,
+        agentLaunched: false
+      };
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    printStatusLines(config, { filesSkipped, installResult, gitResult, compileResult });
+    const workflowCode = files[`src/${workflowFile}`] ?? null;
+    const displayDir = displayDirFor(config.targetDir);
+    if (await offerAgentHandoff(config, options, filesCreated, mcpResult)) {
+      return;
+    }
+    printNextSteps({
+      projectName: config.projectName,
+      persona: config.persona,
+      template: config.template,
+      displayDir,
+      installSkipped: !config.install,
+      workflowCode,
+      workflowFile,
+      mcpConfigured,
+      agentLaunched: false,
+      compiled: compileResult?.success
+    });
+  } catch (err) {
+    if (err instanceof ExitPromptError) {
+      return;
+    }
+    throw err;
+  }
+}
+export {
+  generateProjectFiles,
+  handleAgentHandoff,
+  initCommand,
+  isNonInteractive,
+  resolveInitConfig,
+  runGitInit,
+  runNpmInstall,
+  scaffoldProject,
+  toWorkflowName,
+  validateProjectName
+};