@crossdelta/platform-sdk 0.19.0 → 0.19.3

package/dist/facade.mjs

@@ -0,0 +1,2221 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// cli/src/config/constants.ts
+var CLI_VERSION, LOCK_FILES;
+var init_constants = __esm({
+  "cli/src/config/constants.ts"() {
+    "use strict";
+    CLI_VERSION = process.env.npm_package_version || "0.0.0";
+    LOCK_FILES = [
+      "bun.lock",
+      "bun.lockb",
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml"
+    ];
+  }
+});
+
+// cli/src/utils/ascii-chart.ts
+import chalk from "chalk";
+var init_ascii_chart = __esm({
+  "cli/src/utils/ascii-chart.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/core/errors/types.ts
+var init_types = __esm({
+  "cli/src/core/errors/types.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/core/errors/cli-error.ts
+var init_cli_error = __esm({
+  "cli/src/core/errors/cli-error.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// cli/src/core/errors/handler.ts
+import chalk2 from "chalk";
+var init_handler = __esm({
+  "cli/src/core/errors/handler.ts"() {
+    "use strict";
+    init_cli_error();
+    init_types();
+  }
+});
+
+// cli/src/core/errors/index.ts
+var init_errors = __esm({
+  "cli/src/core/errors/index.ts"() {
+    "use strict";
+    init_cli_error();
+    init_handler();
+    init_types();
+  }
+});
+
+// cli/src/core/filesystem/watcher.ts
+import { existsSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import chokidar from "chokidar";
+var init_watcher = __esm({
+  "cli/src/core/filesystem/watcher.ts"() {
+    "use strict";
+    init_utils();
+    init_config();
+  }
+});
+
+// cli/src/utils/create-workflow-command.ts
+import chalk3 from "chalk";
+import { Command } from "commander";
+import { Listr } from "listr2";
+var init_create_workflow_command = __esm({
+  "cli/src/utils/create-workflow-command.ts"() {
+    "use strict";
+    init_errors();
+    init_watcher();
+    init_config();
+  }
+});
+
+// cli/src/utils/debounce.ts
+var init_debounce = __esm({
+  "cli/src/utils/debounce.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/utils/deep.ts
+var init_deep = __esm({
+  "cli/src/utils/deep.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/utils/process.ts
+import { execaSync } from "execa";
+var init_process = __esm({
+  "cli/src/utils/process.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/utils/environment.ts
+var init_environment = __esm({
+  "cli/src/utils/environment.ts"() {
+    "use strict";
+    init_process();
+  }
+});
+
+// cli/src/utils/fs.ts
+import { readdirSync } from "fs";
+import { dirname, isAbsolute, join as join2, normalize, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { packageUpSync } from "package-up";
+import { rimraf } from "rimraf";
+function getCliRoot() {
+  const packageJsonPath = packageUpSync({ cwd: dirname(getModuleFilename()) });
+  if (!packageJsonPath) {
+    throw new Error("Could not find package.json");
+  }
+  return dirname(packageJsonPath);
+}
+var getModuleFilename;
+var init_fs = __esm({
+  "cli/src/utils/fs.ts"() {
+    "use strict";
+    init_errors();
+    init_config();
+    getModuleFilename = () => {
+      if (typeof import.meta?.url === "string") {
+        return fileURLToPath(import.meta.url);
+      }
+      return process.cwd();
+    };
+  }
+});
+
+// cli/src/utils/logger.ts
+import chalk4 from "chalk";
+var init_logger = __esm({
+  "cli/src/utils/logger.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/utils/merge-contexts.ts
+var init_merge_contexts = __esm({
+  "cli/src/utils/merge-contexts.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/utils/tasks.ts
+import chalk5 from "chalk";
+var init_tasks = __esm({
+  "cli/src/utils/tasks.ts"() {
+    "use strict";
+  }
+});
+
+// cli/src/utils/index.ts
+var init_utils = __esm({
+  "cli/src/utils/index.ts"() {
+    "use strict";
+    init_ascii_chart();
+    init_create_workflow_command();
+    init_debounce();
+    init_deep();
+    init_environment();
+    init_fs();
+    init_logger();
+    init_merge_contexts();
+    init_process();
+    init_tasks();
+  }
+});
+
+// cli/src/core/packages/config.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, resolve as resolve2 } from "path";
+var readJsonSync, readJSONSync, DEFAULT_WORKSPACE_PATHS, parseJsonFile, extractPathValue, getDirName, getParentDir, hasWorkspaceIndicators, isWorkspaceRoot, findWorkspaceRootDir, findWorkspaceRoot, getWorkspacePackageJson, getWorkspacePathsConfig, getContractsConfig, getRootPackageScope, readPackageConfig, _pkgJson, getPkgJson, pkgJson, discoverAvailableServices;
+var init_config = __esm({
+  "cli/src/core/packages/config.ts"() {
+    "use strict";
+    init_constants();
+    init_utils();
+    readJsonSync = (path) => JSON.parse(readFileSync(path, "utf-8"));
+    readJSONSync = readJsonSync;
+    DEFAULT_WORKSPACE_PATHS = {
+      services: "services",
+      apps: "apps",
+      packages: "packages",
+      contracts: "packages/contracts"
+    };
+    parseJsonFile = (path) => {
+      if (!existsSync2(path)) return null;
+      try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+      } catch {
+        return null;
+      }
+    };
+    extractPathValue = (pathConfig, defaultValue) => {
+      if (typeof pathConfig === "string") return pathConfig;
+      if (typeof pathConfig === "object" && pathConfig !== null && "path" in pathConfig) {
+        return pathConfig.path;
+      }
+      return defaultValue;
+    };
+    getDirName = (path) => path.split("/").pop() || "workspace";
+    getParentDir = (dir) => {
+      const parent = dir.slice(0, dir.lastIndexOf("/"));
+      return parent === dir ? null : parent;
+    };
+    hasWorkspaceIndicators = (pkg, dir) => {
+      if (!pkg.workspaces) return false;
+      if (pkg.pf) return true;
+      if (existsSync2(join3(dir, "turbo.json"))) return true;
+      const hasLockFile = LOCK_FILES.some((f) => existsSync2(join3(dir, f)));
+      const hasInfraDir = existsSync2(join3(dir, "infra"));
+      return hasLockFile && hasInfraDir;
+    };
+    isWorkspaceRoot = (dir) => {
+      const pkg = parseJsonFile(join3(dir, "package.json"));
+      return pkg ? hasWorkspaceIndicators(pkg, dir) : false;
+    };
+    findWorkspaceRootDir = (startDir) => {
+      let dir = startDir;
+      while (dir) {
+        if (isWorkspaceRoot(dir)) return dir;
+        dir = getParentDir(dir);
+      }
+      return null;
+    };
+    findWorkspaceRoot = () => {
+      const root = findWorkspaceRootDir(process.cwd());
+      if (!root) {
+        throw new Error(
+          `
+\x1B[31m\u2716\x1B[0m Not in a workspace directory
+
+Current directory: ${process.cwd()}
+
+This command must be run from within a workspace created with \x1B[36mpf new workspace\x1B[0m
+
+To create a new workspace, run:
+
+  \x1B[36mpf new workspace my-platform\x1B[0m
+`
+        );
+      }
+      return root;
+    };
+    getWorkspacePackageJson = (workspaceRoot) => {
+      const root = workspaceRoot ?? findWorkspaceRoot();
+      return parseJsonFile(join3(root, "package.json"));
+    };
+    getWorkspacePathsConfig = (workspaceRoot) => {
+      const pkg = getWorkspacePackageJson(workspaceRoot);
+      if (!pkg?.pf?.paths) return DEFAULT_WORKSPACE_PATHS;
+      const { paths } = pkg.pf;
+      return {
+        services: extractPathValue(paths.services, DEFAULT_WORKSPACE_PATHS.services),
+        apps: extractPathValue(paths.apps, DEFAULT_WORKSPACE_PATHS.apps),
+        packages: extractPathValue(paths.packages, DEFAULT_WORKSPACE_PATHS.packages),
+        contracts: extractPathValue(paths.contracts, DEFAULT_WORKSPACE_PATHS.contracts)
+      };
+    };
+    getContractsConfig = (workspaceRoot) => {
+      const root = workspaceRoot ?? findWorkspaceRoot();
+      const paths = getWorkspacePathsConfig(root);
+      const contractsPath = join3(root, paths.contracts);
+      const contractsPkg = parseJsonFile(join3(contractsPath, "package.json"));
+      const packageName = contractsPkg?.name ?? `${getRootPackageScope()}/contracts`;
+      return {
+        packagePath: contractsPath,
+        eventsPath: join3(contractsPath, "src", "events"),
+        indexPath: join3(contractsPath, "src", "index.ts"),
+        relativePath: paths.contracts,
+        packageName
+      };
+    };
+    getRootPackageScope = () => {
+      const rootPath = findWorkspaceRoot();
+      const pkg = parseJsonFile(join3(rootPath, "package.json"));
+      const fallbackScope = `@${getDirName(rootPath)}`;
+      if (!pkg?.name) return fallbackScope;
+      if (pkg.name.startsWith("@")) {
+        return pkg.name.split("/")[0];
+      }
+      return `@${pkg.name}`;
+    };
+    readPackageConfig = (relativePath) => {
+      const root = getCliRoot();
+      return readJSONSync(resolve2(root, relativePath));
+    };
+    _pkgJson = null;
+    getPkgJson = () => {
+      if (!_pkgJson) {
+        _pkgJson = readPackageConfig("package.json");
+      }
+      return _pkgJson;
+    };
+    pkgJson = new Proxy({}, {
+      get: (_, prop) => getPkgJson()[prop]
+    });
+    discoverAvailableServices = (workspaceRoot) => {
+      const root = workspaceRoot ?? findWorkspaceRoot();
+      const paths = getWorkspacePathsConfig(root);
+      const servicesDir = join3(root, paths.services);
+      if (!existsSync2(servicesDir)) return [];
+      try {
+        const entries = readdirSync2(servicesDir, { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => `${paths.services}/${entry.name}`).sort();
+      } catch {
+        return [];
+      }
+    };
+  }
+});
+
+// cli/src/core/facade/index.ts
+import { readdir } from "fs/promises";
+import { dirname as dirname5, join as join13 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { runFlow as flowcoreRunFlow } from "@crossdelta/flowcore";
+
+// cli/src/core/plugins/loader.ts
+var defaultLogger = {
+  debug: () => {
+  },
+  info: console.log,
+  warn: console.warn,
+  error: console.error
+};
+var isObject = (val) => val !== null && typeof val === "object";
+var isNonEmptyString = (val) => typeof val === "string" && val.length > 0;
+var isString = (val) => typeof val === "string";
+var isFunction = (val) => typeof val === "function";
+var validateCommand = (cmd, index) => {
+  if (!isObject(cmd)) return [`commands[${index}]: must be an object`];
+  return [
+    !isNonEmptyString(cmd.name) && `commands[${index}]: missing or invalid 'name'`,
+    !isString(cmd.description) && `commands[${index}]: missing or invalid 'description'`,
+    !Array.isArray(cmd.args) && `commands[${index}]: missing 'args' array`,
+    !Array.isArray(cmd.options) && `commands[${index}]: missing 'options' array`,
+    !isFunction(cmd.run) && `commands[${index}]: missing 'run' function`
+  ].filter((e) => e !== false);
+};
+var validatePluginStrict = (obj) => {
+  if (!isObject(obj)) return ["Plugin must be an object"];
+  const baseErrors = [
+    !isNonEmptyString(obj.name) && "Missing or invalid 'name'",
+    !isString(obj.version) && "Missing or invalid 'version'",
+    !Array.isArray(obj.commands) && "Missing 'commands' array",
+    !Array.isArray(obj.flows) && "Missing 'flows' array",
+    !isFunction(obj.setup) && "Missing 'setup' function"
+  ].filter((e) => e !== false);
+  const commandErrors = Array.isArray(obj.commands) ? obj.commands.flatMap((cmd, i) => validateCommand(cmd, i)) : [];
+  return [...baseErrors, ...commandErrors];
+};
+var createPluginContext = (workspace, logger = defaultLogger) => ({
+  workspace,
+  logger
+});
+var loadPluginFromModule = async (moduleName, context) => {
+  const { logger } = context;
+  logger.debug(`Loading plugin from module: ${moduleName}`);
+  const mod = await import(moduleName);
+  const createPlugin = mod.createPfPlugin || mod.default?.createPfPlugin;
+  if (!isFunction(createPlugin)) {
+    throw new Error(`Module ${moduleName} does not export createPfPlugin`);
+  }
+  const plugin = createPlugin({
+    contractsPath: context.workspace.contracts.path,
+    contractsPackage: context.workspace.contracts.packageName,
+    availableServices: context.workspace.availableServices
+  });
+  const errors = validatePluginStrict(plugin);
+  if (errors.length > 0) {
+    throw new Error(`Plugin from ${moduleName} does not conform to PfPlugin interface:
+  - ${errors.join("\n  - ")}`);
+  }
+  const validatedPlugin = plugin;
+  logger.debug(`Loaded plugin: ${validatedPlugin.name} v${validatedPlugin.version}`);
+  await validatedPlugin.setup(context);
+  return {
+    plugin: validatedPlugin,
+    source: moduleName
+  };
+};
+
+// cli/src/core/facade/index.ts
+import { deriveEventNames as deriveEventNames4 } from "@crossdelta/cloudevents";
+
+// cli/src/core/capabilities/config.ts
+import { z } from "zod";
+var ProviderMetaSchema = z.object({
+  dependencies: z.record(z.string(), z.string()).default({}),
+  envVars: z.array(
+    z.object({
+      key: z.string(),
+      description: z.string(),
+      required: z.boolean().default(true)
+    })
+  ).default([]),
+  /** Custom adapter filename (e.g., 'push-notification.adapter.ts') */
+  adapterFile: z.string().optional()
+});
+var NotifierDefaultsSchema = z.object({
+  push: z.string().optional(),
+  email: z.string().optional(),
+  slack: z.string().optional(),
+  sms: z.string().optional()
+}).optional();
+var NotifierConfigSchema = z.object({
+  defaults: NotifierDefaultsSchema,
+  providers: z.object({
+    push: z.record(z.string(), ProviderMetaSchema).optional(),
+    email: z.record(z.string(), ProviderMetaSchema).optional(),
+    slack: z.record(z.string(), ProviderMetaSchema).optional(),
+    sms: z.record(z.string(), ProviderMetaSchema).optional()
+  }).optional()
+});
+var CapabilitiesConfigSchema = z.object({
+  notifier: NotifierConfigSchema.optional()
+});
+var getRegisteredProviders = (workspaceConfig) => ({
+  push: Object.keys(workspaceConfig?.notifier?.providers?.push ?? {}),
+  email: Object.keys(workspaceConfig?.notifier?.providers?.email ?? {}),
+  slack: Object.keys(workspaceConfig?.notifier?.providers?.slack ?? {}),
+  sms: Object.keys(workspaceConfig?.notifier?.providers?.sms ?? {})
+});
+var getDefaultProvider = (channel, workspaceConfig) => workspaceConfig?.notifier?.defaults?.[channel];
+var lookupProvider = (channel, provider, workspaceConfig) => {
+  const meta = workspaceConfig?.notifier?.providers?.[channel]?.[provider];
+  if (meta) {
+    return { found: true, provider, meta, source: "workspace" };
+  }
+  const availableProviders = Object.keys(workspaceConfig?.notifier?.providers?.[channel] ?? {});
+  const configSnippet = generateConfigSnippet(channel, provider);
+  return {
+    found: false,
+    channel,
+    provider,
+    availableProviders,
+    configSnippet
+  };
+};
+var normalizeProviderName = (name) => name.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+var extractProviderFromPrompt = (prompt) => {
+  const patterns = [
+    /(?:via|using|with|über|per)\s+([\w\s-]+?)(?:\s+(?:for|to|and|,|\.|$))/i,
+    /(?:via|using|with|über|per)\s+([\w-]+)/i
+  ];
+  for (const pattern of patterns) {
+    const match = prompt.match(pattern);
+    if (match?.[1]) {
+      return match[1].trim();
+    }
+  }
+  return void 0;
+};
+var generateConfigSnippet = (channel, provider) => {
+  const snippet = {
+    pf: {
+      capabilities: {
+        notifier: {
+          providers: {
+            [channel]: {
+              [provider]: {
+                dependencies: { "your-package": "^1.0.0" },
+                envVars: [{ key: "YOUR_API_KEY", description: "API key for provider", required: true }]
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  return JSON.stringify(snippet, null, 2);
+};
+var resolveProvider = (channel, explicitProvider, workspaceConfig) => {
+  if (explicitProvider) {
+    return { resolved: true, provider: explicitProvider, source: "explicit" };
+  }
+  const defaultProvider = getDefaultProvider(channel, workspaceConfig);
+  if (defaultProvider) {
+    return { resolved: true, provider: defaultProvider, source: "default" };
+  }
+  const availableProviders = Object.keys(workspaceConfig?.notifier?.providers?.[channel] ?? {});
+  return {
+    resolved: false,
+    needsElicitation: true,
+    channel,
+    availableProviders
+  };
+};
+var loadCapabilitiesConfig = (workspacePkg) => {
+  if (!workspacePkg) return void 0;
+  const pfConfig = workspacePkg.pf;
+  if (!pfConfig?.capabilities) return void 0;
+  const result = CapabilitiesConfigSchema.safeParse(pfConfig.capabilities);
+  return result.success ? result.data : void 0;
+};
+var loadCapabilitiesConfigFromWorkspace = (getWorkspacePackageJson2) => {
+  const pkg = getWorkspacePackageJson2();
+  return loadCapabilitiesConfig(pkg);
+};
+
+// cli/src/core/capabilities/lowering.ts
+var lowerSpecToCapabilities = (spec, serviceDir) => {
+  const metadata = {
+    files: [],
+    dependencies: {},
+    envVars: [],
+    postCommands: []
+  };
+  for (const trigger of spec.triggers) {
+    if (trigger.type === "event") {
+      metadata.postCommands.push(`pf cloudevents add ${trigger.eventType} --service ${serviceDir} --fields "id:string"`);
+    }
+  }
+  for (const action of spec.actions) {
+    if (action.type === "notify" && action.provider) {
+      metadata.files.push({
+        path: `${serviceDir}/src/adapters/${action.channel}.adapter.ts`,
+        intent: `${action.channel} adapter using ${action.provider}`,
+        layer: "adapter",
+        kind: "notifier"
+      });
+      metadata.files.push({
+        path: `${serviceDir}/src/use-cases/send-${action.channel}.use-case.ts`,
+        intent: `send ${action.channel} notification`,
+        layer: "useCase"
+      });
+    }
+  }
+  return metadata;
+};
+
+// cli/src/core/capabilities/types.ts
+import { z as z2 } from "zod";
+var EventTriggerSchema = z2.object({
+  type: z2.literal("event"),
+  eventType: z2.string(),
+  stream: z2.string().optional()
+});
+var HttpTriggerSchema = z2.object({
+  type: z2.literal("http"),
+  method: z2.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional(),
+  path: z2.string().optional()
+});
+var TriggerSchema = z2.discriminatedUnion("type", [EventTriggerSchema, HttpTriggerSchema]);
+var EmitEventActionSchema = z2.object({
+  type: z2.literal("emit.event"),
+  eventType: z2.string()
+});
+var NotifyActionSchema = z2.object({
+  type: z2.literal("notify"),
+  channel: z2.enum(["push", "email", "slack", "sms"]),
+  /** Must be explicitly provided by user or elicited - NO defaults */
+  provider: z2.string().optional()
+});
+var CallHttpActionSchema = z2.object({
+  type: z2.literal("call.http"),
+  name: z2.string().optional(),
+  baseUrl: z2.string().optional()
+});
+var PersistActionSchema = z2.object({
+  type: z2.literal("persist"),
+  store: z2.enum(["db", "kv", "cache"]),
+  entity: z2.string().optional()
+});
+var ActionSchema = z2.discriminatedUnion("type", [
+  EmitEventActionSchema,
+  NotifyActionSchema,
+  CallHttpActionSchema,
+  PersistActionSchema
+]);
+var ServiceSpecSchema = z2.object({
+  serviceName: z2.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/),
+  framework: z2.enum(["hono", "nest"]).default("hono"),
+  triggers: z2.array(TriggerSchema).min(1),
+  actions: z2.array(ActionSchema).default([])
+});
+
+// cli/src/core/capabilities/parser.ts
+var PROVIDER_KEYWORDS = {
+  "pusher beams": { channel: "push", provider: "pusher-beams" },
+  "pusher-beams": { channel: "push", provider: "pusher-beams" },
+  pusherbeams: { channel: "push", provider: "pusher-beams" },
+  firebase: { channel: "push", provider: "firebase" },
+  onesignal: { channel: "push", provider: "onesignal" },
+  expo: { channel: "push", provider: "expo" },
+  resend: { channel: "email", provider: "resend" },
+  sendgrid: { channel: "email", provider: "sendgrid" },
+  ses: { channel: "email", provider: "ses" },
+  postmark: { channel: "email", provider: "postmark" },
+  "slack-webhook": { channel: "slack", provider: "slack-webhook" },
+  "slack webhook": { channel: "slack", provider: "slack-webhook" },
+  "slack-api": { channel: "slack", provider: "slack-api" },
+  twilio: { channel: "sms", provider: "twilio" },
+  vonage: { channel: "sms", provider: "vonage" }
+};
+var detectProvider = (prompt, channel, workspaceConfig) => {
+  const lowerPrompt = prompt.toLowerCase();
+  for (const [keyword, info] of Object.entries(PROVIDER_KEYWORDS)) {
+    if (info.channel === channel && lowerPrompt.includes(keyword)) {
+      return info.provider;
+    }
+  }
+  const registeredProviders = getRegisteredProviders(workspaceConfig);
+  const channelProviders = registeredProviders[channel] ?? [];
+  for (const provider of channelProviders) {
+    const patterns = [provider, provider.replace("-", " "), provider.replace("-", "")];
+    if (patterns.some((p) => lowerPrompt.includes(p.toLowerCase()))) {
+      return provider;
+    }
+  }
+  const rawProvider = extractProviderFromPrompt(prompt);
+  if (rawProvider) {
+    return normalizeProviderName(rawProvider);
+  }
+  return void 0;
+};
+var inferServiceName = (prompt) => {
+  const patterns = [
+    // "create a notifications service" / "build order-processor service"
+    /(?:create|build|make|erstelle)\s+(?:a\s+)?(?:an?\s+)?([a-z][a-z0-9-]*)\s+service/i,
+    // "notifications service that listens" / "order-processor service which handles"
+    /([a-z][a-z0-9-]*)\s+service\s+(?:that|which|to|consumes|listens|handles)/i,
+    // "service called notifications" / "service named order-processor"
+    /service\s+(?:called|named)\s+([a-z][a-z0-9-]*)/i,
+    // "a notifications service" / "an order-processor service" (at start)
+    /^(?:a|an)\s+([a-z][a-z0-9-]*)\s+service/i,
+    // Simple: "notifications service" at start of prompt
+    /^([a-z][a-z0-9-]*)\s+service\b/i
+  ];
+  for (const pattern of patterns) {
+    const match = prompt.match(pattern);
+    if (match?.[1]) {
+      return match[1].toLowerCase().replace(/\s+/g, "-");
+    }
+  }
+  return void 0;
+};
+var inferTriggers = (prompt) => {
+  const triggers = [];
+  const eventPatterns = [
+    /(?:listens?\s+(?:to|for)|consumes?|handles?|reacts?\s+to|when)\s+([a-z][a-z0-9.]*)\s+events?/gi,
+    /on\s+([a-z][a-z0-9.]*)\s+event/gi
+  ];
+  for (const pattern of eventPatterns) {
+    for (const match of prompt.matchAll(pattern)) {
+      const eventType = match[1].toLowerCase();
+      if (!triggers.some((t) => t.type === "event" && t.eventType === eventType)) {
+        triggers.push({ type: "event", eventType });
+      }
+    }
+  }
+  const directEventPattern = /\b([a-z][a-z0-9]*\.[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)?)\b/gi;
+  for (const match of prompt.matchAll(directEventPattern)) {
+    const eventType = match[1].toLowerCase();
+    if (!eventType.includes(".json") && !eventType.includes(".ts") && !eventType.includes(".js")) {
+      if (!triggers.some((t) => t.type === "event" && t.eventType === eventType)) {
+        triggers.push({ type: "event", eventType });
+      }
+    }
+  }
+  return triggers;
+};
+var inferActions = (prompt, workspaceConfig) => {
+  const actions = [];
+  if (/push\s+notification|send\s+push|notify.*push/i.test(prompt)) {
+    const provider = detectProvider(prompt, "push", workspaceConfig);
+    actions.push({ type: "notify", channel: "push", provider });
+  }
+  if (/send\s+email|email\s+notification/i.test(prompt)) {
+    const provider = detectProvider(prompt, "email", workspaceConfig);
+    actions.push({ type: "notify", channel: "email", provider });
+  }
+  if (/slack\s+(?:message|notification)/i.test(prompt)) {
+    const provider = detectProvider(prompt, "slack", workspaceConfig);
+    actions.push({ type: "notify", channel: "slack", provider });
+  }
+  if (/sms|text\s+message/i.test(prompt)) {
+    const provider = detectProvider(prompt, "sms", workspaceConfig);
+    actions.push({ type: "notify", channel: "sms", provider });
+  }
+  const emitMatch = prompt.match(/emit(?:s)?\s+([a-z][a-z0-9.]*)\s+event/i);
+  if (emitMatch) {
+    actions.push({ type: "emit.event", eventType: emitMatch[1].toLowerCase() });
+  }
+  return actions;
+};
+var findMissingFields = (raw, workspaceConfig) => {
+  const missing = [];
+  if (!raw.serviceName) {
+    missing.push({
+      path: "serviceName",
+      prompt: 'What should the service be named? (kebab-case, e.g., "order-notifications")',
+      type: "string",
+      required: true
+    });
+  }
+  if (!raw.triggers || raw.triggers.length === 0) {
+    missing.push({
+      path: "triggers[0].eventType",
+      prompt: 'What event should trigger this service? (e.g., "order.created")',
+      type: "string",
+      required: true
+    });
+  }
+  raw.actions?.forEach((action, index) => {
+    if (action.type === "notify" && !action.provider) {
+      const channel = action.channel;
+      const defaultProvider = getDefaultProvider(channel, workspaceConfig);
+      if (!defaultProvider) {
+        const registeredProviders = getRegisteredProviders(workspaceConfig);
+        const availableProviders = registeredProviders[channel] ?? [];
+        missing.push({
+          path: `actions[${index}].provider`,
+          prompt: availableProviders.length > 0 ? `Which provider for ${channel} notifications?` : `Which provider for ${channel} notifications? (No providers registered - add to package.json pf.capabilities)`,
+          type: "enum",
+          options: availableProviders,
+          required: true
+        });
+      }
+    }
+    if (action.type === "call.http" && !action.baseUrl) {
+      missing.push({
+        path: `actions[${index}].baseUrl`,
+        prompt: "What is the base URL for the HTTP call?",
+        type: "string",
+        required: true
+      });
+    }
+  });
+  return missing;
+};
+var applyWorkspaceDefaults = (raw, workspaceConfig) => {
+  if (!workspaceConfig || !raw.actions) return raw;
+  const updatedActions = raw.actions.map((action) => {
+    if (action.type === "notify" && !action.provider) {
+      const channel = action.channel;
+      const defaultProvider = getDefaultProvider(channel, workspaceConfig);
+      if (defaultProvider) {
+        return { ...action, provider: defaultProvider };
+      }
+    }
+    return action;
+  });
+  return { ...raw, actions: updatedActions };
+};
+var validateSpec = (raw, workspaceConfig) => {
+  const withDefaults = applyWorkspaceDefaults(raw, workspaceConfig);
+  const missingFields = findMissingFields(withDefaults, workspaceConfig);
+  if (missingFields.length > 0) {
+    return {
+      complete: false,
+      fields: missingFields,
+      partialSpec: withDefaults
+    };
+  }
+  const result = ServiceSpecSchema.safeParse(withDefaults);
+  if (!result.success) {
+    const fields = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      prompt: issue.message,
+      type: "string",
+      required: true
+    }));
+    return { complete: false, fields, partialSpec: withDefaults };
+  }
+  return { complete: true, spec: result.data };
+};
+var parseServicePrompt = async (prompt, options) => {
+  const opts = options && "extract" in options ? { interpreter: options } : options ?? {};
+  const { interpreter, workspaceConfig } = opts;
+  let raw;
+  if (interpreter) {
+    raw = await interpreter.extract(prompt);
+  } else {
+    raw = {
+      serviceName: inferServiceName(prompt),
+      framework: /nest(?:js)?/i.test(prompt) ? "nest" : "hono",
+      triggers: inferTriggers(prompt),
+      actions: inferActions(prompt, workspaceConfig)
+    };
+  }
+  return validateSpec(raw, workspaceConfig);
+};
+
+// cli/src/core/effects/changes.ts
+var groupBy = (items, key) => {
+  return items.reduce((acc, item) => {
+    const group = String(item[key]);
+    const existing = acc[group];
+    acc[group] = existing ? [...existing, item] : [item];
+    return acc;
+  }, {});
+};
+var formatChange = (change, index) => {
+  const lines = [
+    `${index + 1}. ${change.type.toUpperCase()}: ${change.path}`,
+    `   ${change.description}`
+  ];
+  if (change.preview) {
+    const previewLines = change.preview.split("\n").map((line) => `   ${line}`);
+    lines.push("   Preview:", "   ```", ...previewLines, "   ```");
+  }
+  lines.push("");
+  return lines;
+};
+var formatFileList = (icon, label, items) => {
+  if (!items?.length) return [];
+  return [
+    `${icon} ${label}:`,
+    ...items.map((c) => `  \u2022 ${c.path} - ${c.description}`),
+    ""
+  ];
+};
+var aggregateChanges = (results) => {
+  return results.filter((r) => r.success && r.changes).flatMap((r) => r.changes ?? []);
+};
+var formatChangeSummary = (changes) => {
+  if (changes.length === 0) {
+    return "\u2713 No changes";
+  }
+  const groups = groupBy(changes, "type");
+  const summary = [
+    "\u{1F4DD} Changes Summary:",
+    `${groups.create?.length || 0} files to create`,
+    `${groups.update?.length || 0} files to update`,
+    `${groups.delete?.length || 0} files to delete`,
+    "",
+    ...formatFileList("\u{1F4C4}", "Create", groups.create),
+    ...formatFileList("\u270F\uFE0F ", "Update", groups.update),
+    ...formatFileList("\u{1F5D1}\uFE0F ", "Delete", groups.delete)
+  ];
+  return summary.join("\n");
+};
+var formatChangeDetails = (changes) => {
+  if (changes.length === 0) {
+    return "\u2713 No changes";
+  }
+  const header = ["\u{1F4DD} Detailed Changes:", ""];
+  const details = changes.flatMap((change, index) => formatChange(change, index));
+  return [...header, ...details].join("\n");
+};
+
+// cli/src/core/events/index-manager.ts
+init_config();
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { deriveEventNames } from "@crossdelta/cloudevents";
+var addExportToDomainIndex = (domainIndexPath, eventFile) => {
+  const exportLine = `export * from './${eventFile}'`;
+  if (!existsSync3(domainIndexPath)) {
+    const domainDir = dirname2(domainIndexPath);
+    if (!existsSync3(domainDir)) {
+      mkdirSync(domainDir, { recursive: true });
+    }
+    const header = `/**
+ * ${dirname2(domainIndexPath).split("/").pop()} Domain Events
+ */
+
+`;
+    writeFileSync3(domainIndexPath, `${header + exportLine}
+`, "utf-8");
+    return true;
+  }
+  const content = readFileSync2(domainIndexPath, "utf-8");
+  if (content.includes(`'./${eventFile}'`)) return false;
+  const updatedContent = `${content.trimEnd()}
+${exportLine}
+`;
+  writeFileSync3(domainIndexPath, updatedContent, "utf-8");
+  return true;
+};
+var addDomainToEventsIndex = (eventsIndexPath, domain) => {
+  const exportLine = `export * from './${domain}'`;
+  if (!existsSync3(eventsIndexPath)) {
+    const header = `/**
+ * Event Contracts Index
+ * 
+ * Re-exports all event contracts for convenient importing.
+ */
+
+`;
+    writeFileSync3(eventsIndexPath, header + exportLine + "\n", "utf-8");
+    return true;
+  }
+  const content = readFileSync2(eventsIndexPath, "utf-8");
+  const lines = content.split("\n");
+  if (lines.some((line) => line.trim() === exportLine)) {
+    return false;
+  }
+  const lastExportIndex = lines.findLastIndex((line) => line.startsWith("export"));
+  if (lastExportIndex >= 0) {
+    lines.splice(lastExportIndex + 1, 0, exportLine);
+  } else {
+    lines.push(exportLine);
+  }
+  writeFileSync3(eventsIndexPath, lines.join("\n"), "utf-8");
+  return true;
+};
+var enableMainExports = (mainIndexPath) => {
+  if (!existsSync3(mainIndexPath)) return false;
+  const content = readFileSync2(mainIndexPath, "utf-8");
+  const eventsExport = "export * from './events'";
+  const hasUncommentedExport = content.split("\n").some(
+    (line) => line.trim() === eventsExport || line.trim().startsWith(eventsExport)
+  );
+  if (hasUncommentedExport) return false;
+  let updated = content;
+  updated = updated.replace(/\/\/\s*export \* from '\.\/events'/, eventsExport);
+  updated = updated.replace(/\/\/\s*export \* from '\.\/stream-policies'/, "export * from './stream-policies'");
+  if (/export \* from '\.\/events\/\w+\/\w+'/.test(updated)) {
+    updated = updated.replace(/export \* from '\.\/events\/\w+\/\w+'\n?/g, "");
+  }
+  if (!updated.includes(eventsExport)) {
+    updated = `${updated.trimEnd()}
+${eventsExport}
+`;
+  }
+  if (updated !== content) {
+    writeFileSync3(mainIndexPath, updated, "utf-8");
+    return true;
+  }
+  return false;
+};
+var addExportToIndex = (eventType, workspaceRoot) => {
+  const { packagePath } = getContractsConfig(workspaceRoot);
+  const { domain, action } = deriveEventNames(eventType);
+  const eventsDir = join4(packagePath, "src", "events");
+  if (!existsSync3(eventsDir)) return false;
+  const domainDir = join4(eventsDir, domain);
+  const domainIndexPath = join4(domainDir, "index.ts");
+  const eventsIndexPath = join4(eventsDir, "index.ts");
+  const mainIndexPath = join4(packagePath, "src", "index.ts");
+  const singularDomain = eventType.split(".")[0];
+  const legacyDomainDir = join4(eventsDir, singularDomain);
+  if (singularDomain !== domain && existsSync3(legacyDomainDir)) {
+    console.warn(`\u26A0\uFE0F  Warning: Legacy folder '${singularDomain}/' found. Please migrate to '${domain}/' to avoid conflicts.`);
+    console.warn(`   Run: mv ${legacyDomainDir} ${domainDir}`);
+  }
+  let updated = false;
+  if (addExportToDomainIndex(domainIndexPath, action)) {
+    updated = true;
+  }
+  if (addDomainToEventsIndex(eventsIndexPath, domain)) {
+    updated = true;
+  }
+  if (enableMainExports(mainIndexPath)) {
+    updated = true;
+  }
+  return updated;
+};
+
+// cli/src/core/effects/stream.handler.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+import { getStreamName } from "@crossdelta/cloudevents";
+var serviceConsumesStream = (servicePath, streamName) => {
+  const indexPath = join5(servicePath, "src", "index.ts");
+  if (!existsSync4(indexPath)) return false;
+  const content = readFileSync3(indexPath, "utf-8");
+  const namespace = streamName.toLowerCase();
+  const streamsArrayPattern = new RegExp(`streams:\\s*\\[[^\\]]*['"]${streamName}['"]`);
+  if (streamsArrayPattern.test(content)) return true;
+  if (content.includes(`stream: '${streamName}'`)) return true;
+  const subjectPattern = new RegExp(`subjects:\\s*\\[.*['"]${namespace}\\.[*>]`);
+  return subjectPattern.test(content);
+};
+var addCloudEventsImport = (content) => {
+  if (content.includes("@crossdelta/cloudevents")) return content;
+  const cloudEventsImport = `import { consumeJetStreams } from '@crossdelta/cloudevents'
+`;
+  const telemetryMatch = content.match(/import\s+['"]@crossdelta\/telemetry['"]\s*\n/);
+  if (telemetryMatch) {
+    const insertPos = (telemetryMatch.index ?? 0) + telemetryMatch[0].length;
+    return `${content.slice(0, insertPos)}
+${cloudEventsImport}${content.slice(insertPos)}`;
+  }
+  const firstImportMatch = content.match(/import\s+.*\n/);
+  if (firstImportMatch) {
+    const insertPos = (firstImportMatch.index ?? 0) + firstImportMatch[0].length;
+    return content.slice(0, insertPos) + cloudEventsImport + content.slice(insertPos);
+  }
+  return content;
+};
+var generateStreamCode = (streamName, serviceName) => `
+
+// Consume from ${streamName} stream
+consumeJetStreams({
+  streams: ['${streamName}'],
+  consumer: '${serviceName}-service',
+  discover: './src/events/**/*.handler.ts',
+})`;
+var addStreamToService = (servicePath, eventType) => {
+  const streamName = getStreamName(eventType);
+  const indexPath = join5(servicePath, "src", "index.ts");
+  const mainPath = join5(servicePath, "src", "main.ts");
+  if (!existsSync4(indexPath) && existsSync4(mainPath)) {
+    return { added: false, streamName };
+  }
+  if (!existsSync4(indexPath)) {
+    return { added: false, streamName, warning: "Entry point not found (index.ts or main.ts)" };
+  }
+  if (serviceConsumesStream(servicePath, streamName)) {
+    return { added: false, streamName };
+  }
+  let content = readFileSync3(indexPath, "utf-8");
+  const serviceName = servicePath.split("/").pop() || "unknown";
+  if (!content.includes("consumeJetStreams")) {
+    content = addCloudEventsImport(content);
+  }
+  const streamCode = generateStreamCode(streamName, serviceName);
+  const updatedContent = `${content.trimEnd() + streamCode}
+`;
+  writeFileSync4(indexPath, updatedContent, "utf-8");
+  return { added: true, streamName };
+};
+
+// cli/src/core/effects/handlers.ts
+var handleStreamWired = (effect, context, options) => {
+  const { stream, servicePath } = effect;
+  const absolutePath = servicePath.startsWith("/") ? servicePath : `${context.workspace.workspaceRoot}/${servicePath}`;
+  if (options?.dryRun) {
+    return {
+      success: true,
+      message: `Would wire stream ${stream} to ${servicePath}`,
+      changes: [
+        {
+          type: "update",
+          path: absolutePath,
+          description: `Wire ${stream} stream to service`,
+          preview: `consumeJetStreams({ streams: ['${stream.toUpperCase()}'], ... })`
+        }
+      ]
+    };
+  }
+  const result = addStreamToService(absolutePath, `${stream.toLowerCase()}.event`);
+  if (result.warning) {
+    context.logger.warn(result.warning);
+    return { success: false, message: result.warning };
+  }
+  if (result.added) {
+    context.logger.info(`Wired stream ${result.streamName} to service`);
+    return { success: true, message: `Wired stream ${result.streamName}` };
+  }
+  context.logger.debug(`Stream ${result.streamName} already wired`);
+  return { success: true, message: `Stream ${result.streamName} already configured` };
+};
+var handleContractCreated = (effect, context, options) => {
+  const { path, eventType } = effect;
+  if (options?.dryRun) {
+    const preview = `
+import { createContract } from '@crossdelta/cloudevents'
+import { z } from 'zod'
+
+export const ${toPascalCase(eventType)}Contract = createContract({
+  type: '${eventType}',
+  schema: z.object({ ... }),
+})
+    `.trim();
+    return {
+      success: true,
+      message: `Would create contract ${eventType}`,
+      changes: [
+        {
+          type: "create",
+          path,
+          description: `Create event contract for ${eventType}`,
+          preview: preview.slice(0, 500)
+        }
+      ]
+    };
+  }
+  const updated = addExportToIndex(eventType, context.workspace.workspaceRoot);
+  if (updated) {
+    context.logger.debug(`Added export for ${eventType} to contracts index`);
+  }
+  context.logger.debug(`Contract created: ${eventType} at ${path}`);
+  return {
+    success: true,
+    message: updated ? `Contract ${eventType} created with exports` : `Contract ${eventType} created`
+  };
+};
+var toPascalCase = (eventType) => {
+  return eventType.split(".").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+};
+var handleHandlerCreated = (effect, context, options) => {
+  const { path, eventType, servicePath } = effect;
+  if (options?.dryRun) {
+    const preview = `
+import { handleEvent } from '@crossdelta/cloudevents'
+import { ${toPascalCase(eventType)}Contract } from '@your-scope/contracts'
+
+export default handleEvent(${toPascalCase(eventType)}Contract, async (data) => {
+  console.log('Processing ${eventType}:', data)
+  // TODO: Implement handler logic
+})
+    `.trim();
+    return {
+      success: true,
+      message: `Would create handler for ${eventType}`,
+      changes: [
+        {
+          type: "create",
+          path,
+          description: `Create event handler for ${eventType}`,
+          preview: preview.slice(0, 500)
+        }
+      ]
+    };
+  }
+  context.logger.debug(`Handler created: ${eventType} at ${path} (service: ${servicePath})`);
+  return { success: true };
+};
+var effectHandlers = {
+  "stream.wired": handleStreamWired,
+  "contract.created": handleContractCreated,
+  "handler.created": handleHandlerCreated
+};
+var applyEffects = (effects, context, options) => {
+  return effects.map((effect) => {
+    const handler = effectHandlers[effect.kind];
+    if (!handler) {
+      context.logger.warn(`Unknown effect kind: ${effect.kind}`);
+      return { success: false, message: `Unknown effect kind: ${effect.kind}` };
+    }
+    return handler(effect, context, options);
+  });
+};
+
+// cli/src/core/flows/service-generation.flow.ts
+import { join as join12 } from "path";
+import { deriveEventNames as deriveEventNames3 } from "@crossdelta/cloudevents";
+
+// cli/src/core/operations/types.ts
+var ok = (operation, summary, options = {}) => ({
+  ok: true,
+  operation,
+  summary,
+  artifacts: options.artifacts ?? [],
+  changes: options.changes ?? [],
+  diagnostics: options.diagnostics ?? [],
+  next: options.next,
+  data: options.data
+});
+var err = (operation, error, options = {}) => ({
+  ok: false,
+  operation,
+  summary: `Failed: ${error}`,
+  artifacts: [],
+  changes: [],
+  diagnostics: options.diagnostics ?? [{ level: "error", message: error }],
+  data: options.data
+});
+
+// cli/src/core/flows/service-generation.flow.ts
+init_config();
+
+// cli/src/commands/create/hono-microservice/templates.ts
+import { join as join8 } from "path";
+
+// cli/src/core/esm.ts
+import { dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var getDirname = (importMetaUrl) => dirname3(fileURLToPath2(importMetaUrl));
+
+// cli/src/core/filesystem/index.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+init_watcher();
+var getDefaultStartDir = () => {
+  if (typeof import.meta?.url === "string") {
+    return getDirname(import.meta.url);
+  }
+  if (typeof __dirname === "string") return __dirname;
+  return process.cwd();
+};
+var findPackageRoot = (startDir) => {
+  const dir = startDir ?? getDefaultStartDir();
+  const hasPackageJson = (d) => existsSync5(join6(d, "package.json"));
+  const parent = dirname4(dir);
+  if (hasPackageJson(dir)) return dir;
+  if (dir === "/") throw new Error("Could not find package.json (package root)");
+  return findPackageRoot(parent);
+};
+var findDirectory = (searchPaths, errorMessage) => {
+  const found = searchPaths.find(existsSync5);
+  if (!found) {
+    throw new Error(
+      errorMessage ?? `Directory not found. Searched in: ${searchPaths.join(", ")}`
+    );
+  }
+  return found;
+};
+
+// cli/src/core/templates/renderer.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join7 } from "path";
+import Handlebars from "handlebars";
+var findTemplatesDir = (searchPaths, errorMessage) => {
+  return findDirectory(
+    searchPaths,
+    errorMessage ?? `Templates directory not found. Searched in: ${searchPaths.join(", ")}`
+  );
+};
+var renderTemplate = (templatePath, data = {}) => {
+  const templateContent = readFileSync4(templatePath, "utf-8");
+  const template = Handlebars.compile(templateContent);
+  return template(data);
+};
+var createTemplateRenderer = (templatesDir) => (templateName, data = {}) => {
+  const templatePath = join7(templatesDir, templateName);
+  return renderTemplate(templatePath, data);
+};
+
+// cli/src/core/templates/strings.ts
+var toEnvKey = (name) => name.toUpperCase().replace(/-/g, "_");
+var toDisplayName = (name) => name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+
+// cli/src/commands/create/hono-microservice/templates.ts
+var getModuleDir = () => {
+  if (typeof import.meta?.url === "string") {
+    return getDirname(import.meta.url);
+  }
+  if (typeof __dirname === "string") return __dirname;
+  return process.cwd();
+};
+var getTemplatesDir = () => {
+  const moduleDir = getModuleDir();
+  const packageRoot = findPackageRoot();
+  return findTemplatesDir(
+    [
+      join8(moduleDir, "templates", "hono-microservice"),
+      join8(moduleDir, "..", "hono-microservice", "templates"),
+      join8(packageRoot, "bin", "templates", "hono-microservice")
+      // Global install fallback
+    ],
+    "Hono templates directory not found."
+  );
+};
+var renderTemplate2 = (templateName, data = {}) => createTemplateRenderer(getTemplatesDir())(templateName, data);
+function generateHonoTsConfig() {
+  return renderTemplate2("tsconfig.json.hbs");
+}
+function generateHonoDockerfile(bunVersion = "1.2.23") {
+  return renderTemplate2("Dockerfile.hbs", { bunVersion });
+}
+function generateHonoBiomeJson() {
+  return renderTemplate2("biome.json.hbs");
+}
+function generateHonoEnvTs(serviceName, envVars = []) {
+  return renderTemplate2("src/config/env.ts.hbs", {
+    envKey: toEnvKey(serviceName),
+    envVars
+  });
+}
+
+// cli/src/core/templates/hono-bun.template.ts
+var generateImports = (hasEvents) => {
+  const imports = [
+    "import './config/env'",
+    "import '@crossdelta/telemetry'",
+    ""
+  ];
+  if (hasEvents) {
+    imports.push("import { consumeJetStreams } from '@crossdelta/cloudevents'");
+  }
+  imports.push("import { Hono } from 'hono'");
+  return imports;
+};
+var generateServerSetup = (envKey) => [
+  `const port = Number(process.env.${envKey}_PORT) || 8080`,
+  "const app = new Hono()",
+  "",
+  "app.get('/health', (c) => {",
+  "  return c.json({ status: 'ok' })",
+  "})"
+];
+var generateJetStreamConsumer = (serviceName, streams) => [
+  "",
+  "// Start NATS JetStream consumer",
+  "consumeJetStreams({",
+  `  streams: [${streams.map((s) => `'${s}'`).join(", ")}],`,
+  `  consumer: '${serviceName}',`,
+  "  discover: './src/events/**/*.handler.ts',",
+  "})"
+];
+var generateBunServe = () => [
+  "",
+  "Bun.serve({",
+  "  port,",
+  "  fetch: app.fetch,",
+  "})",
+  "",
+  "console.log(`\u{1F680} Service ready at http://localhost:${port}`)"
+];
+var generateIndexTs = (vars) => {
+  const envKey = toEnvKey(vars.serviceName);
+  const parts = [
+    ...generateImports(vars.hasEvents),
+    "",
+    ...generateServerSetup(envKey),
+    ...vars.hasEvents ? generateJetStreamConsumer(vars.serviceName, vars.streams) : [],
+    ...generateBunServe()
+  ];
+  return `${parts.join("\n")}
+`;
+};
+var generatePackageJson = (vars) => {
+  const dependencies = {
+    hono: "^4.6.14",
+    "@crossdelta/telemetry": "workspace:*",
+    zod: "^4.1.0",
+    // Always include contracts - user may add events later via "pf cloudevents add"
+    [`${vars.workspaceScope}/contracts`]: "workspace:*"
+  };
+  if (vars.hasEvents) {
+    dependencies["@crossdelta/cloudevents"] = "workspace:*";
+  }
+  const pkg = {
+    name: vars.packageName,
+    version: "0.0.1",
+    type: "module",
+    scripts: {
+      "start:dev": "bun --watch src/index.ts",
+      start: "bun src/index.ts",
+      test: "bun test"
+    },
+    dependencies,
+    devDependencies: {
+      "@types/bun": "^1.2.23"
+    }
+  };
+  return JSON.stringify(pkg, null, 2);
+};
+var generateReadme = (vars) => {
+  return `# ${vars.serviceName}
+
+## Development
+
+\`\`\`bash
+bun install
+bun dev
+\`\`\`
+
+Service runs on port: \`${vars.port}\`
+
+## Environment Variables
+
+- \`${vars.envVarName}_PORT\`: Service port (default: ${vars.port})
+${vars.hasEvents ? `
+## Events
+
+This service consumes from:
+${vars.streams.map((s) => `- ${s}`).join("\n")}` : ""}
+`;
+};
+var generateEventsGitkeep = () => "";
+var HonoBunTemplate = {
+  name: "hono-bun",
+  runtime: "bun",
+  framework: "hono",
+  files: [
+    {
+      path: "src/index.ts",
+      content: generateIndexTs
+    },
+    {
+      path: "src/config/env.ts",
+      content: (vars) => generateHonoEnvTs(vars.serviceName, vars.envVars)
+    },
+    {
+      path: "package.json",
+      content: generatePackageJson
+    },
+    {
+      path: "tsconfig.json",
+      content: () => generateHonoTsConfig()
+    },
+    {
+      path: "Dockerfile",
+      content: () => generateHonoDockerfile()
+    },
+    {
+      path: "biome.json",
+      content: () => generateHonoBiomeJson()
+    },
+    {
+      path: "README.md",
+      content: generateReadme
+    },
+    {
+      path: "src/events/.gitkeep",
+      content: generateEventsGitkeep,
+      skip: (vars) => !vars.hasEvents
+    }
+  ]
+};
+
+// cli/src/commands/create/nest-microservice/templates.ts
+import { join as join9 } from "path";
+var getModuleDir2 = () => {
+  if (typeof import.meta?.url === "string") {
+    return getDirname(import.meta.url);
+  }
+  if (typeof __dirname === "string") return __dirname;
+  return process.cwd();
+};
+var getTemplatesDir2 = () => {
+  const moduleDir = getModuleDir2();
+  const packageRoot = findPackageRoot();
+  return findTemplatesDir(
+    [
+      join9(moduleDir, "templates", "nest-microservice"),
+      join9(moduleDir, "..", "nest-microservice", "templates"),
+      join9(packageRoot, "bin", "templates", "nest-microservice")
+      // Global install fallback
+    ],
+    "NestJS templates directory not found."
+  );
+};
+var renderTemplate3 = (templateName, data = {}) => createTemplateRenderer(getTemplatesDir2())(templateName, data);
+function generateNestMainTs(serviceName, defaultPort = 3e3) {
+  return renderTemplate3("src/main.ts.hbs", {
+    serviceName,
+    envKey: toEnvKey(serviceName),
+    displayName: toDisplayName(serviceName),
+    defaultPort
+  });
+}
+function generateAppContext() {
+  return renderTemplate3("src/app.context.ts.hbs", {});
+}
+function generateEventsModule() {
+  return renderTemplate3("src/events/events.module.ts.hbs", {});
+}
+function generateEventsService(serviceName) {
+  return renderTemplate3("src/events/events.service.ts.hbs", { serviceName });
+}
+function generateNestDockerfile(nodeVersion = "24", bunVersion = "1.2.23") {
+  return renderTemplate3("Dockerfile.hbs", { nodeVersion, bunVersion });
+}
+function generateNestBiomeJson() {
+  return renderTemplate3("biome.json.hbs", {});
+}
+function generateNestEnvTs(serviceName, envVars = []) {
+  return renderTemplate3("src/config/env.ts.hbs", {
+    envKey: toEnvKey(serviceName),
+    envVars
+  });
+}
+
+// cli/src/core/templates/nest.template.ts
+var generatePackageJson2 = (vars) => {
+  const dependencies = {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@crossdelta/telemetry": "workspace:*",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.0",
+    "zod": "^4.1.0",
+    // Always include contracts - user may add events later via "pf cloudevents add"
+    [`${vars.workspaceScope}/contracts`]: "workspace:*"
+  };
+  if (vars.hasEvents) {
+    dependencies["@crossdelta/cloudevents"] = "workspace:*";
+  }
+  const pkg = {
+    name: vars.packageName,
+    version: "0.0.1",
+    scripts: {
+      "start:dev": "bun --watch src/main.ts",
+      start: "node dist/main.js",
+      build: "tsc",
+      test: "bun test"
+    },
+    dependencies,
+    devDependencies: {
+      "@nestjs/cli": "^11.0.0",
+      "@types/node": "^24.0.0",
+      typescript: "^5.7.0"
+    }
+  };
+  return JSON.stringify(pkg, null, 2);
+};
+var generateTsConfig = () => {
+  const config = {
+    extends: "../../../../tsconfig.json",
+    compilerOptions: {
+      outDir: "./dist",
+      rootDir: "./src",
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist", "**/*.test.ts"]
+  };
+  return JSON.stringify(config, null, 2);
+};
+var generateAppModule = (vars) => {
+  const imports = ["Module", "HttpModule"];
+  const moduleImports = ["HttpModule"];
+  if (vars.hasEvents) {
+    imports.push("OnModuleInit");
+    moduleImports.push("EventsModule");
+  }
+  return `import { ${imports.join(", ")} } from '@nestjs/common'
+${vars.hasEvents ? "import { EventsModule } from './events/events.module'" : ""}
+
+@Module({
+  imports: [${moduleImports.join(", ")}],
+  controllers: [],
+  providers: [],
+})
+export class AppModule${vars.hasEvents ? " implements OnModuleInit" : ""} {
+  ${vars.hasEvents ? "async onModuleInit() {\n    // Events module initializes NATS consumer\n  }" : ""}
+}
+`;
+};
+var generateAppController = () => {
+  return `import { Controller, Get } from '@nestjs/common'
+
+@Controller()
+export class AppController {
+  @Get('health')
+  health() {
+    return { status: 'ok' }
+  }
+}
+`;
+};
+var generateReadme2 = (vars) => {
+  return `# ${vars.serviceName}
+
+## Development
+
+\`\`\`bash
+bun install
+bun dev
+\`\`\`
+
+Service runs on port: \`${vars.port}\`
+
+## Environment Variables
+
+- \`${vars.envVarName}_PORT\`: Service port (default: ${vars.port})
+${vars.hasEvents ? `
+## Events
+
+This service consumes from:
+${vars.streams.map((s) => `- ${s}`).join("\n")}` : ""}
+`;
+};
+var generateEventsGitkeep2 = () => "";
+var NestTemplate = {
+  name: "nest",
+  runtime: "node",
+  framework: "nest",
+  files: [
+    {
+      path: "src/config/env.ts",
+      content: (vars) => generateNestEnvTs(vars.serviceName, vars.envVars)
+    },
+    {
+      path: "src/main.ts",
+      content: (vars) => generateNestMainTs(vars.serviceName, vars.port)
+    },
+    {
+      path: "src/app.module.ts",
+      content: generateAppModule
+    },
+    {
+      path: "src/app.controller.ts",
+      content: () => generateAppController()
+    },
+    {
+      path: "src/app.context.ts",
+      content: () => generateAppContext()
+    },
+    {
+      path: "package.json",
+      content: generatePackageJson2
+    },
+    {
+      path: "tsconfig.json",
+      content: () => generateTsConfig()
+    },
+    {
+      path: "Dockerfile",
+      content: () => generateNestDockerfile()
+    },
+    {
+      path: "biome.json",
+      content: () => generateNestBiomeJson()
+    },
+    {
+      path: "README.md",
+      content: generateReadme2
+    },
+    {
+      path: "src/events/events.module.ts",
+      content: () => generateEventsModule(),
+      skip: (vars) => !vars.hasEvents
+    },
+    {
+      path: "src/events/events.service.ts",
+      content: (vars) => generateEventsService(vars.serviceName),
+      skip: (vars) => !vars.hasEvents
+    },
+    {
+      path: "src/events/handlers/.gitkeep",
+      content: generateEventsGitkeep2,
+      skip: (vars) => !vars.hasEvents
+    }
+  ]
+};
+
+// cli/src/core/templates/index.ts
+var templates = [HonoBunTemplate, NestTemplate];
+var selectTemplate = (type) => {
+  const normalized = normalizeTemplateType(type);
+  const template = templates.find((t) => t.name === normalized);
+  if (!template) {
+    throw new Error(`Template '${type}' not found. Available: ${templates.map((t) => t.name).join(", ")}`);
+  }
+  return template;
+};
+var normalizeTemplateType = (type) => {
+  const aliases = {
+    "hono-micro": "hono-bun",
+    "nest-micro": "nest"
+  };
+  return aliases[type] || type;
+};
+
+// cli/src/core/flows/effect-builder.ts
+import { join as join10 } from "path";
+import { deriveEventNames as deriveEventNames2 } from "@crossdelta/cloudevents";
+
+// cli/src/core/policies/service-layout.ts
+var SERVICE_LAYOUT_POLICY_VERSION = 1;
+var defaultCodingConstraints = {
+  appliesTo: ["src/domain", "src/use-cases"],
+  forbiddenPatterns: [
+    {
+      pattern: "console\\.(log|error|warn|info|debug)\\s*\\(",
+      description: "console.* is forbidden in business logic (use structured logging)",
+      code: "CONSOLE_IN_DOMAIN"
+    },
+    {
+      pattern: "process\\.env\\b",
+      description: "process.env is forbidden in business logic (use dependency injection)",
+      code: "PROCESS_ENV_IN_DOMAIN"
+    },
+    {
+      pattern: "\\bfetch\\s*\\(",
+      description: "fetch() is forbidden in business logic (use adapters/services)",
+      code: "FETCH_IN_DOMAIN"
+    }
+  ]
+};
+var serviceLayoutPolicy = {
+  hono: {
+    businessLogicDir: "use-cases",
+    eventsDir: "events",
+    filePattern: "{name}.use-case.ts",
+    suffix: "use-case",
+    handlerDelegatesToBusinessLogic: true,
+    pathGuards: {
+      forbidDirs: ["src/services"]
+    },
+    codingConstraints: defaultCodingConstraints
+  },
+  nestjs: {
+    businessLogicDir: "",
+    eventsDir: "events",
+    filePattern: "{name}.service.ts",
+    suffix: "service",
+    handlerDelegatesToBusinessLogic: false,
+    pathGuards: {
+      forbidDirs: []
+    },
+    codingConstraints: {
+      appliesTo: ["src/domain"],
+      forbiddenPatterns: defaultCodingConstraints.forbiddenPatterns
+    }
+  }
+};
+var toCamelCase = (name) => {
+  return name.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+};
+var calculateImportPath = (businessLogicDir, fileNameWithoutExt) => {
+  return `../${businessLogicDir}/${fileNameWithoutExt}`;
+};
+var resolveServiceLayout = (framework, name) => {
+  const layout = serviceLayoutPolicy[framework];
+  const fileName = layout.filePattern.replace("{name}", name);
+  const fileNameWithoutExt = fileName.replace(/\.ts$/, "");
+  const dirPath = layout.businessLogicDir ? `src/${layout.businessLogicDir}` : "src";
+  return {
+    filePath: dirPath ? `${dirPath}/${fileName}` : `src/${fileName}`,
+    dirPath,
+    fileName,
+    functionName: toCamelCase(name),
+    delegateFromHandler: layout.handlerDelegatesToBusinessLogic,
+    importFromEvents: layout.businessLogicDir ? calculateImportPath(layout.businessLogicDir, fileNameWithoutExt) : `./${fileNameWithoutExt}`
+  };
+};
+var resolveEventLayout = (framework, eventName) => {
+  const layout = serviceLayoutPolicy[framework];
+  const dirPath = `src/${layout.eventsDir}`;
+  const fileName = `${eventName}.handler.ts`;
+  return {
+    filePath: `${dirPath}/${fileName}`,
+    dirPath,
+    fileName
+  };
+};
+var deriveUseCaseName = (eventType) => {
+  const normalized = eventType.replace(/\./g, "-");
+  return `handle-${normalized}`;
+};
+var normalizePath = (filePath) => {
+  let normalized = filePath.replace(/\\/g, "/");
+  normalized = normalized.replace(/^\.\//, "").replace(/^\//, "");
+  const segments = normalized.split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === "..") {
+      resolved.pop();
+    } else if (segment !== "." && segment !== "") {
+      resolved.push(segment);
+    }
+  }
+  return resolved.join("/");
+};
+var matchesForbiddenDir = (filePath, forbidDirs) => {
+  const normalizedPath = normalizePath(filePath);
+  for (const dir of forbidDirs) {
+    const normalizedDir = normalizePath(dir);
+    if (normalizedPath.startsWith(`${normalizedDir}/`) || normalizedPath === normalizedDir) {
+      return dir;
+    }
+  }
+  return null;
+};
+var isInConstrainedDir = (filePath, appliesTo) => {
+  const normalizedPath = normalizePath(filePath);
+  return appliesTo.some((dir) => {
+    const normalizedDir = normalizePath(dir);
+    return normalizedPath.startsWith(`${normalizedDir}/`) || normalizedPath === normalizedDir;
+  });
+};
+var findPatternViolations = (content, patterns, filePath) => {
+  const violations = [];
+  const lines = content.split("\n");
+  for (const { pattern, description, code } of patterns) {
+    const regex = new RegExp(pattern, "g");
+    for (let i = 0; i < lines.length; i++) {
+      if (regex.test(lines[i])) {
+        violations.push({
+          code,
+          message: description,
+          path: filePath,
+          line: i + 1
+        });
+      }
+      regex.lastIndex = 0;
+    }
+  }
+  return violations;
+};
+var validateFile = (file, layout) => {
+  const violations = [];
+  const forbiddenDir = matchesForbiddenDir(file.path, layout.pathGuards.forbidDirs);
+  if (forbiddenDir) {
+    violations.push({
+      code: "FORBIDDEN_DIR",
+      message: `Path '${file.path}' is in forbidden directory '${forbiddenDir}'`,
+      path: file.path
+    });
+  }
+  if (isInConstrainedDir(file.path, layout.codingConstraints.appliesTo)) {
+    const patternViolations = findPatternViolations(
+      file.content,
+      layout.codingConstraints.forbiddenPatterns,
+      file.path
+    );
+    violations.push(...patternViolations);
+  }
+  return violations;
+};
+var validateGeneratedFiles = (framework, files) => {
+  const layout = serviceLayoutPolicy[framework];
+  const violations = [];
+  for (const file of files) {
+    violations.push(...validateFile(file, layout));
+  }
+  return {
+    valid: violations.length === 0,
+    violations
+  };
+};
+var getFrameworkPolicy = (framework) => serviceLayoutPolicy[framework];
+
+// cli/src/core/flows/effect-builder.ts
+var buildFileEffects = (servicePath, files) => {
+  return files.map((file) => ({
+    kind: "file:write",
+    path: join10(servicePath, file.path),
+    content: file.content
+  }));
+};
+var buildInfraEffect = (serviceName, port, template) => ({
+  kind: "infra:add",
+  serviceName,
+  port,
+  framework: template.framework,
+  runtime: template.runtime
+});
+var buildEnvEffect = (envVarName, port) => ({
+  kind: "env:add",
+  key: `${envVarName}_PORT`,
+  value: port.toString()
+});
+var generateUseCaseContent = (eventType, workspaceScope) => {
+  const { typeName } = deriveEventNames2(eventType);
+  const useCaseName = deriveUseCaseName(eventType);
+  const layout = resolveServiceLayout("hono", useCaseName);
+  return `import type { ${typeName} } from '${workspaceScope}/contracts'
+
+/**
+ * Handle ${eventType} event
+ *
+ * Business logic for processing the event.
+ * Keep this pure where possible - side effects via returned data or adapters.
+ */
+export const ${layout.functionName} = async (data: ${typeName}): Promise<void> => {
+  // TODO: Implement business logic
+  // Example: validate data, transform, call external services
+}
+`;
+};
+var generateEventHandlerContent = (eventType, workspaceScope, framework) => {
+  const { contractName, typeName } = deriveEventNames2(eventType);
+  const useCaseName = deriveUseCaseName(eventType);
+  const layout = resolveServiceLayout(framework, useCaseName);
+  if (layout.delegateFromHandler) {
+    return `import { handleEvent } from '@crossdelta/cloudevents'
+import { ${contractName}, type ${typeName} } from '${workspaceScope}/contracts'
+import { ${layout.functionName} } from '${layout.importFromEvents}'
+
+export default handleEvent(${contractName}, async (data: ${typeName}) => {
+  console.log('\u{1F4E6} [${eventType}] Event received:', data)
+  await ${layout.functionName}(data)
+})
+`;
+  }
+  return `import { handleEvent } from '@crossdelta/cloudevents'
+import { ${contractName}, type ${typeName} } from '${workspaceScope}/contracts'
+
+export default handleEvent(${contractName}, async (data: ${typeName}) => {
+  console.log('\u{1F4E6} [${eventType}] Event received:', data)
+  // TODO: Inject and call service
+})
+`;
+};
+var buildUseCaseEffects = (servicePath, vars, framework) => {
+  if (!vars.hasEvents || vars.events.length === 0) {
+    return [];
+  }
+  const layout = resolveServiceLayout(framework, "stub");
+  if (!layout.delegateFromHandler) {
+    return [];
+  }
+  return vars.events.map((eventType) => {
+    const useCaseName = deriveUseCaseName(eventType);
+    const resolved = resolveServiceLayout(framework, useCaseName);
+    return {
+      kind: "file:write",
+      path: join10(servicePath, resolved.filePath),
+      content: generateUseCaseContent(eventType, vars.workspaceScope)
+    };
+  });
+};
+var buildEventHandlerEffects = (servicePath, vars, framework) => {
+  if (!vars.hasEvents || vars.events.length === 0) {
+    return [];
+  }
+  return vars.events.map((eventType) => {
+    const { kebab } = deriveEventNames2(eventType);
+    const eventLayout = resolveEventLayout(framework, kebab);
+    return {
+      kind: "file:write",
+      path: join10(servicePath, eventLayout.filePath),
+      content: generateEventHandlerContent(eventType, vars.workspaceScope, framework)
+    };
+  });
+};
+var mapFramework = (templateFramework) => {
+  if (templateFramework === "hono") return "hono";
+  if (templateFramework === "nest") return "nestjs";
+  return "hono";
+};
+var buildServiceEffects = (servicePath, files, vars, template) => {
+  const framework = mapFramework(template.framework);
+  const fileEffects = buildFileEffects(servicePath, files);
+  const useCaseEffects = buildUseCaseEffects(servicePath, vars, framework);
+  const eventHandlerEffects = buildEventHandlerEffects(servicePath, vars, framework);
+  const infraEffect = buildInfraEffect(vars.serviceName, vars.port, template);
+  const envEffect = buildEnvEffect(vars.envVarName, vars.port);
+  return [...fileEffects, ...useCaseEffects, ...eventHandlerEffects, infraEffect, envEffect];
+};
+
+// cli/src/core/flows/port-allocation.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join11 } from "path";
+var INTERNAL_PORT_START = 4001;
+var extractPort = (content) => {
+  const portsMatch = content.match(/ports\(\)\.(?:http|https|grpc|primary)\((\d+)\)/);
+  if (portsMatch) {
+    return Number.parseInt(portsMatch[1], 10);
+  }
+  const containerMatch = content.match(/containerPort:\s*(\d+)/);
+  if (containerMatch) {
+    return Number.parseInt(containerMatch[1], 10);
+  }
+  return null;
+};
+var scanUsedPorts = (workspaceRoot) => {
+  try {
+    const infraServicesPath = join11(workspaceRoot, "infra", "services");
+    if (!existsSync6(infraServicesPath)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const files = readdirSync4(infraServicesPath).filter((f) => f.endsWith(".ts"));
+    return files.reduce((ports, file) => {
+      const content = readFileSync5(join11(infraServicesPath, file), "utf-8");
+      const port = extractPort(content);
+      if (port !== null) {
+        ports.add(port);
+      }
+      return ports;
+    }, /* @__PURE__ */ new Set());
+  } catch (error) {
+    console.warn("Failed to scan ports:", error);
+    return /* @__PURE__ */ new Set();
+  }
+};
+var allocateNextPort = (usedPorts, startPort) => {
+  return usedPorts.has(startPort) ? allocateNextPort(usedPorts, startPort + 1) : startPort;
+};
+
+// cli/src/core/flows/service-generation.flow.ts
+var validateServiceName = (name) => {
+  if (!name || name.trim().length === 0) {
+    throw new Error("Service name cannot be empty");
+  }
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(name)) {
+    throw new Error(`Service name '${name}' must be kebab-case (lowercase, alphanumeric, hyphens only)`);
+  }
+};
+var resolveServicePath = (name, customPath, workspaceRoot) => {
+  if (customPath) {
+    if (customPath.startsWith("/")) {
+      return customPath;
+    }
+    if (customPath.startsWith(".")) {
+      return join12(workspaceRoot, customPath);
+    }
+    if (customPath.includes("/")) {
+      return join12(workspaceRoot, customPath);
+    }
+  }
+  const paths = getWorkspacePathsConfig(workspaceRoot);
+  return join12(workspaceRoot, paths.services, name);
+};
+var deriveStreamsFromEvents = (events) => [
+  ...new Set(events.map((e) => deriveEventNames3(e).streamName))
+];
+var buildTemplateVars = (inputs, workspaceRoot, servicePath, port) => {
+  const contractsConfig = getContractsConfig(workspaceRoot);
+  const workspaceScope = contractsConfig.packageName.split("/")[0];
+  const events = inputs.events ?? [];
+  const hasEvents = events.length > 0 || inputs.hasEvents || false;
+  const streams = events.length > 0 ? deriveStreamsFromEvents(events) : inputs.streams ?? [];
+  return {
+    serviceName: inputs.name,
+    packageName: `${workspaceScope}/${inputs.name}`,
+    servicePath: servicePath.replace(`${workspaceRoot}/`, ""),
+    port,
+    envVarName: toEnvKey(inputs.name),
+    hasEvents,
+    streams,
+    events,
+    workspaceScope,
+    envVars: inputs.envVars
+  };
+};
+var generateFiles = (template, vars) => {
+  return template.files.filter((f) => !f.skip || !f.skip(vars)).map((f) => ({
+    path: f.path,
+    content: f.content(vars)
+  }));
+};
+var buildArtifacts = (files, serviceName, servicePath) => {
+  const fileArtifacts = files.map((f) => ({
+    type: "file",
+    path: join12(servicePath, f.path),
+    description: `Service file: ${f.path}`
+  }));
+  return [
+    ...fileArtifacts,
+    {
+      type: "config",
+      path: `infra/services/${serviceName}.ts`,
+      description: "Infrastructure configuration"
+    },
+    {
+      type: "env",
+      path: ".env.local",
+      description: "Environment variables"
+    }
+  ];
+};
+var buildNextActions = (servicePath) => {
+  return [
+    {
+      command: `cd ${servicePath} && bun dev`,
+      description: "Start this service"
+    },
+    {
+      command: "pf dev",
+      description: "Start all services"
+    }
+  ];
+};
+var planServiceGeneration = (inputs) => {
+  validateServiceName(inputs.name);
+  const workspaceRoot = inputs.workspaceRoot ?? findWorkspaceRoot();
+  const servicePath = resolveServicePath(inputs.name, inputs.path, workspaceRoot);
+  const port = inputs.port ?? allocateNextPort(scanUsedPorts(workspaceRoot), INTERNAL_PORT_START);
+  const vars = buildTemplateVars(inputs, workspaceRoot, servicePath, port);
+  const template = selectTemplate(inputs.type);
+  const files = generateFiles(template, vars);
+  const effects = buildServiceEffects(servicePath, files, vars, template);
+  const artifacts = buildArtifacts(files, inputs.name, servicePath);
+  const next = buildNextActions(servicePath);
+  return ok("service.generate", `Generated ${inputs.name} service (port ${port})`, {
+    artifacts,
+    changes: effects,
+    next,
+    data: {
+      serviceName: inputs.name,
+      servicePath,
+      port,
+      vars
+    }
+  });
+};
+
+// cli/src/core/facade/index.ts
+init_config();
+
+// cli/src/core/plugins/types.ts
+var isElicitInputEffect = (effect) => effect.kind === "elicit:input";
+
+// cli/src/core/facade/context.ts
+init_config();
+var createContextFromWorkspace = async (workspaceRoot, logger) => {
+  const root = workspaceRoot ?? findWorkspaceRoot();
+  const contractsConfig = getContractsConfig(root);
+  const availableServices = discoverAvailableServices(root);
+  const workspace = {
+    workspaceRoot: root,
+    contracts: {
+      path: contractsConfig.packagePath,
+      packageName: contractsConfig.packageName
+    },
+    availableServices
+  };
+  return createPluginContext(workspace, logger);
+};
+var createContext = createPluginContext;
+
+// cli/src/core/facade/tools.ts
+var argToProperty = (arg) => [
+  arg.name,
+  { type: "string", description: arg.description }
+];
+var parseOptionName = (flags) => {
+  const match = flags.match(/--([a-zA-Z0-9-]+)/);
+  return match ? match[1] : null;
+};
+var optionToProperty = (opt) => {
+  const name = parseOptionName(opt.flags);
+  if (!name) return null;
+  return [
+    name,
+    {
+      type: "string",
+      description: opt.description,
+      ...opt.default !== void 0 && { default: opt.default }
+    }
+  ];
+};
+var buildInputSchema = (command) => {
+  const argProperties = Object.fromEntries(command.args.map(argToProperty));
+  const optionProperties = Object.fromEntries(
+    command.options.map(optionToProperty).filter((entry) => entry !== null)
+  );
+  const required = command.args.filter((arg) => arg.required !== false).map((arg) => arg.name);
+  return {
+    type: "object",
+    properties: { ...argProperties, ...optionProperties },
+    ...required.length > 0 && { required }
+  };
+};
+var buildToolName = (pluginName, commandName) => `${pluginName}.${commandName}`;
+var commandToToolSpec = (plugin, command) => ({
+  name: buildToolName(plugin.name, command.name),
+  description: command.description,
+  inputSchema: buildInputSchema(command)
+});
+var commandToExecutableToolSpec = (plugin, command) => ({
+  ...commandToToolSpec(plugin, command),
+  execute: async (args) => {
+    const result = await command.run(args, {});
+    return {
+      ok: true,
+      operation: buildToolName(plugin.name, command.name),
+      summary: formatOutput(result.output) ?? `Executed ${buildToolName(plugin.name, command.name)}`,
+      effects: result.effects ?? [],
+      output: result.output
+    };
+  }
+});
+var formatOutput = (output) => {
+  if (!output) return void 0;
+  return Array.isArray(output) ? output.join("\n") : output;
+};
+var collectToolSpecs = (plugins) => plugins.flatMap(({ plugin }) => plugin.commands.map((cmd) => commandToToolSpec(plugin, cmd)));
+var collectExecutableToolSpecs = (plugins, _context) => plugins.flatMap(({ plugin }) => plugin.commands.map((cmd) => commandToExecutableToolSpec(plugin, cmd)));
+
+// cli/src/core/facade/index.ts
+var loadPlugins = async (moduleNames, context) => Promise.all(moduleNames.map((moduleName) => loadPluginFromModule(moduleName, context)));
+var runFlow = async (plugin, flowName, options) => {
+  const flow = plugin.flows.find((f) => f.name === flowName);
+  if (!flow) {
+    throw new Error(`Flow '${flowName}' not found in plugin '${plugin.name}'`);
+  }
+  const steps = await flow.getSteps(options.initialContext);
+  return flowcoreRunFlow(steps, options);
+};
+var getGeneratorDocsDir = () => {
+  if (typeof import.meta?.url === "string") {
+    const __filename = fileURLToPath3(import.meta.url);
+    const __dirname2 = dirname5(__filename);
+    return join13(__dirname2, "../bin/docs/generators");
+  }
+  if (typeof __dirname !== "undefined") {
+    return join13(__dirname, "../bin/docs/generators");
+  }
+  throw new Error("Cannot determine docs directory: neither import.meta.url nor __dirname available");
+};
+var listGeneratorDocs = async () => {
+  const docsDir = getGeneratorDocsDir();
+  const files = await readdir(docsDir);
+  return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+};
+export {
+  SERVICE_LAYOUT_POLICY_VERSION,
+  aggregateChanges,
+  applyEffects,
+  collectExecutableToolSpecs,
+  collectToolSpecs,
+  createContext,
+  createContextFromWorkspace,
+  err as createErrResult,
+  ok as createOkResult,
+  deriveEventNames4 as deriveEventNames,
+  findWorkspaceRoot,
+  formatChangeDetails,
+  formatChangeSummary,
+  getFrameworkPolicy,
+  getGeneratorDocsDir,
+  getRegisteredProviders,
+  isElicitInputEffect,
+  listGeneratorDocs,
+  loadCapabilitiesConfig,
+  loadCapabilitiesConfigFromWorkspace,
+  loadPlugins,
+  lookupProvider,
+  lowerSpecToCapabilities,
+  parseServicePrompt,
+  planServiceGeneration,
+  resolveProvider,
+  runFlow,
+  serviceLayoutPolicy,
+  validateGeneratedFiles
+};
+//# sourceMappingURL=facade.mjs.map