@standardagents/cli 0.10.1-next.bbd142a → 0.11.0-next.ab7e1ea

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import fs, { readFileSync } from 'fs';
-import path, { dirname, resolve } from 'path';
+import fs3, { readFileSync } from 'fs';
+import path3, { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import crypto from 'crypto';
 import readline from 'readline';
@@ -10,6 +10,7 @@ import chalk from 'chalk';
 import { parse, modify, applyEdits } from 'jsonc-parser';
 import { loadFile, writeFile, generateCode } from 'magicast';
 import { addVitePlugin } from 'magicast/helpers';
+import net from 'net';
 
 var logger = {
   success: (message) => {
@@ -205,15 +206,24 @@ Models define which LLM provider and model to use for prompts.
 import { defineModel } from '@standardagents/builder';
 
 export default defineModel({
-  name: 'gpt-4o',
-  provider: 'openai',
-  model: 'gpt-4o',
-  fallbacks: ['gpt-4-turbo', 'gpt-3.5-turbo'],
-  inputPrice: 2.5,
-  outputPrice: 10,
+  name: 'default',
+  provider: 'openrouter',
+  model: 'google/gemini-3-flash-preview',
+  fallbacks: ['fast', 'cheap-heavy'],
 });
 \`\`\`
 
+## Recommended Models (OpenRouter)
+
+| Use Case | Model ID | Description |
+|----------|----------|-------------|
+| Fast/Cheap | \`z-ai/glm-4.5-air\` | Quick responses, low cost |
+| Mid-tier | \`google/gemini-3-flash-preview\` | Good balance of speed and quality |
+| Cheap Heavy | \`z-ai/glm-4.7\` | More capable, still affordable |
+| Heavy | \`google/gemini-3-pro-preview\` | Most capable, for complex tasks |
+
+**\u26A0\uFE0F Google Models**: When using Google models (\`google/gemini-*\`), you must enable \`reasoning\` in your prompt configuration or tool calls will fail. See the prompts CLAUDE.md for details.
+
 ## Provider API Keys
 
 Set these environment variables in \`.dev.vars\` (local) or Cloudflare secrets (production):
@@ -241,16 +251,16 @@ For OpenRouter, use the full model path:
 
 \`\`\`typescript
 export default defineModel({
-  name: 'claude-3-opus',
+  name: 'heavy',
   provider: 'openrouter',
-  model: 'anthropic/claude-3-opus',
-  includedProviders: ['anthropic'],  // Prefer Anthropic's servers
+  model: 'google/gemini-3-pro-preview',
+  includedProviders: ['google'],  // Prefer Google's servers
 });
 \`\`\`
 
 ## Best Practices
 
-- **Name by use case**, not model ID (e.g., \`fast_reasoning\` not \`gpt-4o-mini\`)
+- **Name by use case**, not model ID (e.g., \`fast\`, \`default\`, \`heavy\`)
 - **Configure fallbacks** for production reliability
 - **Set pricing** for cost tracking in logs
 - **Use environment variables** for API keys, never hardcode
@@ -292,7 +302,7 @@ import { definePrompt } from '@standardagents/builder';
 export default definePrompt({
   name: 'customer_support',
   toolDescription: 'Handle customer support inquiries',
-  model: 'gpt-4o',
+  model: 'default',
   prompt: \`You are a helpful customer support agent.
 Always be polite and professional.
 If you cannot help, escalate to a human.\`,
@@ -309,7 +319,7 @@ Include other prompts for reusable instruction blocks:
 export default definePrompt({
   name: 'main_assistant',
   toolDescription: 'Primary assistant',
-  model: 'gpt-4o',
+  model: 'default',
   prompt: [
     { type: 'text', content: 'You are a helpful assistant.\\n\\n' },
     { type: 'include', prompt: 'common_rules' },  // Includes another prompt
@@ -345,7 +355,7 @@ import { z } from 'zod';
 export default definePrompt({
   name: 'data_extractor',
   toolDescription: 'Extract structured data from text',
-  model: 'gpt-4o',
+  model: 'default',
   prompt: 'Extract the requested data from the input.',
   requiredSchema: z.object({
     text: z.string().describe('Text to extract from'),
@@ -362,7 +372,7 @@ Enable for complex reasoning tasks:
 export default definePrompt({
   name: 'code_reviewer',
   toolDescription: 'Review code for issues',
-  model: 'claude-3-opus',
+  model: 'heavy',
   prompt: 'Review the code thoroughly...',
   reasoning: {
     effort: 'high',      // 'low' | 'medium' | 'high'
@@ -372,6 +382,14 @@ export default definePrompt({
 });
 \`\`\`
 
+**\u26A0\uFE0F Google Models Require Reasoning**: When using Google models (\`google/gemini-*\`) via OpenRouter, you **must** include \`reasoning\` configuration or tool calls will fail. At minimum:
+
+\`\`\`typescript
+reasoning: {
+  effort: 'low',  // Can be 'low', 'medium', or 'high'
+},
+\`\`\`
+
 ## Best Practices
 
 - **Write clear instructions** - Structure with headers and bullet points
@@ -483,9 +501,15 @@ Other prompts can then include it in their \`handoffAgents\` array.
 4. **stopOnResponse** - Ends turn when LLM returns text
 5. **maxSessionTurns** - Ends conversation (hard limit: 250)
 
+## Naming Convention
+
+Agent names **must** end with the \`_agent\` suffix (e.g., \`support_agent\`, \`research_agent\`).
+This convention is enforced by the builder UI and makes agents easily identifiable in logs and code.
+
 ## Best Practices
 
 - **Use descriptive names** (\`customer_support_agent\` not \`agent1\`)
+- **Always use the _agent suffix** - names like \`support_agent\`, \`research_agent\`
 - **Always set maxTurns** as a safety limit
 - **Match stop conditions to use case** - chat apps use stopOnResponse, workflows use stopTool
 - **Use labels** for clarity in logs and UI
@@ -1019,23 +1043,23 @@ export default {
 export { DurableThread, DurableAgentBuilder }
 `;
 function getProjectName(cwd) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
+  const packageJsonPath = path3.join(cwd, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
     try {
-      const pkg2 = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      const pkg2 = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
       if (pkg2.name) {
         return pkg2.name.replace(/^@[^/]+\//, "");
       }
     } catch {
     }
   }
-  return path.basename(cwd);
+  return path3.basename(cwd);
 }
 function findViteConfig(cwd) {
   const candidates = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
   for (const candidate of candidates) {
-    const configPath = path.join(cwd, candidate);
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(cwd, candidate);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -1044,8 +1068,8 @@ function findViteConfig(cwd) {
 function findWranglerConfig(cwd) {
   const candidates = ["wrangler.jsonc", "wrangler.json"];
   for (const candidate of candidates) {
-    const configPath = path.join(cwd, candidate);
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(cwd, candidate);
+    if (fs3.existsSync(configPath)) {
       return configPath;
     }
   }
@@ -1054,7 +1078,7 @@ function findWranglerConfig(cwd) {
 async function modifyViteConfig(configPath, force) {
   try {
     const mod = await loadFile(configPath);
-    const code = fs.readFileSync(configPath, "utf-8");
+    const code = fs3.readFileSync(configPath, "utf-8");
     const hasCloudflare = code.includes("@cloudflare/vite-plugin") || code.includes("cloudflare()");
     const hasAgentBuilder = code.includes("@standardagents/builder") || code.includes("agentbuilder()");
     if (hasCloudflare && hasAgentBuilder && !force) {
@@ -1097,7 +1121,7 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
   const existingConfig = findWranglerConfig(cwd);
   if (existingConfig && !force) {
     try {
-      const text = fs.readFileSync(existingConfig, "utf-8");
+      const text = fs3.readFileSync(existingConfig, "utf-8");
       const config = parse(text);
       const hasBindings = config.durable_objects?.bindings?.some(
         (b) => b.name === "AGENT_BUILDER_THREAD" || b.name === "AGENT_BUILDER"
@@ -1144,7 +1168,7 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
         }, {});
         result = applyEdits(result, edits);
       }
-      fs.writeFileSync(existingConfig, result, "utf-8");
+      fs3.writeFileSync(existingConfig, result, "utf-8");
       logger.success("Updated wrangler.jsonc with Standard Agents configuration");
       return true;
     } catch (error) {
@@ -1152,9 +1176,9 @@ function createOrUpdateWranglerConfig(cwd, projectName, force) {
       return false;
     }
   }
-  const wranglerPath = path.join(cwd, "wrangler.jsonc");
+  const wranglerPath = path3.join(cwd, "wrangler.jsonc");
   const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  fs.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
+  fs3.writeFileSync(wranglerPath, WRANGLER_TEMPLATE(sanitizedName), "utf-8");
   logger.success("Created wrangler.jsonc");
   return true;
 }
@@ -1162,33 +1186,33 @@ function getWorkerEntryPoint(cwd) {
   const wranglerConfig = findWranglerConfig(cwd);
   if (wranglerConfig) {
     try {
-      const text = fs.readFileSync(wranglerConfig, "utf-8");
+      const text = fs3.readFileSync(wranglerConfig, "utf-8");
       const config = parse(text);
       if (config.main) {
-        return path.join(cwd, config.main);
+        return path3.join(cwd, config.main);
       }
     } catch {
     }
   }
-  return path.join(cwd, "worker", "index.ts");
+  return path3.join(cwd, "worker", "index.ts");
 }
 async function createOrUpdateWorkerEntry(cwd, force) {
   const entryPath = getWorkerEntryPoint(cwd);
-  const entryDir = path.dirname(entryPath);
-  if (!fs.existsSync(entryDir)) {
-    fs.mkdirSync(entryDir, { recursive: true });
-    logger.success(`Created ${path.relative(cwd, entryDir)} directory`);
-  }
-  if (!fs.existsSync(entryPath)) {
-    fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-    logger.success(`Created ${path.relative(cwd, entryPath)}`);
+  const entryDir = path3.dirname(entryPath);
+  if (!fs3.existsSync(entryDir)) {
+    fs3.mkdirSync(entryDir, { recursive: true });
+    logger.success(`Created ${path3.relative(cwd, entryDir)} directory`);
+  }
+  if (!fs3.existsSync(entryPath)) {
+    fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+    logger.success(`Created ${path3.relative(cwd, entryPath)}`);
     return true;
   }
-  const content = fs.readFileSync(entryPath, "utf-8");
+  const content = fs3.readFileSync(entryPath, "utf-8");
   const hasRouter = content.includes("virtual:@standardagents/builder") && content.includes("router");
   const hasDurableExports = content.includes("DurableThread") && content.includes("DurableAgentBuilder");
   if (hasRouter && hasDurableExports && !force) {
-    logger.info(`${path.relative(cwd, entryPath)} already configured`);
+    logger.info(`${path3.relative(cwd, entryPath)} already configured`);
     return true;
   }
   try {
@@ -1216,17 +1240,17 @@ async function createOrUpdateWorkerEntry(cwd, force) {
     }
     const { code } = generateCode(mod);
     if (force || !hasRouter) {
-      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-      logger.success(`Updated ${path.relative(cwd, entryPath)} with Standard Agents router`);
+      fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Updated ${path3.relative(cwd, entryPath)} with Standard Agents router`);
     }
     return true;
   } catch (error) {
     if (force) {
-      fs.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
-      logger.success(`Created ${path.relative(cwd, entryPath)}`);
+      fs3.writeFileSync(entryPath, WORKER_INDEX, "utf-8");
+      logger.success(`Created ${path3.relative(cwd, entryPath)}`);
       return true;
     }
-    logger.warning(`Could not automatically modify ${path.relative(cwd, entryPath)}`);
+    logger.warning(`Could not automatically modify ${path3.relative(cwd, entryPath)}`);
     logger.log("");
     logger.log("Please ensure your worker entry point includes:");
     logger.log("");
@@ -1245,31 +1269,31 @@ async function createOrUpdateWorkerEntry(cwd, force) {
   }
 }
 function createDurableObjects(cwd) {
-  const agentsDir = path.join(cwd, "agents");
-  if (!fs.existsSync(agentsDir)) {
-    fs.mkdirSync(agentsDir, { recursive: true });
+  const agentsDir = path3.join(cwd, "agents");
+  if (!fs3.existsSync(agentsDir)) {
+    fs3.mkdirSync(agentsDir, { recursive: true });
   }
-  const threadPath = path.join(agentsDir, "Thread.ts");
-  if (!fs.existsSync(threadPath)) {
-    fs.writeFileSync(threadPath, THREAD_TS, "utf-8");
+  const threadPath = path3.join(agentsDir, "Thread.ts");
+  if (!fs3.existsSync(threadPath)) {
+    fs3.writeFileSync(threadPath, THREAD_TS, "utf-8");
     logger.success("Created agents/Thread.ts");
   } else {
     logger.info("agents/Thread.ts already exists");
   }
-  const agentBuilderPath = path.join(agentsDir, "AgentBuilder.ts");
-  if (!fs.existsSync(agentBuilderPath)) {
-    fs.writeFileSync(agentBuilderPath, AGENT_BUILDER_TS, "utf-8");
+  const agentBuilderPath = path3.join(agentsDir, "AgentBuilder.ts");
+  if (!fs3.existsSync(agentBuilderPath)) {
+    fs3.writeFileSync(agentBuilderPath, AGENT_BUILDER_TS, "utf-8");
     logger.success("Created agents/AgentBuilder.ts");
   } else {
     logger.info("agents/AgentBuilder.ts already exists");
   }
 }
 function createDirectoriesAndDocs(cwd) {
-  const agentsDir = path.join(cwd, "agents");
-  const rootDocPath = path.join(agentsDir, "CLAUDE.md");
-  if (!fs.existsSync(rootDocPath)) {
-    fs.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
-    logger.success("Created agents/CLAUDE.md");
+  path3.join(cwd, "agents");
+  const rootDocPath = path3.join(cwd, "CLAUDE.md");
+  if (!fs3.existsSync(rootDocPath)) {
+    fs3.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
+    logger.success("Created CLAUDE.md");
   }
   const directories = [
     { path: "agents/agents", doc: AGENTS_CLAUDE_MD },
@@ -1280,26 +1304,26 @@ function createDirectoriesAndDocs(cwd) {
     { path: "agents/api", doc: API_CLAUDE_MD }
   ];
   for (const dir of directories) {
-    const dirPath = path.join(cwd, dir.path);
-    const docPath = path.join(dirPath, "CLAUDE.md");
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
+    const dirPath = path3.join(cwd, dir.path);
+    const docPath = path3.join(dirPath, "CLAUDE.md");
+    if (!fs3.existsSync(dirPath)) {
+      fs3.mkdirSync(dirPath, { recursive: true });
       logger.success(`Created ${dir.path}`);
     }
-    if (!fs.existsSync(docPath)) {
-      fs.writeFileSync(docPath, dir.doc, "utf-8");
+    if (!fs3.existsSync(docPath)) {
+      fs3.writeFileSync(docPath, dir.doc, "utf-8");
       logger.success(`Created ${dir.path}/CLAUDE.md`);
     }
   }
 }
 function updateTsConfig(cwd) {
-  const tsconfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs.existsSync(tsconfigPath)) {
+  const tsconfigPath = path3.join(cwd, "tsconfig.json");
+  if (!fs3.existsSync(tsconfigPath)) {
     logger.info("No tsconfig.json found, skipping TypeScript configuration");
     return;
   }
   try {
-    const text = fs.readFileSync(tsconfigPath, "utf-8");
+    const text = fs3.readFileSync(tsconfigPath, "utf-8");
     const config = parse(text);
     let result = text;
     const types = config.compilerOptions?.types || [];
@@ -1321,7 +1345,7 @@ function updateTsConfig(cwd) {
       result = applyEdits(result, edits);
     }
     if (newTypes.length > 0 || newIncludes.length > 0) {
-      fs.writeFileSync(tsconfigPath, result, "utf-8");
+      fs3.writeFileSync(tsconfigPath, result, "utf-8");
       logger.success("Updated tsconfig.json with Standard Agents types");
     } else {
       logger.info("tsconfig.json already configured");
@@ -1342,21 +1366,21 @@ function cleanupViteDefaults(cwd) {
   ];
   const dirsToRemove = ["src", "public"];
   for (const file of filesToRemove) {
-    const filePath = path.join(cwd, file);
-    if (fs.existsSync(filePath)) {
+    const filePath = path3.join(cwd, file);
+    if (fs3.existsSync(filePath)) {
       try {
-        fs.unlinkSync(filePath);
+        fs3.unlinkSync(filePath);
       } catch {
       }
     }
   }
   for (const dir of dirsToRemove) {
-    const dirPath = path.join(cwd, dir);
-    if (fs.existsSync(dirPath)) {
+    const dirPath = path3.join(cwd, dir);
+    if (fs3.existsSync(dirPath)) {
       try {
-        const files = fs.readdirSync(dirPath);
+        const files = fs3.readdirSync(dirPath);
         if (files.length === 0) {
-          fs.rmdirSync(dirPath);
+          fs3.rmdirSync(dirPath);
         }
       } catch {
       }
@@ -1388,8 +1412,8 @@ async function scaffold(options = {}) {
   logger.log("");
   logger.log("Your project structure:");
   logger.log("");
+  logger.log("  CLAUDE.md               # Architecture documentation");
   logger.log("  agents/");
-  logger.log("  \u251C\u2500\u2500 CLAUDE.md           # Architecture documentation");
   logger.log("  \u251C\u2500\u2500 Thread.ts           # Durable Object for threads");
   logger.log("  \u251C\u2500\u2500 AgentBuilder.ts     # Durable Object for agent state");
   logger.log("  \u251C\u2500\u2500 agents/             # Agent definitions");
@@ -1490,12 +1514,27 @@ function detectPackageManager() {
     if (userAgent.includes("yarn")) return "yarn";
     if (userAgent.includes("bun")) return "bun";
   }
-  if (fs.existsSync("pnpm-lock.yaml")) return "pnpm";
-  if (fs.existsSync("yarn.lock")) return "yarn";
-  if (fs.existsSync("bun.lockb")) return "bun";
-  if (fs.existsSync("package-lock.json")) return "npm";
+  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs3.existsSync("yarn.lock")) return "yarn";
+  if (fs3.existsSync("bun.lockb")) return "bun";
+  if (fs3.existsSync("package-lock.json")) return "npm";
   return "npm";
 }
+function getBuilderPackageVersion() {
+  try {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path3.resolve(__dirname2, "../../package.json");
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const version = pkg2.version;
+    const prereleaseMatch = version.match(/-([a-z]+)\./i);
+    if (prereleaseMatch) {
+      return `@${prereleaseMatch[1]}`;
+    }
+    return `@^${version}`;
+  } catch {
+    return "";
+  }
+}
 async function selectPackageManager(detected) {
   const options = ["npm", "pnpm", "yarn", "bun"];
   const detectedIndex = options.indexOf(detected);
@@ -1577,8 +1616,8 @@ async function init(projectNameArg, options = {}) {
     logger.error("Project name is required");
     process.exit(1);
   }
-  const projectPath = path.join(cwd, projectName);
-  if (fs.existsSync(projectPath)) {
+  const projectPath = path3.join(cwd, projectName);
+  if (fs3.existsSync(projectPath)) {
     logger.error(`Directory "${projectName}" already exists`);
     process.exit(1);
   }
@@ -1610,24 +1649,24 @@ async function init(projectNameArg, options = {}) {
     logger.error("Failed to create Vite project");
     process.exit(1);
   }
-  const viteConfigPath = path.join(projectPath, "vite.config.ts");
-  if (!fs.existsSync(viteConfigPath)) {
+  const viteConfigPath = path3.join(projectPath, "vite.config.ts");
+  if (!fs3.existsSync(viteConfigPath)) {
     const viteConfigContent = `import { defineConfig } from 'vite'
 
 export default defineConfig({
   plugins: [],
 })
 `;
-    fs.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
+    fs3.writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
     logger.success("Created vite.config.ts");
   }
-  const packageJsonPath = path.join(projectPath, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path3.join(projectPath, "package.json");
+  if (fs3.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
     const kebabName = toKebabCase(projectName);
     if (packageJson.name !== kebabName) {
       packageJson.name = kebabName;
-      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      fs3.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
     }
   }
   logger.log("");
@@ -1636,11 +1675,12 @@ export default defineConfig({
   try {
     const installCmd = pm === "npm" ? "install" : "add";
     const devFlag = pm === "npm" ? "--save-dev" : "-D";
+    const builderVersion = getBuilderPackageVersion();
     await runCommand(pm, [
       installCmd,
       devFlag,
       "@cloudflare/vite-plugin",
-      "@standardagents/builder",
+      `@standardagents/builder${builderVersion}`,
       "wrangler",
       "zod"
     ], projectPath);
@@ -1714,14 +1754,14 @@ export default defineConfig({
     devVarsLines.push("# OPENAI_API_KEY=your-openai-key");
   }
   devVarsLines.push("");
-  const devVarsPath = path.join(projectPath, ".dev.vars");
-  fs.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
+  const devVarsPath = path3.join(projectPath, ".dev.vars");
+  fs3.writeFileSync(devVarsPath, devVarsLines.join("\n"), "utf-8");
   logger.success("Created .dev.vars with encryption key");
-  const gitignorePath = path.join(projectPath, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path3.join(projectPath, ".gitignore");
+  if (fs3.existsSync(gitignorePath)) {
+    const gitignoreContent = fs3.readFileSync(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".dev.vars")) {
-      fs.appendFileSync(gitignorePath, "\n# Local environment variables\n.dev.vars\n");
+      fs3.appendFileSync(gitignorePath, "\n# Local environment variables\n.dev.vars\n");
       logger.success("Added .dev.vars to .gitignore");
     }
   }
@@ -1743,6 +1783,535 @@ export default defineConfig({
   logger.log("");
   logger.log("For more information, visit: https://standardagents.ai/docs");
 }
+function getReactPackageVersion() {
+  try {
+    const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+    const pkgPath = path3.resolve(__dirname2, "../package.json");
+    const pkg2 = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const version = pkg2.version;
+    const prereleaseMatch = version.match(/-([a-z]+)\./i);
+    if (prereleaseMatch) {
+      return prereleaseMatch[1];
+    }
+    return `^${version}`;
+  } catch {
+    return "latest";
+  }
+}
+function getChatSourceDir() {
+  const __dirname2 = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(__dirname2, "../chat");
+}
+async function prompt2(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+function runCommand2(command, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: false
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve2();
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function detectPackageManager2() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.includes("pnpm")) return "pnpm";
+    if (userAgent.includes("yarn")) return "yarn";
+    if (userAgent.includes("bun")) return "bun";
+  }
+  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
+  if (fs3.existsSync("yarn.lock")) return "yarn";
+  if (fs3.existsSync("bun.lockb")) return "bun";
+  if (fs3.existsSync("package-lock.json")) return "npm";
+  return "npm";
+}
+async function selectPackageManager2(detected) {
+  const options = ["npm", "pnpm", "yarn", "bun"];
+  const detectedIndex = options.indexOf(detected);
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = detectedIndex;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${options.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select a package manager:\n");
+      options.forEach((opt, i) => {
+        const marker = i === detectedIndex ? " (detected)" : "";
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${opt}${marker}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select a package manager:\n");
+    options.forEach((opt, i) => {
+      const marker = i === detectedIndex ? " (detected)" : "";
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${opt}${marker}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve2(options[selectedIndex]);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function selectFramework() {
+  const options = [
+    { value: "vite", label: "Vite (React + TypeScript)" },
+    { value: "nextjs", label: "Next.js (App Router)" }
+  ];
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let selectedIndex = 0;
+    const renderOptions = () => {
+      stdout.write("\x1B[?25l");
+      stdout.write(`\x1B[${options.length + 1}A`);
+      stdout.write("\x1B[0J");
+      stdout.write("Select a framework:\n");
+      options.forEach((opt, i) => {
+        const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+        stdout.write(`${prefix} ${highlight}${opt.label}\x1B[0m
+`);
+      });
+    };
+    stdout.write("Select a framework:\n");
+    options.forEach((opt, i) => {
+      const prefix = i === selectedIndex ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const highlight = i === selectedIndex ? "\x1B[36m" : "\x1B[90m";
+      stdout.write(`${prefix} ${highlight}${opt.label}\x1B[0m
+`);
+    });
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const cleanup = () => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stdout.write("\x1B[?25h");
+    };
+    const onData = (key) => {
+      if (key === "\x1B[A" || key === "k") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        renderOptions();
+      } else if (key === "\x1B[B" || key === "j") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        renderOptions();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve2(options[selectedIndex].value);
+      } else if (key === "") {
+        cleanup();
+        stdout.write("\n");
+        process.exit(1);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isPortOpen(port) {
+  const tryConnect = (host) => {
+    return new Promise((resolve2) => {
+      const socket = new net.Socket();
+      socket.setTimeout(200);
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve2(true);
+      });
+      socket.on("timeout", () => {
+        socket.destroy();
+        resolve2(false);
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        resolve2(false);
+      });
+      socket.connect(port, host);
+    });
+  };
+  if (await tryConnect("127.0.0.1")) return true;
+  if (await tryConnect("::1")) return true;
+  return false;
+}
+async function isAgentbuilderInstance(url) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e3);
+    const response = await fetch(`${url}/api/agents`, {
+      signal: controller.signal,
+      headers: { "Accept": "application/json" }
+    });
+    clearTimeout(timeout);
+    if (response.status === 401) {
+      return true;
+    }
+    if (response.ok) {
+      const data = await response.json();
+      return Array.isArray(data.agents);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function detectAgentbuilderInstance() {
+  const portsToScan = [
+    5173,
+    5174,
+    5175,
+    5176,
+    5177,
+    5178,
+    5179,
+    5180,
+    3e3,
+    3001,
+    3002,
+    3003,
+    8080,
+    8e3,
+    4e3
+  ];
+  logger.log("\x1B[90mScanning for running agentbuilder instance...\x1B[0m");
+  const openPorts = [];
+  await Promise.all(
+    portsToScan.map(async (port) => {
+      if (await isPortOpen(port)) {
+        openPorts.push(port);
+      }
+    })
+  );
+  for (const port of openPorts.sort((a, b) => a - b)) {
+    const url = `http://localhost:${port}`;
+    if (await isAgentbuilderInstance(url)) {
+      return url;
+    }
+  }
+  return null;
+}
+function copyDir(src, dest, skip = []) {
+  if (!fs3.existsSync(dest)) {
+    fs3.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skip.includes(entry.name)) continue;
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, skip);
+    } else {
+      fs3.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+async function initChat(projectNameArg, options = {}) {
+  const cwd = process.cwd();
+  const chatSourceDir = getChatSourceDir();
+  if (!fs3.existsSync(chatSourceDir)) {
+    logger.error("Chat source files not found. This CLI installation may be corrupted.");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.info("Scaffolding a frontend chat application...");
+  logger.log("");
+  let projectName = projectNameArg;
+  if (!projectName && !options.yes) {
+    projectName = await prompt2("Project name: ");
+  }
+  if (!projectName) {
+    logger.error("Project name is required");
+    process.exit(1);
+  }
+  const projectPath = path3.join(cwd, projectName);
+  if (fs3.existsSync(projectPath)) {
+    logger.error(`Directory "${projectName}" already exists`);
+    process.exit(1);
+  }
+  let framework;
+  if (options.framework) {
+    framework = options.framework;
+  } else if (options.yes) {
+    framework = "vite";
+  } else {
+    framework = await selectFramework();
+    logger.log("");
+  }
+  let serverUrl;
+  if (options.yes) {
+    serverUrl = "http://localhost:5173";
+  } else {
+    const detectedUrl = await detectAgentbuilderInstance();
+    if (detectedUrl) {
+      logger.success(`Found agentbuilder at ${detectedUrl}`);
+      const urlInput = await prompt2(`Agentbuilder dev server URL [${detectedUrl}]: `);
+      serverUrl = urlInput || detectedUrl;
+    } else {
+      logger.log("\x1B[90mNo running agentbuilder instance found\x1B[0m");
+      const urlInput = await prompt2("Agentbuilder dev server URL [http://localhost:5173]: ");
+      serverUrl = urlInput || "http://localhost:5173";
+    }
+    if (!isValidUrl(serverUrl)) {
+      logger.error("Invalid URL format");
+      process.exit(1);
+    }
+  }
+  const detectedPm = detectPackageManager2();
+  let pm;
+  if (options.yes) {
+    pm = detectedPm;
+  } else {
+    pm = await selectPackageManager2(detectedPm);
+    logger.log("");
+  }
+  logger.log("");
+  logger.info(`Creating ${framework === "vite" ? "Vite" : "Next.js"} project...`);
+  logger.log("");
+  fs3.mkdirSync(projectPath, { recursive: true });
+  const reactVersion = getReactPackageVersion();
+  if (framework === "vite") {
+    await scaffoldVite(projectPath, chatSourceDir, projectName, serverUrl, reactVersion);
+  } else {
+    await scaffoldNextjs(projectPath, chatSourceDir, projectName, serverUrl, reactVersion);
+  }
+  logger.log("");
+  logger.info("Installing dependencies...");
+  logger.log("");
+  try {
+    await runCommand2(pm, pm === "npm" ? ["install"] : ["install"], projectPath);
+  } catch (error) {
+    logger.error("Failed to install dependencies");
+    process.exit(1);
+  }
+  logger.log("");
+  logger.success("Chat UI scaffolded successfully!");
+  logger.log("");
+  logger.info("Starting development server...");
+  logger.log("");
+  const devArgs = pm === "npm" ? ["run", "dev"] : ["dev"];
+  const devProcess = spawn(pm, devArgs, {
+    cwd: projectPath,
+    stdio: ["inherit", "pipe", "pipe"],
+    shell: false
+  });
+  let browserOpened = false;
+  const openBrowser = (url) => {
+    if (browserOpened) return;
+    browserOpened = true;
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    spawn(openCmd, [url], { stdio: "ignore", detached: true }).unref();
+  };
+  devProcess.stdout?.on("data", (data) => {
+    const text = data.toString();
+    process.stdout.write(data);
+    const urlMatch = text.match(/Local:\s+(https?:\/\/localhost:\d+\/?)/);
+    if (urlMatch && !browserOpened) {
+      openBrowser(urlMatch[1]);
+    }
+  });
+  devProcess.stderr?.on("data", (data) => {
+    process.stderr.write(data);
+  });
+  devProcess.on("error", (error) => {
+    logger.error(`Failed to start dev server: ${error.message}`);
+    process.exit(1);
+  });
+}
+async function scaffoldVite(projectPath, chatSourceDir, projectName, serverUrl, reactVersion) {
+  copyDir(path3.join(chatSourceDir, "src"), path3.join(projectPath, "src"), []);
+  logger.success("Copied src/");
+  const viteDir = path3.join(chatSourceDir, "vite");
+  let indexHtml = fs3.readFileSync(path3.join(viteDir, "index.html"), "utf-8");
+  indexHtml = indexHtml.replace('src="/main.tsx"', 'src="/src/main.tsx"');
+  fs3.writeFileSync(path3.join(projectPath, "index.html"), indexHtml, "utf-8");
+  logger.success("Created index.html");
+  fs3.copyFileSync(path3.join(viteDir, "main.tsx"), path3.join(projectPath, "src", "main.tsx"));
+  logger.success("Created src/main.tsx");
+  let viteConfig = fs3.readFileSync(path3.join(viteDir, "vite.config.ts"), "utf-8");
+  viteConfig = `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+  ],
+})
+`;
+  fs3.writeFileSync(path3.join(projectPath, "vite.config.ts"), viteConfig, "utf-8");
+  logger.success("Created vite.config.ts");
+  fs3.copyFileSync(path3.join(chatSourceDir, "tsconfig.json"), path3.join(projectPath, "tsconfig.json"));
+  const tsconfig = JSON.parse(fs3.readFileSync(path3.join(projectPath, "tsconfig.json"), "utf-8"));
+  tsconfig.include = ["src"];
+  delete tsconfig.compilerOptions?.paths;
+  fs3.writeFileSync(path3.join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+  logger.success("Created tsconfig.json");
+  fs3.copyFileSync(path3.join(chatSourceDir, "package.json"), path3.join(projectPath, "package.json"));
+  const pkg2 = JSON.parse(fs3.readFileSync(path3.join(projectPath, "package.json"), "utf-8"));
+  pkg2.name = projectName;
+  pkg2.scripts = {
+    dev: "vite",
+    build: "vite build",
+    preview: "vite preview"
+  };
+  delete pkg2.private;
+  if (pkg2.dependencies?.["@standardagents/react"]) {
+    pkg2.dependencies["@standardagents/react"] = reactVersion;
+  }
+  delete pkg2.dependencies?.["next"];
+  delete pkg2.devDependencies?.["@tailwindcss/postcss"];
+  delete pkg2.devDependencies?.["postcss"];
+  fs3.writeFileSync(path3.join(projectPath, "package.json"), JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  logger.success("Created package.json");
+  const envContent = `# Agentbuilder connection
+VITE_AGENTBUILDER_URL=${serverUrl}
+`;
+  fs3.writeFileSync(path3.join(projectPath, ".env"), envContent, "utf-8");
+  logger.success("Created .env");
+  fs3.writeFileSync(path3.join(projectPath, ".gitignore"), `node_modules
+dist
+.env
+`, "utf-8");
+  logger.success("Created .gitignore");
+  let mainTsx = fs3.readFileSync(path3.join(projectPath, "src", "main.tsx"), "utf-8");
+  mainTsx = mainTsx.replace(/from '\.\.\/src\//g, "from './").replace(/import '\.\.\/src\//g, "import './");
+  fs3.writeFileSync(path3.join(projectPath, "src", "main.tsx"), mainTsx, "utf-8");
+  if (fs3.existsSync(path3.join(viteDir, "favicon.svg"))) {
+    fs3.copyFileSync(path3.join(viteDir, "favicon.svg"), path3.join(projectPath, "favicon.svg"));
+    logger.success("Created favicon.svg");
+  }
+}
+async function scaffoldNextjs(projectPath, chatSourceDir, projectName, serverUrl, reactVersion) {
+  copyDir(path3.join(chatSourceDir, "src"), path3.join(projectPath, "src"), []);
+  logger.success("Copied src/");
+  const nextDir = path3.join(chatSourceDir, "next");
+  copyDir(path3.join(nextDir, "app"), path3.join(projectPath, "app"), []);
+  logger.success("Copied app/");
+  fs3.copyFileSync(path3.join(nextDir, "next.config.ts"), path3.join(projectPath, "next.config.ts"));
+  logger.success("Created next.config.ts");
+  fs3.copyFileSync(path3.join(nextDir, "postcss.config.mjs"), path3.join(projectPath, "postcss.config.mjs"));
+  logger.success("Created postcss.config.mjs");
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2017",
+      lib: ["dom", "dom.iterable", "esnext"],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: "esnext",
+      moduleResolution: "bundler",
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: "preserve",
+      incremental: true,
+      plugins: [{ name: "next" }],
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"]
+  };
+  fs3.writeFileSync(path3.join(projectPath, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n", "utf-8");
+  logger.success("Created tsconfig.json");
+  const pkg2 = JSON.parse(fs3.readFileSync(path3.join(chatSourceDir, "package.json"), "utf-8"));
+  pkg2.name = projectName;
+  pkg2.scripts = {
+    dev: "next dev",
+    build: "next build",
+    start: "next start"
+  };
+  delete pkg2.private;
+  if (pkg2.dependencies?.["@standardagents/react"]) {
+    pkg2.dependencies["@standardagents/react"] = reactVersion;
+  }
+  delete pkg2.devDependencies?.["@tailwindcss/vite"];
+  delete pkg2.devDependencies?.["@vitejs/plugin-react"];
+  delete pkg2.devDependencies?.["vite"];
+  fs3.writeFileSync(path3.join(projectPath, "package.json"), JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  logger.success("Created package.json");
+  const envContent = `# Agentbuilder connection
+NEXT_PUBLIC_AGENTBUILDER_URL=${serverUrl}
+`;
+  fs3.writeFileSync(path3.join(projectPath, ".env.local"), envContent, "utf-8");
+  logger.success("Created .env.local");
+  fs3.writeFileSync(path3.join(projectPath, ".gitignore"), `node_modules
+.next
+out
+.env.local
+`, "utf-8");
+  logger.success("Created .gitignore");
+  let layoutTsx = fs3.readFileSync(path3.join(projectPath, "app", "layout.tsx"), "utf-8");
+  layoutTsx = layoutTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
+  fs3.writeFileSync(path3.join(projectPath, "app", "layout.tsx"), layoutTsx, "utf-8");
+  let pageTsx = fs3.readFileSync(path3.join(projectPath, "app", "page.tsx"), "utf-8");
+  pageTsx = pageTsx.replace(/from '\.\.\/\.\.\/src\//g, "from '../src/");
+  fs3.writeFileSync(path3.join(projectPath, "app", "page.tsx"), pageTsx, "utf-8");
+}
 
 // src/index.ts
 var __dirname$1 = dirname(fileURLToPath(import.meta.url));
@@ -1751,6 +2320,7 @@ var program = new Command();
 program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version(pkg.version);
 program.command("init [project-name]").description("Create a new Standard Agents project (runs create vite, then scaffold)").option("-y, --yes", "Skip prompts and use defaults").option("--template <template>", "Vite template to use", "vanilla-ts").action(init);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
+program.command("init-chat [project-name]").description("Scaffold a frontend chat application").option("-y, --yes", "Skip prompts and use defaults").option("--framework <framework>", "Framework to use (vite or nextjs)").action(initChat);
 program.parse();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map