@openbuilder/cli 0.50.27 → 0.50.28

package/dist/index.js

@@ -10,9 +10,10 @@ import 'zod/v4';
 import 'zod/v3';
 import { parse } from 'jsonc-parser';
 import { z } from 'zod';
-import { existsSync } from 'fs';
+import { existsSync, mkdirSync as mkdirSync$1 } from 'fs';
 import { existsSync as existsSync$1, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { readFile } from 'fs/promises';
+import * as path from 'path';
 import { join } from 'path';
 import WebSocket$1, { WebSocketServer, WebSocket } from 'ws';
 import { drizzle } from 'drizzle-orm/node-postgres';
@@ -30,6 +31,7 @@ import { EventEmitter } from 'node:events';
 import { createServer, createConnection } from 'node:net';
 import { readFile as readFile$1, rm, writeFile, readdir } from 'node:fs/promises';
 import { simpleGit } from 'simple-git';
+import * as os from 'os';
 import { tunnelManager } from './chunks/manager-CvGX9qqe.js';
 import 'chalk';
 import 'node:util';
@@ -2139,7 +2141,7 @@ var init_design$1 = __esm$1({
 
 // src/config/tags.ts
 function findTagDefinition$1(key) {
-  for (const def of TAG_DEFINITIONS$1) {
+  for (const def of TAG_DEFINITIONS$2) {
     if (def.key === key) return def;
     if (def.children) {
       const child = def.children.find((c) => c.key === key);
@@ -2148,10 +2150,10 @@ function findTagDefinition$1(key) {
   }
   return void 0;
 }
-var TAG_DEFINITIONS$1;
+var TAG_DEFINITIONS$2;
 var init_tags$1 = __esm$1({
   "src/config/tags.ts"() {
-    TAG_DEFINITIONS$1 = [
+    TAG_DEFINITIONS$2 = [
       // Model Selection (explicit provider + model mapping)
       {
         key: "model",
@@ -3914,6 +3916,7 @@ Create as many tasks as needed for the request (3-15+ tasks based on complexity)
 
 // src/shared/runner/messages.ts
 var COMMAND_TYPES = [
+  "analyze-project",
   "start-build",
   "cancel-build",
   "start-dev-server",
@@ -6382,9 +6385,62 @@ async function runMigrations(migrationsFolder = "./drizzle") {
     await pool.end();
   }
 }
+var ProjectMetadataSchema = z.object({
+  slug: z.string().describe("URL-friendly project identifier (lowercase, hyphens)"),
+  friendlyName: z.string().describe("Human-readable project name"),
+  description: z.string().describe("Brief description of what the project does"),
+  icon: z.enum([
+    "Folder",
+    "Code",
+    "Layout",
+    "Database",
+    "Zap",
+    "Globe",
+    "Lock",
+    "Users",
+    "ShoppingCart",
+    "Calendar",
+    "MessageSquare",
+    "FileText",
+    "Image",
+    "Music",
+    "Video",
+    "CheckCircle",
+    "Star"
+  ]).describe("Icon name from available Lucide icons")
+});
+var TemplateAnalysisSchema = z.object({
+  templateId: z.string().describe("ID of the selected template"),
+  reasoning: z.string().describe("Brief explanation of why this template was chosen"),
+  confidence: z.number().min(0).max(1).describe("Confidence score from 0.0 to 1.0")
+});
+var ProjectNamingSchema = z.object({
+  slug: z.string().describe("URL-friendly project identifier (lowercase, hyphens, 2-4 words)"),
+  friendlyName: z.string().describe("Human-readable project name (Title Case, 2-5 words)")
+});
+var AVAILABLE_ICONS = [
+  "Folder",
+  "Code",
+  "Layout",
+  "Database",
+  "Zap",
+  "Globe",
+  "Lock",
+  "Users",
+  "ShoppingCart",
+  "Calendar",
+  "MessageSquare",
+  "FileText",
+  "Image",
+  "Music",
+  "Video",
+  "CheckCircle",
+  "Star"
+];
 
 var AgentCore = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  AVAILABLE_ICONS: AVAILABLE_ICONS,
   CLAUDE_SYSTEM_PROMPT: CLAUDE_SYSTEM_PROMPT,
   CODEX_SYSTEM_PROMPT: CODEX_SYSTEM_PROMPT,
   DEFAULT_AGENT_ID: DEFAULT_AGENT_ID,
@@ -6394,6 +6450,9 @@ var AgentCore = /*#__PURE__*/Object.freeze({
   LEGACY_MODEL_MAP: LEGACY_MODEL_MAP,
   MODEL_METADATA: MODEL_METADATA,
   NEONDB_CHAT_MESSAGES: NEONDB_CHAT_MESSAGES,
+  ProjectMetadataSchema: ProjectMetadataSchema,
+  ProjectNamingSchema: ProjectNamingSchema,
+  TemplateAnalysisSchema: TemplateAnalysisSchema,
   buildLogger: buildLogger$2,
   buildWebSocketServer: buildWebSocketServer,
   db: db,
@@ -7600,7 +7659,7 @@ var init_design = __esm({
 
 // src/config/tags.ts
 function findTagDefinition(key) {
-  for (const def of TAG_DEFINITIONS) {
+  for (const def of TAG_DEFINITIONS$1) {
     if (def.key === key) return def;
     if (def.children) {
       const child = def.children.find((c) => c.key === key);
@@ -7609,10 +7668,10 @@ function findTagDefinition(key) {
   }
   return void 0;
 }
-var TAG_DEFINITIONS;
+var TAG_DEFINITIONS$1;
 var init_tags = __esm({
   "src/config/tags.ts"() {
-    TAG_DEFINITIONS = [
+    TAG_DEFINITIONS$1 = [
       // Model Selection (explicit provider + model mapping)
       {
         key: "model",
@@ -11543,6 +11602,644 @@ async function orchestrateBuild(context) {
     };
 }
 
+// src/config/tags.ts
+var TAG_DEFINITIONS = [
+  // Model Selection (explicit provider + model mapping)
+  {
+    key: "model",
+    label: "Model",
+    description: "AI agent and model to use for generation",
+    category: "model",
+    inputType: "select",
+    options: [
+      {
+        value: "claude-sonnet-4-5",
+        label: "Claude Sonnet 4.5",
+        description: "Anthropic Claude - Balanced performance and speed",
+        logo: "/claude.png",
+        provider: "claude-code",
+        model: "claude-sonnet-4-5"
+      },
+      {
+        value: "claude-opus-4-5",
+        label: "Claude Opus 4.5",
+        description: "Anthropic Claude - Most capable for complex tasks",
+        logo: "/claude.png",
+        provider: "claude-code",
+        model: "claude-opus-4-5"
+      },
+      {
+        value: "claude-haiku-4-5",
+        label: "Claude Haiku 4.5",
+        description: "Anthropic Claude - Fastest, good for iterations",
+        logo: "/claude.png",
+        provider: "claude-code",
+        model: "claude-haiku-4-5"
+      },
+      {
+        value: "gpt-5.2-codex",
+        label: "GPT-5.2 Codex",
+        description: "OpenAI Codex - Advanced code generation",
+        logo: "/openai.png",
+        provider: "openai-codex",
+        model: "openai/gpt-5.2-codex"
+      }
+    ]
+  },
+  // Framework Selection
+  {
+    key: "framework",
+    label: "Framework",
+    description: "Frontend framework to use",
+    category: "framework",
+    inputType: "select",
+    options: [
+      {
+        value: "next",
+        label: "Next.js",
+        description: "Full-stack React with SSR, App Router, and file-based routing",
+        logo: "/logos/nextjs.svg",
+        repository: "github:codyde/template-nextjs",
+        branch: "main"
+      },
+      {
+        value: "tanstack",
+        label: "TanStack Start",
+        description: "Minimal TanStack Start foundation with React 19, Router, Query, and Tailwind",
+        logo: "/logos/tanstack.png",
+        repository: "github:codyde/template-tanstackstart",
+        branch: "main"
+      },
+      {
+        value: "vite",
+        label: "React + Vite",
+        description: "Fast React SPA with Vite - perfect for client-side apps",
+        logo: "/logos/react.svg",
+        repository: "github:codyde/template-reactvite",
+        branch: "main"
+      },
+      {
+        value: "astro",
+        label: "Astro",
+        description: "Content-focused static sites with islands architecture",
+        logo: "/astro.png",
+        repository: "github:codyde/template-astro",
+        branch: "main"
+      }
+    ],
+    promptTemplate: "CRITICAL: You MUST use the {label} template. Clone it using: npx degit {repository}#{branch} {{projectName}}"
+  },
+  // Runner Selection (options populated dynamically)
+  {
+    key: "runner",
+    label: "Runner",
+    description: "Build runner to execute the build",
+    category: "runner",
+    inputType: "select",
+    options: []
+    // Populated dynamically from connected runners
+  },
+  // Design Configuration (nested)
+  {
+    key: "design",
+    label: "Design",
+    description: "Visual design preferences",
+    category: "design",
+    inputType: "nested",
+    children: [
+      // Brand Themes
+      {
+        key: "brand",
+        label: "Brand",
+        description: "Pre-configured brand color themes",
+        category: "design",
+        inputType: "select",
+        maxSelections: 1,
+        options: [
+          {
+            value: "sentry",
+            label: "Sentry",
+            description: "Error monitoring and performance - vibrant purple and pink",
+            logo: "/logos/sentry.svg",
+            values: {
+              primaryColor: "#9D58BF",
+              secondaryColor: "#FF708C",
+              accentColor: "#FF9838",
+              neutralLight: "#F0ECF3",
+              neutralDark: "#2B2233"
+            }
+          },
+          {
+            value: "stripe",
+            label: "Stripe",
+            description: "Modern payments aesthetic",
+            logo: "/logos/stripe.svg",
+            values: {
+              primaryColor: "#635bff",
+              secondaryColor: "#0a2540",
+              accentColor: "#00d4ff",
+              neutralLight: "#f6f9fc",
+              neutralDark: "#0a2540"
+            }
+          },
+          {
+            value: "vercel",
+            label: "Vercel",
+            description: "Clean developer tools",
+            logo: "/logos/vercel.svg",
+            values: {
+              primaryColor: "#000000",
+              secondaryColor: "#ffffff",
+              accentColor: "#0070f3",
+              neutralLight: "#fafafa",
+              neutralDark: "#000000"
+            }
+          },
+          {
+            value: "linear",
+            label: "Linear",
+            description: "Sleek project management",
+            logo: "/logos/linear.svg",
+            values: {
+              primaryColor: "#5e6ad2",
+              secondaryColor: "#26b5ce",
+              accentColor: "#f2994a",
+              neutralLight: "#f7f8f8",
+              neutralDark: "#1a1a1a"
+            }
+          },
+          {
+            value: "notion",
+            label: "Notion",
+            description: "Warm productivity",
+            logo: "/logos/notion.svg",
+            values: {
+              primaryColor: "#2383e2",
+              secondaryColor: "#e69138",
+              accentColor: "#d44c47",
+              neutralLight: "#f7f6f3",
+              neutralDark: "#37352f"
+            }
+          },
+          {
+            value: "github",
+            label: "GitHub",
+            description: "Developer-first",
+            logo: "/logos/github.svg",
+            values: {
+              primaryColor: "#238636",
+              secondaryColor: "#1f6feb",
+              accentColor: "#f85149",
+              neutralLight: "#f6f8fa",
+              neutralDark: "#24292f"
+            }
+          },
+          {
+            value: "airbnb",
+            label: "Airbnb",
+            description: "Friendly travel",
+            logo: "/logos/airbnb.svg",
+            values: {
+              primaryColor: "#ff385c",
+              secondaryColor: "#00a699",
+              accentColor: "#fc642d",
+              neutralLight: "#f7f7f7",
+              neutralDark: "#222222"
+            }
+          },
+          {
+            value: "spotify",
+            label: "Spotify",
+            description: "Bold music streaming",
+            logo: "/logos/spotify.svg",
+            values: {
+              primaryColor: "#1db954",
+              secondaryColor: "#191414",
+              accentColor: "#1ed760",
+              neutralLight: "#f6f6f6",
+              neutralDark: "#000000"
+            }
+          }
+        ],
+        promptTemplate: "Use the {value} brand aesthetic with the following color palette: Primary: {primaryColor}, Secondary: {secondaryColor}, Accent: {accentColor}, Neutral Light: {neutralLight}, Neutral Dark: {neutralDark}. Match the design style and feel of {value}."
+      }
+    ]
+  }
+];
+
+/**
+ * Project Analyzer Module
+ *
+ * Handles AI-based project analysis before builds:
+ * - Template selection (or uses framework tag fast-path)
+ * - Project name/slug generation
+ * - Project metadata generation (icon, description)
+ *
+ * This consolidates AI calls that were previously split between frontend and runner,
+ * ensuring the runner is the single source of truth for all project decisions.
+ */
+// Map model IDs to Claude Agent SDK model names
+const MODEL_MAP = {
+    'claude-haiku-4-5': 'claude-sonnet-4-5', // Haiku 4.5 not yet available, use Sonnet
+    'claude-sonnet-4-5': 'claude-sonnet-4-5',
+    'claude-opus-4-5': 'claude-opus-4-5',
+};
+function resolveModelName(modelId) {
+    return MODEL_MAP[modelId] || 'claude-sonnet-4-5';
+}
+/**
+ * Get a clean env object with only string values
+ */
+function getCleanEnv() {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    if (!env.PATH) {
+        env.PATH = '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin';
+    }
+    return env;
+}
+/**
+ * Ensure a directory exists
+ */
+function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync$1(dir, { recursive: true });
+    }
+}
+/**
+ * Generate structured output using Claude Agent SDK
+ */
+async function generateStructuredOutput(options) {
+    const modelName = resolveModelName(options.model);
+    const jsonSchema = z.toJSONSchema(options.schema);
+    const jsonInstructions = `You must respond with ONLY valid JSON that matches this schema. Do not include any text before or after the JSON object. Do not wrap in markdown code blocks.
+
+JSON Schema:
+${JSON.stringify(jsonSchema, null, 2)}
+
+CRITICAL: Your response must START with { and END with }. Output only the JSON object.`;
+    const fullPrompt = options.system
+        ? `${options.system}\n\n${jsonInstructions}\n\nUser request: ${options.prompt}`
+        : `${jsonInstructions}\n\nUser request: ${options.prompt}`;
+    const tempDir = path.join(os.tmpdir(), 'runner-ai');
+    ensureDir(tempDir);
+    const sdkOptions = {
+        model: modelName,
+        maxTurns: 1,
+        tools: [],
+        cwd: tempDir,
+        permissionMode: 'bypassPermissions',
+        allowDangerouslySkipPermissions: true,
+        env: getCleanEnv(),
+    };
+    let responseText = '';
+    try {
+        for await (const message of query({ prompt: fullPrompt, options: sdkOptions })) {
+            if (message.type === 'assistant') {
+                for (const block of message.message.content) {
+                    if (block.type === 'text') {
+                        responseText += block.text;
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error('[project-analyzer] SDK query failed:', error);
+        captureException(error);
+        throw error;
+    }
+    if (!responseText) {
+        throw new Error('No text response from Claude Agent SDK');
+    }
+    // Clean up any markdown code blocks if present
+    let jsonText = responseText.trim();
+    const codeBlockMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+    if (codeBlockMatch) {
+        jsonText = codeBlockMatch[1].trim();
+    }
+    const jsonMatch = jsonText.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+        jsonText = jsonMatch[0];
+    }
+    const parsed = JSON.parse(jsonText);
+    const validated = options.schema.parse(parsed);
+    return { object: validated };
+}
+/**
+ * Generate project name/slug from user prompt
+ */
+async function generateProjectName(prompt, model) {
+    const namePrompt = `Extract the core project concept from this request and create appropriate names:
+
+User's project request: "${prompt}"
+
+IMPORTANT: Extract only the PROJECT TYPE/CONCEPT. Ignore all conversational phrases:
+- Ignore: "I want", "I need", "I would like", "please", "can you", "build me", "create me", "make me"
+- Ignore: "a", "an", "the", "using", "with", "for me"
+- Focus ONLY on WHAT is being built, not how the user asked for it
+
+Generate:
+1. A URL-friendly slug (lowercase, hyphens, 2-4 words, max 30 chars)
+2. A human-readable friendly name (Title Case, 2-5 words)
+
+Examples:
+- "I want to build a todo app" → slug: "todo-app", friendlyName: "Todo App"
+- "I want a workflow automation tool" → slug: "workflow-automation", friendlyName: "Workflow Automation"
+- "Can you create an error monitoring dashboard for me" → slug: "error-monitoring", friendlyName: "Error Monitoring Dashboard"
+- "I need a chat app with real-time messaging please" → slug: "realtime-chat", friendlyName: "Realtime Chat"
+
+Requirements:
+- Slug: lowercase, hyphens only, no special characters, max 30 chars
+- Friendly name: Title Case, readable, professional, 2-5 words
+- NEVER include words like "want", "need", "please", "build", "create", "make" in the output
+- Focus on the core product/application concept`;
+    try {
+        console.log('[project-analyzer] Generating project name...');
+        const result = await generateStructuredOutput({
+            model,
+            schema: ProjectNamingSchema,
+            prompt: namePrompt,
+        });
+        const { slug, friendlyName } = result.object;
+        // Validate slug format
+        if (slug.length < 2 || slug.length > 100 || !/^[a-z0-9-]+$/.test(slug)) {
+            throw new Error('Generated slug is invalid format');
+        }
+        console.log(`[project-analyzer] Generated name: ${friendlyName} (${slug})`);
+        return { slug, friendlyName };
+    }
+    catch (error) {
+        console.error('[project-analyzer] Name generation failed, using fallback:', error);
+        // Fallback: extract words from prompt
+        const words = prompt
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, '')
+            .split(/\s+/)
+            .filter(w => w.length > 2)
+            .filter(w => !['the', 'and', 'for', 'with', 'build', 'create', 'make', 'want', 'need', 'please', 'can', 'you', 'help', 'using'].includes(w))
+            .slice(0, 4);
+        const slug = words.length > 0 ? words.join('-') : 'new-project';
+        const friendlyName = words.length > 0
+            ? words.map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')
+            : 'New Project';
+        return { slug, friendlyName };
+    }
+}
+/**
+ * Generate project metadata (icon, description)
+ */
+async function generateProjectMetadata(prompt, model) {
+    const metadataPrompt = `Based on this project request, generate appropriate metadata:
+
+User's request: "${prompt}"
+
+Available icons: Folder, Code, Layout, Database, Zap, Globe, Lock, Users, ShoppingCart, Calendar, MessageSquare, FileText, Image, Music, Video, CheckCircle, Star
+
+Generate:
+- icon: Most appropriate icon from the list above
+- description: 1-2 sentences describing what the project does
+
+IMPORTANT: Focus on the actual functionality being requested.`;
+    try {
+        console.log('[project-analyzer] Generating project metadata...');
+        const result = await generateStructuredOutput({
+            model,
+            schema: ProjectMetadataSchema.pick({ icon: true, description: true }).extend({
+                slug: z.string().optional(),
+                friendlyName: z.string().optional(),
+            }),
+            prompt: metadataPrompt,
+        });
+        console.log(`[project-analyzer] Generated icon: ${result.object.icon}`);
+        return {
+            icon: result.object.icon,
+            description: result.object.description
+        };
+    }
+    catch (error) {
+        console.error('[project-analyzer] Metadata generation failed, using defaults:', error);
+        return {
+            icon: 'Code',
+            description: prompt.substring(0, 150),
+        };
+    }
+}
+/**
+ * Select template based on prompt (AI analysis)
+ */
+async function selectTemplateWithAI(prompt, templates, model) {
+    const templateContext = templates.map(t => `
+## ${t.name} (ID: ${t.id})
+${t.description}
+Keywords: ${t.selection.keywords.join(', ')}
+Use cases: ${t.selection.useCases.join('; ')}
+Tech: ${t.tech.framework} ${t.tech.version}, ${t.tech.language}
+`).join('\n---\n');
+    const selectionPrompt = `Select the best template for this project:
+
+User's request: "${prompt}"
+
+Available templates:
+${templateContext}
+
+Selection guidelines:
+- react-vite: Simple SPAs, prototypes, basic UIs
+- nextjs-fullstack: Full-stack apps needing auth, database, API routes, SSR
+- astro-static: Blogs, documentation, landing pages
+
+Return the template ID, your reasoning, and confidence score.
+VALID templateId values: ${templates.map(t => t.id).join(', ')}`;
+    try {
+        console.log('[project-analyzer] Analyzing prompt for template selection...');
+        const result = await generateStructuredOutput({
+            model,
+            schema: TemplateAnalysisSchema,
+            prompt: selectionPrompt,
+        });
+        const template = templates.find(t => t.id === result.object.templateId);
+        if (!template) {
+            throw new Error(`Template ${result.object.templateId} not found`);
+        }
+        console.log(`[project-analyzer] Selected template: ${template.name} (confidence: ${result.object.confidence})`);
+        console.log(`[project-analyzer] Reasoning: ${result.object.reasoning}`);
+        return {
+            template,
+            reasoning: result.object.reasoning,
+            confidence: result.object.confidence,
+        };
+    }
+    catch (error) {
+        console.error('[project-analyzer] Template selection failed, using fallback:', error);
+        // Fallback to keyword-based selection
+        const promptLower = prompt.toLowerCase();
+        let template = templates.find(t => t.id === 'react-vite'); // Default
+        if (promptLower.includes('next') || promptLower.includes('full-stack') || promptLower.includes('database') || promptLower.includes('auth')) {
+            template = templates.find(t => t.id === 'nextjs-fullstack') || template;
+        }
+        else if (promptLower.includes('blog') || promptLower.includes('landing') || promptLower.includes('static') || promptLower.includes('docs')) {
+            template = templates.find(t => t.id === 'astro-static') || template;
+        }
+        return {
+            template: template,
+            reasoning: 'Fallback keyword-based selection',
+            confidence: 0.5,
+        };
+    }
+}
+/**
+ * Get template from framework tag (fast path - no AI)
+ */
+function getTemplateFromTag(templates, tags) {
+    const frameworkTag = tags.find(t => t.key === 'framework');
+    if (!frameworkTag)
+        return null;
+    // Find template matching the framework tag
+    const matchingTemplate = templates.find(t => t.tech.framework.toLowerCase() === frameworkTag.value.toLowerCase());
+    if (matchingTemplate) {
+        console.log(`[project-analyzer] Using template from framework tag: ${matchingTemplate.name}`);
+        return matchingTemplate;
+    }
+    // Try to get template info from TAG_DEFINITIONS
+    const frameworkDef = TAG_DEFINITIONS.find(d => d.key === 'framework');
+    const frameworkOption = frameworkDef?.options?.find(o => o.value === frameworkTag.value);
+    if (frameworkOption?.repository) {
+        console.log(`[project-analyzer] Framework tag found but no matching template, using tag metadata`);
+        // Return null - caller should use tag metadata directly
+        return null;
+    }
+    return null;
+}
+/**
+ * Main analysis function - orchestrates all AI calls
+ *
+ * Sends events via callback as analysis progresses:
+ * - analysis-started
+ * - project-metadata (with results)
+ * - analysis-complete
+ */
+async function analyzeProject(options, sendEvent, commandId) {
+    const { prompt, agent, claudeModel, tags } = options;
+    const model = claudeModel || 'claude-sonnet-4-5';
+    console.log('[project-analyzer] Starting project analysis...');
+    console.log(`[project-analyzer] Agent: ${agent}, Model: ${model}`);
+    // Emit analysis started
+    sendEvent({
+        type: 'analysis-started',
+        commandId,
+        timestamp: new Date().toISOString(),
+    });
+    // Load templates
+    const templates = await getAllTemplates();
+    console.log(`[project-analyzer] Loaded ${templates.length} templates`);
+    // Step 1: Template Selection
+    let selectedTemplate = null;
+    // Fast path: Check if framework tag is present
+    if (tags && tags.length > 0) {
+        const tagTemplate = getTemplateFromTag(templates, tags);
+        if (tagTemplate) {
+            selectedTemplate = tagTemplate;
+            console.log('[project-analyzer] FAST PATH: Using template from framework tag');
+        }
+        else {
+            // Check if we have tag metadata without matching template
+            const frameworkTag = tags.find(t => t.key === 'framework');
+            if (frameworkTag) {
+                const frameworkDef = TAG_DEFINITIONS.find(d => d.key === 'framework');
+                const frameworkOption = frameworkDef?.options?.find(o => o.value === frameworkTag.value);
+                if (frameworkOption?.repository) {
+                    // Build synthetic template from tag
+                    selectedTemplate = {
+                        id: `${frameworkTag.value}-default`,
+                        name: frameworkOption.label,
+                        description: `Template for ${frameworkOption.label}`,
+                        repository: frameworkOption.repository,
+                        branch: frameworkOption.branch || 'main',
+                        selection: { keywords: [], useCases: [], examples: [] },
+                        tech: {
+                            framework: frameworkTag.value,
+                            version: 'latest',
+                            language: 'TypeScript',
+                            styling: 'Tailwind CSS',
+                            packageManager: 'pnpm',
+                            nodeVersion: '20',
+                        },
+                        setup: {
+                            defaultPort: 3000,
+                            installCommand: 'pnpm install',
+                            devCommand: 'pnpm dev',
+                            buildCommand: 'pnpm build',
+                        },
+                        ai: { systemPromptAddition: '', includedFeatures: [] },
+                    };
+                    console.log('[project-analyzer] FAST PATH: Built template from tag metadata');
+                }
+            }
+        }
+    }
+    // Slow path: AI template selection (if not already selected via tag)
+    if (!selectedTemplate) {
+        console.log('[project-analyzer] Running AI template selection...');
+        const selection = await selectTemplateWithAI(prompt, templates, model);
+        selectedTemplate = selection.template;
+    }
+    // At this point selectedTemplate is guaranteed to be assigned
+    const finalTemplate = selectedTemplate;
+    // Step 2: Generate project name (parallel-capable but keeping sequential for simplicity)
+    const { slug, friendlyName } = await generateProjectName(prompt, model);
+    // Step 3: Generate metadata (icon, description)
+    const { icon, description } = await generateProjectMetadata(prompt, model);
+    // Build result
+    const result = {
+        slug,
+        friendlyName,
+        description,
+        icon,
+        template: {
+            id: finalTemplate.id,
+            name: finalTemplate.name,
+            framework: finalTemplate.tech.framework,
+            port: finalTemplate.setup.defaultPort,
+            runCommand: finalTemplate.setup.devCommand,
+            repository: finalTemplate.repository,
+            branch: finalTemplate.branch,
+        },
+    };
+    // Emit project metadata
+    sendEvent({
+        type: 'project-metadata',
+        commandId,
+        timestamp: new Date().toISOString(),
+        payload: {
+            path: '', // Not yet created
+            projectType: result.template.framework,
+            runCommand: result.template.runCommand,
+            port: result.template.port,
+            detectedFramework: result.template.framework,
+            slug: result.slug,
+            friendlyName: result.friendlyName,
+            description: result.description,
+            icon: result.icon,
+            template: result.template,
+        },
+    });
+    // Emit analysis complete
+    sendEvent({
+        type: 'analysis-complete',
+        commandId,
+        timestamp: new Date().toISOString(),
+    });
+    console.log('[project-analyzer] Analysis complete!');
+    console.log(`[project-analyzer] Project: ${friendlyName} (${slug})`);
+    console.log(`[project-analyzer] Template: ${finalTemplate.name}`);
+    console.log(`[project-analyzer] Icon: ${icon}`);
+    return result;
+}
+
 // Silent mode for TUI
 let isSilentMode$1 = false;
 function setSilentMode(silent) {
@@ -12694,8 +13391,45 @@ async function startRunner(options = {}) {
         };
     }
     async function handleCommand(command) {
+        // Handle analyze-project specially - no projectId yet
+        if (command.type === 'analyze-project') {
+            debugLog(`Received command: analyze-project`);
+            debugLog(`Command ID: ${command.id}`);
+            debugLog(`Timestamp: ${command.timestamp}`);
+            // Send ack without projectId
+            sendEvent({
+                type: "ack",
+                commandId: command.id,
+                timestamp: new Date().toISOString(),
+                message: `Command analyze-project accepted`,
+            });
+            // Handle the analyze-project command
+            try {
+                log('🔍 Starting project analysis...');
+                await analyzeProject({
+                    prompt: command.payload.prompt,
+                    agent: command.payload.agent,
+                    claudeModel: command.payload.claudeModel,
+                    tags: command.payload.tags,
+                }, sendEvent, command.id);
+                log('✅ Project analysis complete');
+            }
+            catch (error) {
+                log('❌ Project analysis failed:', error);
+                sendEvent({
+                    type: 'error',
+                    commandId: command.id,
+                    timestamp: new Date().toISOString(),
+                    error: error instanceof Error ? error.message : 'Analysis failed',
+                    stack: error instanceof Error ? error.stack : undefined,
+                });
+            }
+            return;
+        }
+        // All other commands have projectId
+        const projectId = command.projectId;
         // Log command receipt - only verbose details in debug mode
-        debugLog(`Received command: ${command.type} for project: ${command.projectId}`);
+        debugLog(`Received command: ${command.type} for project: ${projectId}`);
         debugLog(`Command ID: ${command.id}`);
         debugLog(`Timestamp: ${command.timestamp}`);
         // Log command-specific details (verbose only)
@@ -12715,7 +13449,7 @@ async function startRunner(options = {}) {
         }
         sendEvent({
             type: "ack",
-            ...buildEventBase(command.projectId, command.id),
+            ...buildEventBase(projectId, command.id),
             message: `Command ${command.type} accepted`,
         });
         switch (command.type) {
@@ -14208,6 +14942,10 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                 const command = JSON.parse(String(data));
                 // BUG FIX: Update lastCommandReceived timestamp
                 lastCommandReceived = Date.now();
+                // Get projectId - analyze-project commands don't have one yet
+                const projectIdForTelemetry = command.type === 'analyze-project'
+                    ? 'pending-analysis'
+                    : command.projectId;
                 // Continue trace from frontend - each build now starts its trace in the frontend
                 // This creates a span within the continued trace for the runner's work
                 if (command._sentry?.trace) {
@@ -14223,13 +14961,13 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                             attributes: {
                                 'command.type': command.type,
                                 'command.id': command.id,
-                                'project.id': command.projectId,
+                                'project.id': projectIdForTelemetry,
                                 'trace.continued': true,
                             },
                         }, async (span) => {
                             try {
                                 setTag("command_type", command.type);
-                                setTag("project_id", command.projectId);
+                                setTag("project_id", projectIdForTelemetry);
                                 setTag("command_id", command.id);
                                 // Capture build metrics for start-build commands
                                 if (command.type === 'start-build' && command.payload) {
@@ -14267,13 +15005,13 @@ Write a brief, professional summary (1-3 sentences) describing what was accompli
                         attributes: {
                             'command.type': command.type,
                             'command.id': command.id,
-                            'project.id': command.projectId,
+                            'project.id': projectIdForTelemetry,
                             'trace.continued': false,
                         },
                     }, async (span) => {
                         try {
                             setTag("command_type", command.type);
-                            setTag("project_id", command.projectId);
+                            setTag("project_id", projectIdForTelemetry);
                             setTag("command_id", command.id);
                             // Capture build metrics for start-build commands
                             if (command.type === 'start-build' && command.payload) {