@mesh-tech/mesh-cli 0.1.1 → 0.12.0

package/dist/src/commands/create-app.js

@@ -1,25 +1,149 @@
 /**
  * mesh create-app - Scaffold a new tenant application
  *
- * Creates a new application using one of the available templates:
- * - api-web-db: API + Web + Database (default)
- * - temporal-api-worker: Temporal Worker + API for workflows
+ * Three modes:
+ * 1. Legacy: `mesh create-app --template workflow --tenant x --name y`
+ * 2. Composable (flags): `mesh create-app --tenant x --name y --primitives service,database`
+ * 3. Interactive: `mesh create-app` (prompts when TTY detected and flags missing)
+ *
+ * All options can be passed as flags for agent/CI usage (no TTY required).
  */
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import Handlebars from "handlebars";
 import { logInfo, logSuccess, logError, logWarn } from "../utils/index.js";
-// Get package root (works from both src/ and dist/)
+import { resolveTargetRoot, syncSkills } from "./skills.js";
+import { findPackageRoot } from "./local/stack.js";
+// Get package root by walking up until we find package.json with our package name.
+// Works from both src/commands/ (tsx) and dist/src/commands/ (compiled).
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-// Navigate from dist/src/commands/ or src/commands/ to package root
-const packageRoot = path.resolve(__dirname, "..", "..", "..");
+const packageRoot = findPackageRoot(__dirname);
 // Available templates
 const TEMPLATES = {
-    "api-web-db": "API + Web + Database application",
-    "temporal-api-worker": "Temporal Worker + API for workflow orchestration",
+    workflow: "Hono API + Temporal worker + hello workflow (Pulumi/app-kit)",
+    "api-auth": "Hono API with platform auth: authn (Zitadel JWT) + authz (SpiceDB)",
+    "api-role-gating": "Hono API with role-gating authz: authn (Zitadel JWT) + coarse-role checks on Zitadel project roles, in-process (no SpiceDB)",
+    "external-service": "Hono API calling a third-party vendor via platform-managed credentials (ExternalService + mock for `mesh dev --externals`)",
+};
+/** Removed templates → what replaced them (named in the unknown-template error). */
+const REMOVED_TEMPLATES = {
+    "temporal-api-worker": "renamed to 'workflow'",
+    "api-web-db": "removed (SST-based) — use --primitives service,database",
+};
+// Available primitives for composable mode
+const PRIMITIVES = {
+    service: "HTTP Service (API with Hono)",
+    database: "Database (PostgreSQL via Prisma)",
+    temporal: "Temporal (workflow orchestration)",
+    bucket: "S3 Bucket (file storage)",
+};
+/**
+ * Hub platform account IDs — the AWS account hosting a shared tenant's
+ * `{tenant}-{env}-apps-deployer` role. Shared tenants (acme, …) deploy into the
+ * hub account, so the generated `mesh:deployerRole` ARN resolves against this map.
+ * `mesh` is the only hub today; add entries as new hubs come online.
+ */
+const HUB_ACCOUNTS = {
+    mesh: "159923586610",
 };
+/**
+ * Walk up from `dir` looking for a `pnpm-workspace.yaml` — the app lives inside a
+ * pnpm monorepo, so `@mesh-tech/*` deps should be `workspace:*` (link local source)
+ * rather than pinned registry versions the local workspace doesn't publish.
+ */
+function isInsideMonorepo(dir) {
+    let cur = path.resolve(dir);
+    while (cur !== path.dirname(cur)) {
+        if (fs.existsSync(path.join(cur, "pnpm-workspace.yaml")))
+            return true;
+        cur = path.dirname(cur);
+    }
+    return false;
+}
+/**
+ * Deployer-role ARN for a shared tenant on a known hub, or a clearly-marked
+ * `ACCOUNT_ID` placeholder when the hub account is unknown (the generated config
+ * comments the fill-in step in that case).
+ */
+function resolveDeployerRoleArn(tenant, platformName, env) {
+    const account = HUB_ACCOUNTS[platformName] ?? "ACCOUNT_ID";
+    return `arn:aws:iam::${account}:role/${tenant}-${env}-apps-deployer`;
+}
+const VALID_PRIMITIVES = Object.keys(PRIMITIVES);
+// =============================================================================
+// Standalone apps-repo bootstrap
+// =============================================================================
+/**
+ * A fresh standalone tenant-apps repo (empty clone of {tenant}-mesh-apps) is
+ * bootstrappable when the cwd is a git repo root that has none of the layouts
+ * `resolveAppDir` looks for. Previously create-app exited with "Tenant
+ * directory not found: tenants/<t>/" here — even though the app-tenant
+ * doctor's Repo-shape check names create-app as the fix ("workspace files
+ * included"), so the command must actually deliver them.
+ */
+export function shouldBootstrapAppsRepo(cwd) {
+    return (fs.existsSync(path.join(cwd, ".git")) &&
+        !isInsideMonorepo(cwd) &&
+        !fs.existsSync(path.join(cwd, "package.json")) &&
+        !fs.existsSync(path.join(cwd, "tenants")) &&
+        !fs.existsSync(path.join(cwd, "apps")));
+}
+/**
+ * Generate the repo-level files of a standalone tenant-apps repo (the
+ * trabian-mesh-apps shape): pnpm workspace over apps/*, private root
+ * package.json, scoped CodeArtifact .npmrc, base tsconfig, .gitignore, README.
+ * Only writes files that don't already exist; returns what it created.
+ */
+export function bootstrapAppsRepo(cwd, tenant) {
+    const templateDir = path.join(packageRoot, "templates", "apps-repo");
+    const registryAccount = HUB_ACCOUNTS.mesh;
+    const context = {
+        repoName: path.basename(cwd),
+        tenant,
+        tenantTitle: tenant
+            .split("-")
+            .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+            .join(" "),
+        registryUrl: `https://mesh-platform-${registryAccount}.d.codeartifact.us-east-2.amazonaws.com/npm/mesh-packages/`,
+    };
+    const staging = fs.mkdtempSync(path.join(os.tmpdir(), "mesh-apps-repo-"));
+    try {
+        copyTemplate(templateDir, staging, context);
+        // npm strips dotfiles from published tarballs, so the template ships
+        // `gitignore`/`npmrc` and the bootstrap restores the real names.
+        for (const [from, to] of [
+            ["gitignore", ".gitignore"],
+            ["npmrc", ".npmrc"],
+        ]) {
+            const p = path.join(staging, from);
+            if (fs.existsSync(p))
+                fs.renameSync(p, path.join(staging, to));
+        }
+        const created = [];
+        for (const entry of fs.readdirSync(staging)) {
+            const dest = path.join(cwd, entry);
+            if (fs.existsSync(dest))
+                continue;
+            fs.cpSync(path.join(staging, entry), dest, { recursive: true });
+            created.push(entry);
+        }
+        fs.mkdirSync(path.join(cwd, "apps"), { recursive: true });
+        created.push("apps/");
+        return created;
+    }
+    finally {
+        fs.rmSync(staging, { recursive: true, force: true });
+    }
+}
+function maybeBootstrapAppsRepo(cwd, tenant, test) {
+    if (test || !shouldBootstrapAppsRepo(cwd))
+        return;
+    const created = bootstrapAppsRepo(cwd, tenant);
+    logInfo(`Standalone apps repo detected — bootstrapped workspace files: ${created.join(", ")}`);
+}
 // Register Handlebars helpers
 Handlebars.registerHelper("titleCase", (str) => {
     return str
@@ -27,10 +151,62 @@ Handlebars.registerHelper("titleCase", (str) => {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join(" ");
 });
+/**
+ * Check if we're in an interactive terminal
+ */
+function isInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/**
+ * Run interactive prompts to gather missing options.
+ * Only called when TTY is available and required options are missing.
+ */
+async function promptForOptions(options) {
+    // Dynamic imports so non-interactive usage doesn't load inquirer
+    const { default: input } = await import("@inquirer/input");
+    const { default: checkbox } = await import("@inquirer/checkbox");
+    const tenant = options.tenant ??
+        (await input({
+            message: "Tenant name",
+            validate: (v) => (v.length > 0 ? true : "Tenant name is required"),
+        }));
+    const name = options.name ??
+        (await input({
+            message: "App name",
+            validate: (v) => (v.length > 0 ? true : "App name is required"),
+        }));
+    let primitives;
+    if (options.primitives) {
+        primitives = parsePrimitives(options.primitives);
+    }
+    else {
+        primitives = await checkbox({
+            message: "Select primitives",
+            choices: VALID_PRIMITIVES.map((p) => ({
+                name: PRIMITIVES[p],
+                value: p,
+                checked: p === "service", // service checked by default
+            })),
+        });
+        if (primitives.length === 0) {
+            primitives = ["service"];
+        }
+    }
+    // Database and bucket place files in api/ — ensure service is included
+    if (primitives.includes("database") && !primitives.includes("service")) {
+        primitives.push("service");
+        logInfo("Added 'service' — database files live in the api/ directory.");
+    }
+    if (primitives.includes("bucket") && !primitives.includes("service")) {
+        primitives.push("service");
+        logInfo("Added 'service' — bucket requires an API service for S3 helpers.");
+    }
+    return { tenant, name, primitives };
+}
 /**
  * Recursively copy a directory, processing .hbs templates
  */
-function copyTemplate(srcDir, destDir, context) {
+export function copyTemplate(srcDir, destDir, context) {
     const entries = fs.readdirSync(srcDir, { withFileTypes: true });
     for (const entry of entries) {
         const srcPath = path.join(srcDir, entry.name);
@@ -39,6 +215,10 @@ function copyTemplate(srcDir, destDir, context) {
         if (destName.endsWith(".hbs")) {
             destName = destName.slice(0, -4);
         }
+        // File names can be templated too (e.g. Pulumi.{{tenant}}-{{env}}.yaml.hbs)
+        if (destName.includes("{{")) {
+            destName = Handlebars.compile(destName)(context);
+        }
         const destPath = path.join(destDir, destName);
         if (entry.isDirectory()) {
             fs.mkdirSync(destPath, { recursive: true });
@@ -57,120 +237,298 @@ function copyTemplate(srcDir, destDir, context) {
         }
     }
 }
+/**
+ * Parse and validate primitive selections from comma-separated string
+ */
+function parsePrimitives(input) {
+    const selected = input.split(",").map((s) => s.trim().toLowerCase());
+    const invalid = selected.filter((s) => !VALID_PRIMITIVES.includes(s));
+    if (invalid.length > 0) {
+        logError(`Unknown primitives: ${invalid.join(", ")}`);
+        logInfo(`Available primitives: ${VALID_PRIMITIVES.join(", ")}`);
+        process.exit(1);
+    }
+    return selected;
+}
+/**
+ * Resolve output directory for the app
+ */
+function resolveAppDir(cwd, tenant, name, test) {
+    const baseDir = test ? "tests/tenants" : "tenants";
+    const possiblePaths = [
+        path.join(cwd, baseDir, tenant, "apps"),
+        path.join(cwd, "..", tenant, "apps"),
+        path.join(cwd, "apps"),
+    ];
+    let appsDir = possiblePaths.find((p) => fs.existsSync(p));
+    if (!appsDir) {
+        appsDir = path.join(cwd, baseDir, tenant, "apps");
+        if (!fs.existsSync(path.join(cwd, baseDir, tenant))) {
+            logError(`Tenant directory not found: ${baseDir}/${tenant}/`);
+            logInfo("Create the tenant directory first, or run from within it.");
+            process.exit(1);
+        }
+        if (!fs.existsSync(appsDir)) {
+            logInfo(`Creating apps directory: ${appsDir}`);
+            fs.mkdirSync(appsDir, { recursive: true });
+        }
+    }
+    return path.join(appsDir, name);
+}
+/**
+ * Generate a composable app from fragments
+ */
+function generateComposableApp(appDir, context) {
+    const fragmentsDir = path.join(packageRoot, "fragments");
+    // 1. Always copy base fragment
+    const baseDir = path.join(fragmentsDir, "base");
+    if (!fs.existsSync(baseDir)) {
+        logError(`Fragments directory not found: ${baseDir}`);
+        logInfo("Make sure the mesh-cli package is installed correctly.");
+        process.exit(1);
+    }
+    copyTemplate(baseDir, appDir, context);
+    // 2. Copy primitive-specific fragments
+    if (context.service) {
+        const serviceDir = path.join(fragmentsDir, "service");
+        if (!fs.existsSync(serviceDir)) {
+            throw new Error(`Fragment directory not found: ${serviceDir}`);
+        }
+        copyTemplate(serviceDir, appDir, context);
+    }
+    if (context.database) {
+        const dbDir = path.join(fragmentsDir, "database");
+        if (!fs.existsSync(dbDir)) {
+            throw new Error(`Fragment directory not found: ${dbDir}`);
+        }
+        copyTemplate(dbDir, appDir, context);
+    }
+    if (context.temporal) {
+        const temporalDir = path.join(fragmentsDir, "temporal");
+        if (!fs.existsSync(temporalDir)) {
+            throw new Error(`Fragment directory not found: ${temporalDir}`);
+        }
+        copyTemplate(temporalDir, appDir, context);
+    }
+    if (context.bucket) {
+        const bucketDir = path.join(fragmentsDir, "bucket");
+        if (!fs.existsSync(bucketDir)) {
+            throw new Error(`Fragment directory not found: ${bucketDir}`);
+        }
+        copyTemplate(bucketDir, appDir, context);
+    }
+    // 3. Always generate AGENTS.md
+    const agentsDir = path.join(fragmentsDir, "agents");
+    if (fs.existsSync(agentsDir)) {
+        copyTemplate(agentsDir, appDir, context);
+    }
+}
 export function registerCreateAppCommand(program) {
     program
         .command("create-app")
         .description("Scaffold a new tenant application")
-        .requiredOption("--tenant <tenant>", "Tenant name (e.g., acme)")
-        .requiredOption("--name <name>", "Application name (e.g., billing)")
-        .option("--template <template>", `Template to use: ${Object.keys(TEMPLATES).join(", ")}`, "api-web-db")
+        .option("--tenant <tenant>", "Tenant name (e.g., acme)")
+        .option("--name <name>", "Application name (e.g., billing)")
+        .option("--template <template>", `Legacy template: ${Object.keys(TEMPLATES).join(", ")}`)
+        .option("--primitives <primitives>", `Comma-separated primitives: ${VALID_PRIMITIVES.join(", ")} (default: service)`)
         .option("--test", "Create in tests/tenants/ directory", false)
         .action(async (options) => {
-        const { tenant, name, template, test } = options;
-        // Validate template
-        if (!Object.keys(TEMPLATES).includes(template)) {
-            logError(`Unknown template: ${template}`);
-            logInfo(`Available templates:`);
-            for (const [name, desc] of Object.entries(TEMPLATES)) {
-                console.log(`  ${name.padEnd(20)} - ${desc}`);
+        // Legacy template mode — requires all flags
+        if (options.template) {
+            if (!options.tenant || !options.name) {
+                logError("--tenant and --name are required with --template");
+                process.exit(1);
             }
-            process.exit(1);
+            await runLegacyTemplate(options.tenant, options.name, options.template, options.test);
+            return;
         }
-        logInfo(`Creating app '${name}' for tenant '${tenant}'...`);
-        logInfo(`Template: ${template} (${TEMPLATES[template]})`);
-        if (test) {
-            logInfo("Creating in tests/ directory");
-        }
-        // Determine output directory
-        const cwd = process.cwd();
-        let appsDir;
-        // Base directory depends on --test flag
-        const baseDir = test ? "tests/tenants" : "tenants";
-        // Check common locations
-        const possiblePaths = [
-            path.join(cwd, baseDir, tenant, "apps"),
-            path.join(cwd, "..", tenant, "apps"),
-            path.join(cwd, "apps"),
-        ];
-        const foundPath = possiblePaths.find((p) => fs.existsSync(p));
-        if (foundPath) {
-            appsDir = foundPath;
+        // Composable mode — interactive or flag-based
+        let tenant;
+        let name;
+        let primitives;
+        const needsPrompt = !options.tenant || !options.name || !options.primitives;
+        if (needsPrompt && isInteractive()) {
+            // Interactive: prompt for missing values
+            const prompted = await promptForOptions(options);
+            tenant = prompted.tenant;
+            name = prompted.name;
+            primitives = prompted.primitives;
         }
-        else {
-            // Default to {baseDir}/{tenant}/apps relative to cwd
-            appsDir = path.join(cwd, baseDir, tenant, "apps");
-            if (!fs.existsSync(path.join(cwd, baseDir, tenant))) {
-                logError(`Tenant directory not found: ${baseDir}/${tenant}/`);
-                logInfo("Create the tenant directory first, or run from within it.");
+        else if (needsPrompt) {
+            // Non-interactive but missing flags
+            if (!options.tenant) {
+                logError("--tenant is required (no TTY for interactive mode)");
                 process.exit(1);
             }
-            if (!fs.existsSync(appsDir)) {
-                logInfo(`Creating apps directory: ${appsDir}`);
-                fs.mkdirSync(appsDir, { recursive: true });
+            if (!options.name) {
+                logError("--name is required (no TTY for interactive mode)");
+                process.exit(1);
             }
+            tenant = options.tenant;
+            name = options.name;
+            primitives = options.primitives
+                ? parsePrimitives(options.primitives)
+                : ["service"];
         }
-        const appDir = path.join(appsDir, name);
-        // Check if app already exists
-        if (fs.existsSync(appDir)) {
-            logError(`App directory already exists: ${appDir}`);
-            logInfo("Choose a different name or remove the existing directory.");
-            process.exit(1);
-        }
-        // Find template directory (at package root, not in dist)
-        const templateDir = path.join(packageRoot, "templates", template);
-        if (!fs.existsSync(templateDir)) {
-            logError(`Template not found: ${templateDir}`);
-            logInfo("Make sure the mesh-cli package is installed correctly.");
-            process.exit(1);
-        }
-        // Create context for templates
-        const context = {
-            name,
-            tenant,
-        };
-        // Create app directory
-        logInfo(`Creating app at ${appDir}...`);
-        fs.mkdirSync(appDir, { recursive: true });
-        // Copy and process templates
-        try {
-            copyTemplate(templateDir, appDir, context);
-            logSuccess(`Created app structure at ${appDir}`);
-        }
-        catch (error) {
-            logError(`Failed to create app: ${error}`);
-            // Clean up on failure
-            fs.rmSync(appDir, { recursive: true, force: true });
-            process.exit(1);
+        else {
+            tenant = options.tenant;
+            name = options.name;
+            primitives = parsePrimitives(options.primitives);
         }
-        // Check if config.ts exists in parent apps directory
-        const configPath = path.join(appsDir, "config.ts");
-        if (!fs.existsSync(configPath)) {
-            logWarn(`No config.ts found at ${configPath}`);
-            logInfo("You may need to create a shared config.ts for tenant apps.");
-            logInfo("See existing apps for an example.");
-        }
-        // Print next steps
-        console.log("");
-        logSuccess("App created successfully!");
-        console.log("");
-        console.log("Next steps:");
-        console.log(`  cd ${appDir}`);
-        console.log("  pnpm install");
-        if (template === "temporal-api-worker") {
-            console.log("");
-            console.log("For development:");
-            console.log("  1. Start dev server: pnpm mesh dev");
-            console.log("     (auto-starts tunnel to Temporal + DB)");
-            console.log("  2. Start worker manually in SST dev UI");
-            console.log("  3. Open Temporal Web UI: http://localhost:8080");
+        // Database and bucket place files in api/ — ensure service is included
+        if (primitives.includes("database") && !primitives.includes("service")) {
+            primitives.push("service");
+            logInfo("Added 'service' — database files live in the api/ directory.");
         }
-        else {
-            console.log("  pnpm mesh dev");
+        if (primitives.includes("bucket") && !primitives.includes("service")) {
+            primitives.push("service");
+            logInfo("Added 'service' — bucket requires an API service for S3 helpers.");
         }
-        console.log("");
-        console.log("To deploy:");
-        console.log("  pnpm deploy --stage dev");
-        console.log("");
+        await runComposable(tenant, name, primitives, options.test);
     });
 }
+async function runLegacyTemplate(tenant, name, template, test) {
+    if (!Object.keys(TEMPLATES).includes(template)) {
+        const removed = REMOVED_TEMPLATES[template];
+        logError(`Unknown template: ${template}${removed ? ` (${removed})` : ""}`);
+        logInfo(`Available templates:`);
+        for (const [tplName, desc] of Object.entries(TEMPLATES)) {
+            console.log(`  ${tplName.padEnd(20)} - ${desc}`);
+        }
+        process.exit(1);
+    }
+    logInfo(`Creating app '${name}' for tenant '${tenant}'...`);
+    logInfo(`Template: ${template} (${TEMPLATES[template]})`);
+    if (test) {
+        logInfo("Creating in tests/ directory");
+    }
+    maybeBootstrapAppsRepo(process.cwd(), tenant, test);
+    const appDir = resolveAppDir(process.cwd(), tenant, name, test);
+    if (fs.existsSync(appDir)) {
+        logError(`App directory already exists: ${appDir}`);
+        process.exit(1);
+    }
+    const templateDir = path.join(packageRoot, "templates", template);
+    if (!fs.existsSync(templateDir)) {
+        logError(`Template not found: ${templateDir}`);
+        process.exit(1);
+    }
+    fs.mkdirSync(appDir, { recursive: true });
+    try {
+        copyTemplate(templateDir, appDir, { name, tenant });
+        logSuccess(`Created app at ${appDir}`);
+    }
+    catch (error) {
+        logError(`Failed to create app: ${error}`);
+        fs.rmSync(appDir, { recursive: true, force: true });
+        process.exit(1);
+    }
+    autoSyncSkills(appDir);
+    printLegacyNextSteps(appDir, template);
+}
+/** Best-effort skills sync after scaffolding (design D1): a fresh Claude
+ * session in the repo sees the base skills + Intent discovery immediately. */
+function autoSyncSkills(appDir) {
+    try {
+        syncSkills(resolveTargetRoot(appDir));
+    }
+    catch (err) {
+        logWarn(`Agent-skill sync skipped: ${err instanceof Error ? err.message : err} — run: mesh skills sync`);
+    }
+}
+async function runComposable(tenant, name, primitives, test) {
+    logInfo(`Creating app '${name}' for tenant '${tenant}'...`);
+    logInfo(`Primitives: ${primitives.join(", ")}`);
+    if (test) {
+        logInfo("Creating in tests/ directory");
+    }
+    maybeBootstrapAppsRepo(process.cwd(), tenant, test);
+    const appDir = resolveAppDir(process.cwd(), tenant, name, test);
+    if (fs.existsSync(appDir)) {
+        logError(`App directory already exists: ${appDir}`);
+        process.exit(1);
+    }
+    // Platform defaults (the generated Pulumi config targets the mesh hub / dev).
+    const region = "us-east-2";
+    const platformName = "mesh";
+    const platformEnv = "dev";
+    const context = {
+        name,
+        tenant,
+        service: primitives.includes("service"),
+        database: primitives.includes("database"),
+        temporal: primitives.includes("temporal"),
+        bucket: primitives.includes("bucket"),
+        region,
+        // Link local source when generating inside this monorepo; pin only for
+        // out-of-repo tenant repos that install `@mesh-tech/*` from the registry.
+        workspaceDeps: isInsideMonorepo(appDir),
+        deployerRoleArn: resolveDeployerRoleArn(tenant, platformName, platformEnv),
+    };
+    fs.mkdirSync(appDir, { recursive: true });
+    try {
+        generateComposableApp(appDir, context);
+        logSuccess(`Created app at ${appDir}`);
+    }
+    catch (error) {
+        logError(`Failed to create app: ${error}`);
+        fs.rmSync(appDir, { recursive: true, force: true });
+        process.exit(1);
+    }
+    // Check for config.ts
+    const configPath = path.join(path.dirname(appDir), "config.ts");
+    if (!fs.existsSync(configPath)) {
+        logWarn(`No config.ts found at ${configPath}`);
+        logInfo("You may need to create a shared config.ts for tenant apps.");
+    }
+    autoSyncSkills(appDir);
+    printComposableNextSteps(appDir, context);
+}
+function printLegacyNextSteps(appDir, _template) {
+    const configPath = path.join(path.dirname(appDir), "config.ts");
+    if (!fs.existsSync(configPath)) {
+        logWarn(`No config.ts found at ${configPath}`);
+        logInfo("You may need to create a shared config.ts for tenant apps.");
+    }
+    console.log("");
+    logSuccess("App created successfully!");
+    console.log("");
+    console.log("Next steps:");
+    console.log(`  cd ${appDir}`);
+    console.log("  pnpm install");
+    console.log("  pnpm mesh dev");
+    console.log("");
+    console.log("To deploy:");
+    console.log("  pnpm mesh deploy up");
+    console.log("");
+}
+function printComposableNextSteps(appDir, context) {
+    console.log("");
+    logSuccess("App created successfully!");
+    console.log("");
+    console.log("Generated:");
+    console.log("  index.ts          Pulumi app definition");
+    console.log("  AGENTS.md         AI agent instructions");
+    console.log("  CLAUDE.md         Bridges AGENTS.md into Claude Code (@AGENTS.md)");
+    if (context.service) {
+        console.log("  api/              HTTP service (Hono)");
+    }
+    if (context.temporal) {
+        console.log("  worker/           Temporal worker");
+    }
+    if (context.database) {
+        console.log("  prisma/           Database schema");
+    }
+    if (context.bucket) {
+        console.log("  api/src/storage.ts  S3 helpers");
+    }
+    console.log("");
+    console.log("Next steps:");
+    console.log(`  cd ${appDir}`);
+    console.log("  pnpm install");
+    console.log("  mesh stack init          # personal dev stack (deploy: false)");
+    console.log("  mesh deploy up --yes     # deploy via the stack's deployer role");
+    console.log("  mesh dev                 # run locally");
+    console.log("");
+}
 //# sourceMappingURL=create-app.js.map