create-syrinx-agent 4.4.0

package/dist/index.js

@@ -0,0 +1,1100 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+
+// src/exit-codes.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  INTERNAL: 1,
+  USAGE: 2
+};
+var CliError = class extends Error {
+  exitCode;
+  constructor(exitCode, message) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+
+// src/help.ts
+var HELP_TEXT = `create-syrinx-agent \u2014 scaffold a Syrinx voice agent project.
+
+One generator with conditional emission, not enumerated template directories:
+pick a provider per pipeline stage with flags and get back a project that
+depends on exactly those providers and typechecks out of the box.
+
+USAGE
+  npm create syrinx-agent <target-dir> [options]
+  create-syrinx-agent <target-dir> [options]
+
+PIPELINE (cascade mode \u2014 pick one provider per stage)
+  --stt <deepgram|google|elevenlabs|grok>
+  --tts <cartesia|elevenlabs|gemini|openai-tts|grok>
+  --reasoner <aisdk|kuralle|mastra>
+  --vad <silero-vad>                        optional, provider STT/endpointing owns it by default
+  --endpointing <pipecat-smart-turn|vap>     optional, provider STT owns it by default
+
+PIPELINE (speech-to-speech \u2014 exclusive with --stt/--tts)
+  --realtime <realtime|grok>
+      A speech-to-speech pipeline has no separate STT/reasoner/TTS stages.
+      Passing --stt or --tts alongside --realtime is refused.
+
+TRANSPORT
+  --transport <browser|twilio|telnyx|smartpbx>   default: browser
+  --runtime <node|cloudflare>                    default: node
+      --runtime cloudflare --transport telnyx is generated but warned as
+      deploy-unverified on the Workers edge.
+
+PRESETS (flag bundles \u2014 an explicit flag always overrides the preset)
+  --preset <phone>
+
+OPTIONS
+  --name <project-name>      default: the target directory's basename
+  --yes                      accept defaults for anything not passed, never prompt
+  --no-install, --skip-install
+                              write the project but skip \`npm install\`
+  --dry-run                  print the file list and exit; write nothing
+  --help, -h                 show this help
+  --version, -v               print the generator's version
+
+Never prompts when --yes is passed or stdin is not a TTY: missing required
+flags fail with a USAGE error naming what is missing.
+`;
+
+// src/version.ts
+var GENERATOR_VERSION = "0.1.0";
+
+// src/options.ts
+import { resolve } from "node:path";
+var STT_PROVIDERS = ["deepgram", "google", "elevenlabs", "grok"];
+var TTS_PROVIDERS = ["cartesia", "elevenlabs", "gemini", "openai-tts", "grok"];
+var REALTIME_PROVIDERS = ["realtime", "grok"];
+var REASONER_PROVIDERS = ["aisdk", "kuralle", "mastra"];
+var VAD_PROVIDERS = ["silero-vad"];
+var ENDPOINTING_PROVIDERS = ["pipecat-smart-turn", "vap"];
+var TRANSPORTS = ["browser", "twilio", "telnyx", "smartpbx"];
+var RUNTIMES = ["node", "cloudflare"];
+var PRESETS = {
+  phone: { stt: "deepgram", tts: "cartesia", reasoner: "aisdk", transport: "twilio", runtime: "node" }
+};
+function memberOf(list, value, flagName) {
+  if (!list.includes(value)) {
+    throw new CliError(EXIT_CODES.USAGE, `--${flagName} must be one of: ${list.join(", ")} (got "${value}")`);
+  }
+  return value;
+}
+function resolveOptions(raw, positionals) {
+  if (raw.preset !== void 0 && !(raw.preset in PRESETS)) {
+    throw new CliError(EXIT_CODES.USAGE, `--preset must be one of: ${Object.keys(PRESETS).join(", ")} (got "${raw.preset}")`);
+  }
+  const preset = raw.preset !== void 0 ? PRESETS[raw.preset] : void 0;
+  const sttRaw = raw.stt ?? preset?.stt;
+  const ttsRaw = raw.tts ?? preset?.tts;
+  const reasonerRaw = raw.reasoner ?? preset?.reasoner;
+  const realtimeRaw = raw.realtime;
+  if (realtimeRaw !== void 0 && (sttRaw !== void 0 || ttsRaw !== void 0)) {
+    throw new CliError(
+      EXIT_CODES.USAGE,
+      `--realtime is a speech-to-speech pipeline with no separate STT/TTS stages \u2014 it cannot be combined with ${[
+        sttRaw !== void 0 ? "--stt" : void 0,
+        ttsRaw !== void 0 ? "--tts" : void 0
+      ].filter((v) => v !== void 0).join(" and ")}.`
+    );
+  }
+  const transport = memberOf(TRANSPORTS, raw.transport ?? preset?.transport ?? "browser", "transport");
+  const runtime = memberOf(RUNTIMES, raw.runtime ?? preset?.runtime ?? "node", "runtime");
+  const skipInstall = raw["no-install"] === true || raw["skip-install"] === true;
+  const dryRun = raw["dry-run"] === true;
+  const targetDir = positionals[0];
+  const name = raw.name ?? (targetDir !== void 0 ? targetDir.split("/").filter(Boolean).at(-1) : void 0);
+  if (name === void 0 || name.length === 0) {
+    throw new CliError(EXIT_CODES.USAGE, "a target directory or --name is required, e.g. `create-syrinx-agent my-agent`");
+  }
+  const resolvedTarget = resolve(process.cwd(), targetDir ?? name);
+  if (realtimeRaw !== void 0) {
+    const realtime = memberOf(REALTIME_PROVIDERS, realtimeRaw, "realtime");
+    return { mode: "realtime", realtime, transport, runtime, name, targetDir: resolvedTarget, skipInstall, dryRun };
+  }
+  const missing = [
+    sttRaw === void 0 ? "--stt" : void 0,
+    ttsRaw === void 0 ? "--tts" : void 0,
+    reasonerRaw === void 0 ? "--reasoner" : void 0
+  ].filter((v) => v !== void 0);
+  if (missing.length > 0) {
+    throw new CliError(
+      EXIT_CODES.USAGE,
+      `missing required flag(s): ${missing.join(", ")} (or pass --realtime for a speech-to-speech pipeline, or --preset <name>)`
+    );
+  }
+  const stt = memberOf(STT_PROVIDERS, sttRaw, "stt");
+  const tts = memberOf(TTS_PROVIDERS, ttsRaw, "tts");
+  const reasoner = memberOf(REASONER_PROVIDERS, reasonerRaw, "reasoner");
+  const vad = raw.vad !== void 0 ? memberOf(VAD_PROVIDERS, raw.vad, "vad") : void 0;
+  const endpointing = raw.endpointing !== void 0 ? memberOf(ENDPOINTING_PROVIDERS, raw.endpointing, "endpointing") : void 0;
+  return { mode: "cascade", stt, tts, reasoner, vad, endpointing, transport, runtime, name, targetDir: resolvedTarget, skipInstall, dryRun };
+}
+function warningsFor(opts) {
+  const warnings = [];
+  if (opts.runtime === "cloudflare" && opts.transport === "telnyx") {
+    warnings.push(
+      "runtime=cloudflare + transport=telnyx is generated but not yet bound on the Workers edge \u2014 deploy-unverified. See @kuralle-syrinx/server-workers for current Cloudflare transport coverage before deploying."
+    );
+  }
+  return warnings;
+}
+
+// src/write-project.ts
+import { spawnSync } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+// src/providers/stt.ts
+var PKG_VERSION = "^4.3.0";
+var STT_STAGE_PROVIDERS = {
+  // packages/deepgram/src/stt.ts: DeepgramSTTPlugin, endpointingCapability.owner === "provider_stt".
+  // Config fields mirror examples/02-hello-voice-headless/src/hello-voice-agent.ts.
+  deepgram: {
+    packageName: "@kuralle-syrinx/deepgram",
+    packageVersion: PKG_VERSION,
+    className: "DeepgramSTTPlugin",
+    envKeys: [{ key: "DEEPGRAM_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef2) => [
+      `api_key: ${envRef2("DEEPGRAM_API_KEY")}`,
+      `model: "nova-3"`,
+      `sample_rate: 16000`,
+      `emit_eos_on_final: true`
+    ]
+  },
+  // packages/google/src/index.ts: GoogleSTTPlugin (Cloud Speech-to-Text v2).
+  // api_key + project_id are required config; endpointingCapability.owner === "provider_stt".
+  google: {
+    packageName: "@kuralle-syrinx/google",
+    packageVersion: PKG_VERSION,
+    className: "GoogleSTTPlugin",
+    envKeys: [
+      { key: "GOOGLE_CLOUD_SPEECH_API_KEY", required: true },
+      { key: "GOOGLE_CLOUD_PROJECT_ID", required: true }
+    ],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef2) => [
+      `api_key: ${envRef2("GOOGLE_CLOUD_SPEECH_API_KEY")}`,
+      `project_id: ${envRef2("GOOGLE_CLOUD_PROJECT_ID")}`,
+      `sample_rate: 16000`
+    ]
+  },
+  // packages/elevenlabs/src/stt.ts: ElevenLabsSTTPlugin (Scribe v2 Realtime).
+  elevenlabs: {
+    packageName: "@kuralle-syrinx/elevenlabs",
+    packageVersion: PKG_VERSION,
+    importFrom: "@kuralle-syrinx/elevenlabs/stt",
+    className: "ElevenLabsSTTPlugin",
+    envKeys: [{ key: "ELEVENLABS_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef2) => [`api_key: ${envRef2("ELEVENLABS_API_KEY")}`]
+  },
+  // packages/grok/src/stt.ts: GrokSTTPlugin. endpointingCapability.owner === "provider_stt".
+  grok: {
+    packageName: "@kuralle-syrinx/grok",
+    packageVersion: PKG_VERSION,
+    importFrom: "@kuralle-syrinx/grok/stt",
+    className: "GrokSTTPlugin",
+    envKeys: [{ key: "XAI_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: true,
+    configFields: (envRef2) => [`api_key: ${envRef2("XAI_API_KEY")}`, `language: "en"`]
+  }
+};
+
+// src/providers/tts.ts
+var PKG_VERSION2 = "^4.3.0";
+var TTS_STAGE_PROVIDERS = {
+  // packages/cartesia/src/index.ts: CartesiaTTSPlugin. Config mirrors hello-voice-agent.ts.
+  cartesia: {
+    packageName: "@kuralle-syrinx/cartesia",
+    packageVersion: PKG_VERSION2,
+    className: "CartesiaTTSPlugin",
+    envKeys: [
+      { key: "CARTESIA_API_KEY", required: true },
+      { key: "CARTESIA_VOICE_ID", required: true }
+    ],
+    usesSocketFactory: true,
+    ownsEndpointing: false,
+    configFields: (envRef2) => [`api_key: ${envRef2("CARTESIA_API_KEY")}`, `voice_id: ${envRef2("CARTESIA_VOICE_ID")}`]
+  },
+  // packages/elevenlabs/src/tts.ts: ElevenLabsTTSPlugin.
+  elevenlabs: {
+    packageName: "@kuralle-syrinx/elevenlabs",
+    packageVersion: PKG_VERSION2,
+    importFrom: "@kuralle-syrinx/elevenlabs/tts",
+    className: "ElevenLabsTTSPlugin",
+    envKeys: [
+      { key: "ELEVENLABS_API_KEY", required: true },
+      { key: "ELEVENLABS_VOICE_ID", required: true }
+    ],
+    usesSocketFactory: true,
+    ownsEndpointing: false,
+    configFields: (envRef2) => [`api_key: ${envRef2("ELEVENLABS_API_KEY")}`, `voice_id: ${envRef2("ELEVENLABS_VOICE_ID")}`]
+  },
+  // packages/gemini/src/index.ts: GeminiTTSPlugin. HTTP-based (@google/genai) — no SocketFactory.
+  gemini: {
+    packageName: "@kuralle-syrinx/gemini",
+    packageVersion: PKG_VERSION2,
+    className: "GeminiTTSPlugin",
+    envKeys: [{ key: "GOOGLE_GENERATIVE_AI_API_KEY", required: true }],
+    usesSocketFactory: false,
+    ownsEndpointing: false,
+    configFields: (envRef2) => [`api_key: ${envRef2("GOOGLE_GENERATIVE_AI_API_KEY")}`]
+  },
+  // packages/openai-tts/src/index.ts: OpenAICompatibleTTSPlugin. HTTP-based — no SocketFactory.
+  "openai-tts": {
+    packageName: "@kuralle-syrinx/openai-tts",
+    packageVersion: PKG_VERSION2,
+    className: "OpenAICompatibleTTSPlugin",
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    usesSocketFactory: false,
+    ownsEndpointing: false,
+    configFields: (envRef2) => [`api_key: ${envRef2("OPENAI_API_KEY")}`]
+  },
+  // packages/grok/src/tts.ts: GrokTTSPlugin.
+  grok: {
+    packageName: "@kuralle-syrinx/grok",
+    packageVersion: PKG_VERSION2,
+    importFrom: "@kuralle-syrinx/grok/tts",
+    className: "GrokTTSPlugin",
+    envKeys: [{ key: "XAI_API_KEY", required: true }],
+    usesSocketFactory: true,
+    ownsEndpointing: false,
+    configFields: (envRef2) => [`api_key: ${envRef2("XAI_API_KEY")}`, `voice_id: "eve"`]
+  }
+};
+
+// src/providers/reasoner.ts
+var PKG_VERSION3 = "^4.3.0";
+var OPENAI_SDK_VERSION = "^3.0.67";
+var AI_SDK_VERSION = "^6.0.0";
+var MASTRA_CORE_VERSION = "^1.41.0";
+var SYSTEM_PROMPT_CONST = "SYSTEM_PROMPT";
+var REASONER_PROVIDERS2 = {
+  // packages/aisdk/src/from-ai-sdk.ts: fromStreamText(config) -> Reasoner.
+  // Mirrors examples/02-hello-voice-headless/src/hello-voice-agent.ts.
+  aisdk: {
+    packageName: "@kuralle-syrinx/aisdk",
+    packageVersion: PKG_VERSION3,
+    extraPackages: { "@ai-sdk/openai": OPENAI_SDK_VERSION, ai: AI_SDK_VERSION },
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    importLines: () => [
+      `import { fromStreamText } from "@kuralle-syrinx/aisdk";`,
+      `import { createOpenAI } from "@ai-sdk/openai";`
+    ],
+    preludeLines: (envRef2) => [`const openai = createOpenAI({ apiKey: ${envRef2("OPENAI_API_KEY")} });`],
+    reasonerExpr: `fromStreamText({ model: openai("gpt-4.1-mini"), system: ${SYSTEM_PROMPT_CONST} })`
+  },
+  // packages/mastra/src/from-mastra.ts: fromMastraAgent(agent) -> Reasoner.
+  // Mirrors examples/02-hello-voice-headless/src/university-support-mastra.ts.
+  mastra: {
+    packageName: "@kuralle-syrinx/mastra",
+    packageVersion: PKG_VERSION3,
+    extraPackages: { "@ai-sdk/openai": OPENAI_SDK_VERSION, "@mastra/core": MASTRA_CORE_VERSION },
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    importLines: () => [
+      `import { fromMastraAgent, type MastraAgentLike } from "@kuralle-syrinx/mastra";`,
+      `import { createOpenAI } from "@ai-sdk/openai";`,
+      `import { Agent as MastraAgent } from "@mastra/core/agent";`
+    ],
+    preludeLines: (envRef2) => [
+      `const openai = createOpenAI({ apiKey: ${envRef2("OPENAI_API_KEY")} });`,
+      `const mastraAgent = new MastraAgent({`,
+      `  id: "syrinx-agent",`,
+      `  name: "syrinx-agent",`,
+      `  instructions: ${SYSTEM_PROMPT_CONST},`,
+      `  model: openai("gpt-4.1-mini"),`,
+      `});`
+    ],
+    // Structural cast to MastraAgentLike, same pattern the reference agent uses —
+    // fromMastraAgent types against a structural interface, not @mastra/core's own type.
+    reasonerExpr: `fromMastraAgent(mastraAgent as unknown as MastraAgentLike)`
+  },
+  kuralle: void 0
+};
+
+// src/providers/realtime.ts
+var PKG_VERSION4 = "^4.3.0";
+var REALTIME_PROVIDERS2 = {
+  realtime: {
+    packageName: "@kuralle-syrinx/realtime",
+    packageVersion: PKG_VERSION4,
+    envKeys: [{ key: "OPENAI_API_KEY", required: true }],
+    importLines: [`import { fromOpenAIRealtime } from "@kuralle-syrinx/realtime";`],
+    adapterExpr: (envRef2, socketFactoryIdent) => `fromOpenAIRealtime({ apiKey: ${envRef2("OPENAI_API_KEY")}, socketFactory: ${socketFactoryIdent} })`
+  },
+  grok: {
+    packageName: "@kuralle-syrinx/grok",
+    packageVersion: PKG_VERSION4,
+    envKeys: [{ key: "XAI_API_KEY", required: true }],
+    importLines: [`import { fromGrokRealtime } from "@kuralle-syrinx/grok/realtime";`],
+    adapterExpr: (envRef2, socketFactoryIdent) => `fromGrokRealtime({ apiKey: ${envRef2("XAI_API_KEY")}, socketFactory: ${socketFactoryIdent} })`
+  }
+};
+
+// src/providers/vad-endpointing.ts
+var PKG_VERSION5 = "^4.3.0";
+var VAD_SIDECAR_PROVIDERS = {
+  // packages/silero-vad/src/index.ts: SileroVADPlugin. No API key — a bundled ONNX model.
+  "silero-vad": {
+    packageName: "@kuralle-syrinx/silero-vad",
+    packageVersion: PKG_VERSION5,
+    className: "SileroVADPlugin",
+    slot: "vad",
+    envKeys: [],
+    configFields: () => []
+  }
+};
+var ENDPOINTING_SIDECAR_PROVIDERS = {
+  // packages/pipecat-smart-turn/src/index.ts: PipecatEOSPlugin. No API key — a bundled ONNX model.
+  "pipecat-smart-turn": {
+    packageName: "@kuralle-syrinx/pipecat-smart-turn",
+    packageVersion: PKG_VERSION5,
+    className: "PipecatEOSPlugin",
+    slot: "eos",
+    envKeys: [],
+    configFields: () => []
+  },
+  vap: void 0
+};
+
+// src/templates/agent-module.ts
+var SYSTEM_PROMPT = "You are a helpful voice assistant. Keep your replies short.";
+function nodeEnvRef(key) {
+  return `process.env["${key}"] ?? ""`;
+}
+function requireStage(provider, flag, value) {
+  if (provider === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--${flag} ${value} is not yet implemented by this generator`);
+  }
+  return provider;
+}
+function importLine(className, from) {
+  return `import { ${className} } from "${from}";`;
+}
+function mergeImports(lines) {
+  const IMPORT_RE = /^import \{ (.+) \} from "(.+)";$/;
+  const sourceOrder = [];
+  const namesBySource = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const match = IMPORT_RE.exec(line);
+    const names = match?.[1];
+    const from = match?.[2];
+    if (names === void 0 || from === void 0) continue;
+    let bucket = namesBySource.get(from);
+    if (bucket === void 0) {
+      bucket = [];
+      namesBySource.set(from, bucket);
+      sourceOrder.push(from);
+    }
+    for (const name of names.split(",").map((n) => n.trim())) {
+      if (!bucket.includes(name)) bucket.push(name);
+    }
+  }
+  return sourceOrder.map((from) => `import { ${(namesBySource.get(from) ?? []).join(", ")} } from "${from}";`);
+}
+function buildAgentModule(opts) {
+  if (opts.mode === "realtime") return buildRealtimeAgentModule(opts);
+  return buildCascadeAgentModule(opts);
+}
+function buildCascadeAgentModule(opts) {
+  const stt = requireStage(STT_STAGE_PROVIDERS[opts.stt], "stt", opts.stt);
+  const tts = requireStage(TTS_STAGE_PROVIDERS[opts.tts], "tts", opts.tts);
+  const reasoner = REASONER_PROVIDERS2[opts.reasoner];
+  if (reasoner === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--reasoner ${opts.reasoner} is not yet implemented by this generator`);
+  }
+  const vad = opts.vad !== void 0 ? VAD_SIDECAR_PROVIDERS[opts.vad] : void 0;
+  if (opts.vad !== void 0 && vad === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--vad ${opts.vad} is not yet implemented by this generator`);
+  }
+  const eos = opts.endpointing !== void 0 ? ENDPOINTING_SIDECAR_PROVIDERS[opts.endpointing] : void 0;
+  if (opts.endpointing !== void 0 && eos === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--endpointing ${opts.endpointing} is not yet implemented by this generator`);
+  }
+  const endpointingOwner = eos !== void 0 ? "smart_turn" : stt.ownsEndpointing ? "provider_stt" : void 0;
+  if (endpointingOwner === void 0) {
+    throw new CliError(
+      EXIT_CODES.USAGE,
+      `--stt ${opts.stt} cannot own endpointing on its own \u2014 pass --endpointing pipecat-smart-turn`
+    );
+  }
+  const imports = [
+    `import { VoiceAgentSession, type VoicePlugin } from "@kuralle-syrinx/core";`,
+    `import { ReasoningBridge } from "@kuralle-syrinx/aisdk";`,
+    importLine(stt.className, stt.importFrom ?? stt.packageName),
+    importLine(tts.className, tts.importFrom ?? tts.packageName),
+    ...vad !== void 0 ? [importLine(vad.className, vad.packageName)] : [],
+    ...eos !== void 0 ? [importLine(eos.className, eos.packageName)] : [],
+    ...reasoner.importLines(nodeEnvRef)
+  ];
+  const pluginConfigLines = [
+    `      stt: {`,
+    ...stt.configFields(nodeEnvRef).map((f) => `        ${f},`),
+    `      },`
+  ];
+  if (vad !== void 0) pluginConfigLines.push(`      vad: {},`);
+  if (eos !== void 0) pluginConfigLines.push(`      eos: {},`);
+  pluginConfigLines.push(
+    `      bridge: {},`,
+    `      tts: {`,
+    ...tts.configFields(nodeEnvRef).map((f) => `        ${f},`),
+    `      },`
+  );
+  const pluginInstanceLines = [`    stt: new ${stt.className}(),`];
+  if (vad !== void 0) pluginInstanceLines.push(`    vad: new ${vad.className}(),`);
+  if (eos !== void 0) pluginInstanceLines.push(`    eos: new ${eos.className}(),`);
+  pluginInstanceLines.push(
+    `    bridge: new ReasoningBridge(${reasoner.reasonerExpr}),`,
+    `    tts: new ${tts.className}(),`
+  );
+  return `// SPDX-License-Identifier: MIT
+//
+// Cascade voice agent: ${opts.stt} STT -> ${opts.reasoner} reasoner -> ${opts.tts} TTS.
+// Generated by create-syrinx-agent. Wired to the local dev server and to
+// \`syrinx turn\`/\`syrinx text\` through the --agent <module>#<export> seam
+// (examples/02-hello-voice-headless/scripts/dev-server.ts).
+
+${mergeImports(imports).join("\n")}
+
+const ${SYSTEM_PROMPT_CONST} = ${JSON.stringify(SYSTEM_PROMPT)};
+
+export function createAgent(): VoiceAgentSession {
+${reasoner.preludeLines(nodeEnvRef).map((l) => `  ${l}`).join("\n")}
+
+  const session = new VoiceAgentSession({
+    plugins: {
+${pluginConfigLines.join("\n")}
+    },
+    endpointingOwner: "${endpointingOwner}",
+  });
+
+  const plugins: Record<string, VoicePlugin> = {
+${pluginInstanceLines.join("\n")}
+  };
+  for (const [name, plugin] of Object.entries(plugins)) {
+    session.registerPlugin(name, plugin);
+  }
+
+  return session;
+}
+`;
+}
+function buildRealtimeAgentModule(opts) {
+  const realtime = REALTIME_PROVIDERS2[opts.realtime];
+  if (realtime === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--realtime ${opts.realtime} is not yet implemented by this generator`);
+  }
+  const imports = [
+    `import { VoiceAgentSession } from "@kuralle-syrinx/core";`,
+    `import { RealtimeBridge } from "@kuralle-syrinx/realtime";`,
+    `import { createNodeWsSocket } from "@kuralle-syrinx/ws/node";`,
+    ...realtime.importLines
+  ];
+  return `// SPDX-License-Identifier: MIT
+//
+// Speech-to-speech voice agent: ${opts.realtime} realtime. Generated by
+// create-syrinx-agent. Wired to the local dev server and to
+// \`syrinx turn\`/\`syrinx text\` through the --agent <module>#<export> seam
+// (examples/02-hello-voice-headless/scripts/dev-server.ts).
+
+${mergeImports(imports).join("\n")}
+
+export function createAgent(): VoiceAgentSession {
+  const adapter = ${realtime.adapterExpr(nodeEnvRef, "createNodeWsSocket")};
+  const bridge = new RealtimeBridge(adapter);
+
+  const session = new VoiceAgentSession({
+    plugins: { realtime: {} },
+    endpointingOwner: "timer",
+  });
+  session.registerPlugin("realtime", bridge);
+
+  return session;
+}
+`;
+}
+
+// src/templates/dev-server.ts
+var TRANSPORT_SERVERS = {
+  browser: { factoryName: "createVoiceWebSocketServer", extraOptions: [`path: "/ws"`], urlPath: "/ws" },
+  twilio: { factoryName: "createTwilioMediaStreamServer", extraOptions: [], urlPath: "/" },
+  telnyx: { factoryName: "createTelnyxMediaStreamServer", extraOptions: [], urlPath: "/" },
+  smartpbx: { factoryName: "createSmartPbxMediaStreamServer", extraOptions: [], urlPath: "/" }
+};
+function buildDevServer(transport) {
+  const binding = TRANSPORT_SERVERS[transport];
+  const optionsLines = [`    port,`, `    host,`, ...binding.extraOptions.map((l) => `    ${l},`), `    createSession: () => factory(),`];
+  return `// SPDX-License-Identifier: MIT
+//
+// Local dev server \u2014 wires YOUR agent module to a ${transport} transport host.
+//
+//   pnpm dev -- --agent ./src/agent.ts#createAgent
+//
+// --agent is <module>[#namedExport]; the export is a zero-arg factory
+// returning a VoiceAgentSession. Same seam as
+// examples/02-hello-voice-headless/scripts/dev-server.ts.
+
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+import { ${binding.factoryName}, installGracefulShutdown } from "@kuralle-syrinx/server-websocket";
+import type { VoiceAgentSession } from "@kuralle-syrinx/core";
+
+export type SessionFactory = () => VoiceAgentSession | Promise<VoiceAgentSession>;
+
+/**
+ * Resolve \`--agent <module>[#export]\` to a factory. Fails loudly and
+ * specifically \u2014 a dev server that silently falls back to a different agent
+ * than the one you asked for is worse than one that refuses to start.
+ */
+async function resolveAgentFactory(spec: string | undefined): Promise<{ factory: SessionFactory; label: string }> {
+  if (!spec) throw new Error("--agent <module>[#export] is required, e.g. --agent ./src/agent.ts#createAgent");
+  const [modulePath, exportName] = spec.split("#");
+  if (!modulePath) throw new Error(\`--agent needs a module path, got: \${spec}\`);
+  const abs = isAbsolute(modulePath) ? modulePath : resolve(process.cwd(), modulePath);
+  const mod = (await import(pathToFileURL(abs).href)) as Record<string, unknown>;
+
+  const picked = exportName ? mod[exportName] : (mod["default"] ?? mod["createAgent"] ?? mod["createSession"]);
+  if (typeof picked !== "function") {
+    const available = Object.keys(mod).filter((k) => typeof mod[k] === "function");
+    throw new Error(
+      \`\${abs} has no callable export \${exportName ? \`"\${exportName}"\` : "(default, createAgent, or createSession)"}. \` +
+        \`Callable exports: \${available.length > 0 ? available.join(", ") : "(none)"}\`,
+    );
+  }
+  return { factory: picked as SessionFactory, label: \`\${modulePath}\${exportName ? \`#\${exportName}\` : ""}\` };
+}
+
+function flag(argv: readonly string[], name: string): string | undefined {
+  const i = argv.indexOf(name);
+  return i >= 0 ? argv[i + 1] : undefined;
+}
+
+function readPort(): number {
+  const raw = process.env["SYRINX_DEV_PORT"]?.trim();
+  if (!raw) return 4173;
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535) throw new Error(\`invalid SYRINX_DEV_PORT: \${raw}\`);
+  return port;
+}
+
+async function main(): Promise<void> {
+  const { factory, label } = await resolveAgentFactory(flag(process.argv.slice(2), "--agent"));
+  const port = readPort();
+  const host = process.env["SYRINX_DEV_HOST"]?.trim() || "127.0.0.1";
+
+  const server = await ${binding.factoryName}({
+${optionsLines.join("\n")}
+  });
+
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("expected TCP server address");
+  console.log(\`Syrinx dev server (${transport}): ws://\${host}:\${String(address.port)}${binding.urlPath}\`);
+  console.log(\`Agent: \${label}\`);
+
+  installGracefulShutdown(server, { drainDeadlineMs: 10_000, onClosed: () => process.exit(0) });
+}
+
+void main().catch((err: unknown) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});
+`;
+}
+
+// src/templates/package-json.ts
+var CORE_VERSION = "^4.3.0";
+function transportPackage() {
+  return { "@kuralle-syrinx/server-websocket": CORE_VERSION, ws: "^8.21.0" };
+}
+function collectDependencies(opts) {
+  const deps = {
+    "@kuralle-syrinx/core": CORE_VERSION,
+    ...transportPackage()
+  };
+  if (opts.mode === "cascade") {
+    const stt = STT_STAGE_PROVIDERS[opts.stt];
+    const tts = TTS_STAGE_PROVIDERS[opts.tts];
+    const reasoner = REASONER_PROVIDERS2[opts.reasoner];
+    if (stt) deps[stt.packageName] = stt.packageVersion;
+    if (tts) deps[tts.packageName] = tts.packageVersion;
+    deps["@kuralle-syrinx/aisdk"] = CORE_VERSION;
+    if (reasoner) {
+      deps[reasoner.packageName] = reasoner.packageVersion;
+      Object.assign(deps, reasoner.extraPackages);
+    }
+    const vad = opts.vad !== void 0 ? VAD_SIDECAR_PROVIDERS[opts.vad] : void 0;
+    if (vad) deps[vad.packageName] = vad.packageVersion;
+    const eos = opts.endpointing !== void 0 ? ENDPOINTING_SIDECAR_PROVIDERS[opts.endpointing] : void 0;
+    if (eos) deps[eos.packageName] = eos.packageVersion;
+  } else {
+    const realtime = REALTIME_PROVIDERS2[opts.realtime];
+    deps["@kuralle-syrinx/realtime"] = CORE_VERSION;
+    deps["@kuralle-syrinx/ws"] = CORE_VERSION;
+    if (realtime) deps[realtime.packageName] = realtime.packageVersion;
+  }
+  return deps;
+}
+function buildPackageJson(opts) {
+  const dependencies = collectDependencies(opts);
+  const agentSpec = "./src/agent.ts#createAgent";
+  const scripts = {
+    dev: `tsx scripts/dev-server.ts --agent ${agentSpec}`,
+    "check:typecheck": "tsc --noEmit",
+    "check:turn": `syrinx turn --in test/fixtures/smoke.wav --agent ${agentSpec} --json`
+  };
+  const devDependencies = {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    tsx: "^4.20.0",
+    typescript: "^5.7.0"
+  };
+  if (opts.runtime === "cloudflare") {
+    dependencies["@kuralle-syrinx/cf-agents"] = CORE_VERSION;
+    dependencies["agents"] = "0.14.0";
+    dependencies["ai"] = "^6.0.0";
+    devDependencies["@cloudflare/workers-types"] = "^4.20260601.1";
+    devDependencies["wrangler"] = "4.97.0";
+    scripts["check:wrangler-dry-run"] = "wrangler deploy --dry-run";
+  }
+  const pkg = {
+    name: opts.name,
+    version: "0.0.1",
+    private: true,
+    type: "module",
+    license: "MIT",
+    scripts,
+    dependencies: sortKeys({ ...dependencies, "@kuralle-syrinx/cli": CORE_VERSION }),
+    devDependencies: sortKeys(devDependencies)
+  };
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+}
+function sortKeys(obj) {
+  const out = {};
+  for (const key of Object.keys(obj).sort()) out[key] = obj[key];
+  return out;
+}
+
+// src/templates/env-example.ts
+function collectEnvKeys(opts) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (specs) => {
+    for (const spec of specs) {
+      if (seen.has(spec.key)) continue;
+      seen.add(spec.key);
+      keys.push(spec);
+    }
+  };
+  if (opts.mode === "cascade") {
+    const stt = STT_STAGE_PROVIDERS[opts.stt];
+    const tts = TTS_STAGE_PROVIDERS[opts.tts];
+    const reasoner = REASONER_PROVIDERS2[opts.reasoner];
+    if (stt) add(stt.envKeys);
+    if (tts) add(tts.envKeys);
+    if (reasoner) add(reasoner.envKeys);
+    const vad = opts.vad !== void 0 ? VAD_SIDECAR_PROVIDERS[opts.vad] : void 0;
+    if (vad) add(vad.envKeys);
+    const eos = opts.endpointing !== void 0 ? ENDPOINTING_SIDECAR_PROVIDERS[opts.endpointing] : void 0;
+    if (eos) add(eos.envKeys);
+  } else {
+    const realtime = REALTIME_PROVIDERS2[opts.realtime];
+    if (realtime) add(realtime.envKeys);
+  }
+  return keys;
+}
+function buildEnvExample(opts) {
+  const keys = collectEnvKeys(opts);
+  const lines = [
+    "# Generated by create-syrinx-agent \u2014 exactly the keys this combination needs.",
+    "# Copy to .env and fill in.",
+    "",
+    ...keys.map((k) => `${k.key}=`),
+    "",
+    "# Optional \u2014 local dev server bind (defaults: 127.0.0.1:4173)",
+    "SYRINX_DEV_PORT=",
+    "SYRINX_DEV_HOST=",
+    ""
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
+// src/templates/agents-md.ts
+function buildAgentsMd(opts) {
+  const pipelineLine = opts.mode === "cascade" ? `${opts.stt} STT -> ${opts.reasoner} reasoner -> ${opts.tts} TTS (cascade)` : `${opts.realtime} realtime (speech-to-speech, no separate STT/TTS stages)`;
+  return `# AGENTS.md
+
+This project was generated by \`create-syrinx-agent\`.
+
+Pipeline: ${pipelineLine}
+Transport: ${opts.transport} \xB7 Runtime: ${opts.runtime}
+
+## What a coding agent CAN verify here
+
+- \`pnpm check:typecheck\` (\`tsc --noEmit\`) \u2014 the agent module and dev server compile.
+- \`pnpm check:turn\` \u2014 runs \`syrinx turn --in test/fixtures/smoke.wav --agent ./src/agent.ts#createAgent --json\`.
+  Given a fixture **with** a recorded expected transcript (a \`.json\` sidecar produced by the
+  Studio's "Save as fixture"), this asserts the replayed transcript matches and **exits non-zero
+  on drift** \u2014 a real regression check, not just a smoke test. The bundled \`test/fixtures/smoke.wav\`
+  ships with no sidecar, so as generated this only proves the pipeline runs end-to-end and produces
+  *some* transcript/reply/audio; record your own fixture with the Studio for an assertion that
+  actually catches regressions.
+- Exit codes and JSON output from \`syrinx turn\` / \`syrinx text\` \u2014 parseable, deterministic,
+  scriptable.
+
+Both checks need real provider credentials in \`.env\` (see \`.env.example\`) \u2014 without them
+\`check:turn\` fails at the provider call, not at a code defect.
+
+## What a coding agent CANNOT verify here
+
+A coding agent can assert transcripts, exit codes, and latency numbers. It **cannot** judge:
+
+- Whether barge-in feels natural (the timing a human perceives as responsive vs. jarring).
+- Whether a pause reads as "thinking" or as a hang \u2014 same latency number, different human read.
+- Whether a synthesized voice sounds warm, robotic, or off \u2014 TTS quality is a perceptual judgment.
+
+Those need a human in the Syrinx Studio, listening. Do not treat a green \`check:turn\` as proof the
+agent is pleasant to talk to \u2014 it only proves the transcript matched (or that the pipeline ran, for
+the unsigned bundled fixture).
+
+## \`tsx\` vs plain \`node\`
+
+\`--agent\` pointed at a \`.ts\` module (as in the scripts above) needs \`tsx\` \u2014 Node's built-in type
+stripping does not do TypeScript's \`.js\`-import-resolves-to-\`.ts\` remapping that this project's
+imports rely on. Built JS (after a bundler step) runs fine under plain \`node\`. Every script this
+generator wrote already invokes \`tsx\`; if you write your own, do the same for a \`.ts\` --agent target.
+
+## Layout
+
+- \`src/agent.ts\` \u2014 \`createAgent()\`, the \`--agent\` seam's factory export.
+- \`scripts/dev-server.ts\` \u2014 local dev server (\`pnpm dev\`), wraps \`createAgent()\` in a
+  ${opts.transport} transport host.
+- \`test/fixtures/smoke.wav\` \u2014 bundled silence fixture for \`check:turn\`.
+- \`.env.example\` \u2014 exactly the provider keys this combination needs.
+`;
+}
+
+// src/templates/tsconfig.ts
+function buildTsconfig(runtime) {
+  const types = runtime === "cloudflare" ? ["node", "@cloudflare/workers-types"] : ["node"];
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      strict: true,
+      skipLibCheck: true,
+      noEmit: true,
+      types
+    },
+    include: ["src/**/*.ts", "scripts/**/*.ts"]
+  };
+  return `${JSON.stringify(tsconfig, null, 2)}
+`;
+}
+
+// src/templates/fixture.ts
+var SAMPLE_RATE = 16e3;
+var DURATION_SECONDS = 0.5;
+var CHANNELS = 1;
+var BITS_PER_SAMPLE = 16;
+function buildSmokeWav() {
+  const numSamples = Math.floor(SAMPLE_RATE * DURATION_SECONDS);
+  const dataBytes = numSamples * CHANNELS * (BITS_PER_SAMPLE / 8);
+  const buffer = Buffer.alloc(44 + dataBytes);
+  buffer.write("RIFF", 0, "ascii");
+  buffer.writeUInt32LE(36 + dataBytes, 4);
+  buffer.write("WAVE", 8, "ascii");
+  buffer.write("fmt ", 12, "ascii");
+  buffer.writeUInt32LE(16, 16);
+  buffer.writeUInt16LE(1, 20);
+  buffer.writeUInt16LE(CHANNELS, 22);
+  buffer.writeUInt32LE(SAMPLE_RATE, 24);
+  buffer.writeUInt32LE(SAMPLE_RATE * CHANNELS * (BITS_PER_SAMPLE / 8), 28);
+  buffer.writeUInt16LE(CHANNELS * (BITS_PER_SAMPLE / 8), 32);
+  buffer.writeUInt16LE(BITS_PER_SAMPLE, 34);
+  buffer.write("data", 36, "ascii");
+  buffer.writeUInt32LE(dataBytes, 40);
+  return buffer;
+}
+
+// src/templates/cloudflare-worker.ts
+var SYSTEM_PROMPT2 = "You are a helpful voice assistant. Keep your replies short.";
+function envRef(key) {
+  return `env.${key}`;
+}
+function importLine2(className, from) {
+  return `import { ${className} } from "${from}";`;
+}
+function requireStage2(provider, flag, value) {
+  if (provider === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--${flag} ${value} is not yet implemented by this generator`);
+  }
+  return provider;
+}
+function cfTransport(transport) {
+  if (transport === "browser") return "edge";
+  if (transport === "twilio" || transport === "telnyx") return transport;
+  throw new CliError(
+    EXIT_CODES.USAGE,
+    `--runtime cloudflare has no ${transport} transport binding in @kuralle-syrinx/cf-agents (only edge/twilio/telnyx) \u2014 use --transport browser, twilio, or telnyx`
+  );
+}
+function envInterface(keys) {
+  const lines = keys.map((k) => `  readonly ${k.key}: string;`);
+  return `interface Env extends Record<string, unknown> {
+${lines.join("\n")}
+}`;
+}
+function buildCloudflareWorkerSource(opts) {
+  const transport = cfTransport(opts.transport);
+  const envKeys = collectEnvKeys(opts);
+  if (opts.mode === "cascade") {
+    if (opts.vad !== void 0 || opts.endpointing !== void 0) {
+      throw new CliError(
+        EXIT_CODES.USAGE,
+        "--vad/--endpointing are not yet implemented for --runtime cloudflare by this generator"
+      );
+    }
+    const stt = requireStage2(STT_STAGE_PROVIDERS[opts.stt], "stt", opts.stt);
+    const tts = requireStage2(TTS_STAGE_PROVIDERS[opts.tts], "tts", opts.tts);
+    const reasoner = REASONER_PROVIDERS2[opts.reasoner];
+    if (reasoner === void 0) {
+      throw new CliError(EXIT_CODES.USAGE, `--reasoner ${opts.reasoner} is not yet implemented by this generator`);
+    }
+    const sttNew = stt.usesSocketFactory ? `new ${stt.className}(createWorkersSocket)` : `new ${stt.className}()`;
+    const ttsNew = tts.usesSocketFactory ? `new ${tts.className}(createWorkersSocket)` : `new ${tts.className}()`;
+    const needsWorkersSocket = stt.usesSocketFactory || tts.usesSocketFactory;
+    const imports2 = [
+      `import { Agent, routeAgentRequest } from "agents";`,
+      `import { withVoice } from "@kuralle-syrinx/cf-agents";`,
+      importLine2(stt.className, stt.importFrom ?? stt.packageName),
+      importLine2(tts.className, tts.importFrom ?? tts.packageName),
+      ...needsWorkersSocket ? [`import { createWorkersSocket } from "@kuralle-syrinx/ws/workers";`] : [],
+      ...reasoner.importLines(envRef)
+    ];
+    return `// SPDX-License-Identifier: MIT
+//
+// Cascade voice agent on Cloudflare Workers: ${opts.stt} STT -> ${opts.reasoner} reasoner -> ${opts.tts} TTS.
+// Generated by create-syrinx-agent. Mirrors examples/03-cf-agent-voice and
+// packages/cf-agents/README.md.
+
+${imports2.join("\n")}
+
+${envInterface(envKeys)}
+
+const ${SYSTEM_PROMPT_CONST} = ${JSON.stringify(SYSTEM_PROMPT2)};
+
+export class VoiceAgent extends withVoice<Env, typeof Agent<Env>>(Agent<Env>, {
+  transport: "${transport}",
+  pipeline: {
+    kind: "cascaded",
+    stt: (env) => ({
+      plugin: ${sttNew},
+      config: {
+${stt.configFields(envRef).map((f) => `        ${f},`).join("\n")}
+      },
+    }),
+    tts: (env) => ({
+      plugin: ${ttsNew},
+      config: {
+${tts.configFields(envRef).map((f) => `        ${f},`).join("\n")}
+      },
+    }),
+  },
+  reasoner: (env) => {
+${reasoner.preludeLines(envRef).map((l) => `    ${l}`).join("\n")}
+    return ${reasoner.reasonerExpr};
+  },
+}) {}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return (await routeAgentRequest(request, env)) ?? new Response("Not found", { status: 404 });
+  },
+};
+`;
+  }
+  const realtime = REALTIME_PROVIDERS2[opts.realtime];
+  if (realtime === void 0) {
+    throw new CliError(EXIT_CODES.USAGE, `--realtime ${opts.realtime} is not yet implemented by this generator`);
+  }
+  const imports = [
+    `import { Agent, routeAgentRequest } from "agents";`,
+    `import { withVoice } from "@kuralle-syrinx/cf-agents";`,
+    `import { createWorkersSocket } from "@kuralle-syrinx/ws/workers";`,
+    ...realtime.importLines
+  ];
+  return `// SPDX-License-Identifier: MIT
+//
+// Speech-to-speech voice agent on Cloudflare Workers: ${opts.realtime} realtime.
+// Generated by create-syrinx-agent. Mirrors examples/03-cf-agent-voice and
+// packages/cf-agents/README.md.
+
+${imports.join("\n")}
+
+${envInterface(envKeys)}
+
+export class VoiceAgent extends withVoice<Env, typeof Agent<Env>>(Agent<Env>, {
+  transport: "${transport}",
+  pipeline: {
+    kind: "realtime",
+    front: (env) => ${realtime.adapterExpr(envRef, "createWorkersSocket")},
+  },
+}) {}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return (await routeAgentRequest(request, env)) ?? new Response("Not found", { status: 404 });
+  },
+};
+`;
+}
+function buildWranglerJsonc(opts) {
+  const wrangler = {
+    $schema: "node_modules/wrangler/config-schema.json",
+    name: opts.name,
+    main: "src/index.ts",
+    compatibility_date: "2026-06-01",
+    compatibility_flags: ["nodejs_compat"],
+    durable_objects: { bindings: [{ name: "VoiceAgent", class_name: "VoiceAgent" }] },
+    migrations: [{ tag: "v1", new_sqlite_classes: ["VoiceAgent"] }]
+  };
+  return `${JSON.stringify(wrangler, null, 2)}
+`;
+}
+
+// src/write-project.ts
+function buildFileMap(opts) {
+  const files = [
+    { relPath: "package.json", content: buildPackageJson(opts) },
+    { relPath: "tsconfig.json", content: buildTsconfig(opts.runtime) },
+    { relPath: ".env.example", content: buildEnvExample(opts) },
+    { relPath: "AGENTS.md", content: buildAgentsMd(opts) },
+    { relPath: "src/agent.ts", content: buildAgentModule(opts) },
+    { relPath: "scripts/dev-server.ts", content: buildDevServer(opts.transport) },
+    { relPath: "test/fixtures/smoke.wav", content: buildSmokeWav() }
+  ];
+  if (opts.runtime === "cloudflare") {
+    files.push(
+      { relPath: "src/index.ts", content: buildCloudflareWorkerSource(opts) },
+      { relPath: "wrangler.jsonc", content: buildWranglerJsonc(opts) }
+    );
+  }
+  return files;
+}
+async function writeProject(targetDir, files) {
+  for (const file of files) {
+    const abs = join(targetDir, file.relPath);
+    await mkdir(dirname(abs), { recursive: true });
+    await writeFile(abs, file.content);
+  }
+}
+function runNpmInstall(targetDir) {
+  const result = spawnSync("npm", ["install"], { cwd: targetDir, stdio: "inherit" });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`npm install exited with code ${String(result.status)}`);
+}
+
+// src/generate.ts
+async function runGenerate(values, positionals, io) {
+  const opts = resolveOptions(values, positionals);
+  for (const warning of warningsFor(opts)) {
+    io.stderr(`warning: ${warning}`);
+  }
+  const files = buildFileMap(opts);
+  if (opts.dryRun) {
+    io.stdout(`Would write ${String(files.length)} file(s) to ${opts.targetDir}:`);
+    for (const file of files) io.stdout(`  ${file.relPath}`);
+    return;
+  }
+  await writeProject(opts.targetDir, files);
+  io.stdout(`Wrote ${String(files.length)} file(s) to ${opts.targetDir}`);
+  if (opts.skipInstall) {
+    io.stdout("Skipped install (--no-install). Run `npm install` inside the project next.");
+    return;
+  }
+  io.stdout(`Installing dependencies in ${opts.name}/ ...`);
+  runNpmInstall(opts.targetDir);
+  io.stdout("Done.");
+}
+
+// src/cli.ts
+var defaultIO = {
+  stdout: (line) => {
+    process.stdout.write(`${line}
+`);
+  },
+  stderr: (line) => {
+    process.stderr.write(`${line}
+`);
+  }
+};
+var PARSE_OPTIONS = {
+  "help": { type: "boolean", short: "h" },
+  "version": { type: "boolean", short: "v" },
+  "stt": { type: "string" },
+  "tts": { type: "string" },
+  "realtime": { type: "string" },
+  "reasoner": { type: "string" },
+  "vad": { type: "string" },
+  "endpointing": { type: "string" },
+  "transport": { type: "string" },
+  "runtime": { type: "string" },
+  "preset": { type: "string" },
+  "name": { type: "string" },
+  "yes": { type: "boolean" },
+  "no-install": { type: "boolean" },
+  "skip-install": { type: "boolean" },
+  "dry-run": { type: "boolean" }
+};
+async function main(argv, io = defaultIO) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    io.stdout(HELP_TEXT);
+    return EXIT_CODES.SUCCESS;
+  }
+  if (argv.includes("--version") || argv.includes("-v")) {
+    io.stdout(GENERATOR_VERSION);
+    return EXIT_CODES.SUCCESS;
+  }
+  let parsed;
+  try {
+    parsed = parseArgs({ args: [...argv], options: PARSE_OPTIONS, allowPositionals: true });
+  } catch (err) {
+    io.stderr(err instanceof Error ? err.message : String(err));
+    return EXIT_CODES.USAGE;
+  }
+  try {
+    await runGenerate(parsed.values, parsed.positionals, io);
+    return EXIT_CODES.SUCCESS;
+  } catch (err) {
+    if (err instanceof CliError) {
+      io.stderr(err.message);
+      return err.exitCode;
+    }
+    io.stderr(err instanceof Error ? err.stack ?? err.message : String(err));
+    return EXIT_CODES.INTERNAL;
+  }
+}
+
+// src/index.ts
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map