@arcteninc/core 0.0.139 → 0.0.140

package/scripts/cli-init-wizard.ts

@@ -1,968 +1,648 @@
 #!/usr/bin/env node
 /**
- * Arcten Init Wizard - Interactive setup for AI agent integration
+ * Arcten Init - Complete End-to-End Setup
  *
- * Features:
- * - Scans codebase for functions
- * - Estimates analysis cost
- * - Optional AI analysis for tool recommendations
- * - Syncs configuration to dashboard
- * - Generates local setup files
+ * Creates a FULLY WORKING setup with zero manual steps:
+ * 1. Deterministic discovery (tree-sitter scan)
+ * 2. Deterministic classification (AI API + pattern fallback)
+ * 3. Placement menu (user choice)
+ * 4. Deterministic file creation (templates)
+ * 5. AI review (checks generated files)
+ * 6. Run sync (generates arcten.tools.ts)
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { glob } from 'glob';
 import * as readline from 'readline';
-import { autoDiscoverAndExtract } from './cli-extract-types-auto.ts';
+import { execSync } from 'child_process';
+import { discoverFunctionsInDirectory, filterLikelyTools, type DiscoveredFunction } from './tree-sitter-discover.js';
 
 // Types
-interface FunctionMetadata {
-  name: string;
-  file: string;
-  params: any;
-  returnType?: string;
-  jsDoc?: string;
-  sourceCode?: string;
+interface InitContext {
+  projectRoot: string;
+  framework: 'nextjs-app' | 'nextjs-pages' | 'vite' | 'unknown';
+  toolsFile: string;
+  toolsFileRelative: string;
+  functions: DiscoveredFunction[];
+  apiKey: string;
+  projectId: string;
+  serverUrl: string;
 }
 
-interface CodebaseContext {
-  fileTree: string;
-  framework: {
-    name: string;
-    version?: string;
-    type: 'nextjs-app' | 'nextjs-pages' | 'vite' | 'cra' | 'unknown';
-  };
-  dependencies: Record<string, string>;
-  functions: FunctionMetadata[];
-  stats: {
-    totalFunctions: number;
-    skippedPaths: string[];
-  };
-}
-
-interface AnalysisEstimate {
-  success: boolean;
-  estimatedTokens: number;
-  estimatedCost: number;
-  functionCount: number;
-  chunkCount: number;
-  willBeChunked: boolean;
-  currency: string;
-  message: string;
-}
-
-interface AnalysisResult {
-  success: boolean;
-  tokensUsed: number;
-  inputTokens: number;
-  outputTokens: number;
-  recommendations: ToolRecommendation[];
-  suggestedAgents: AgentConfig[];
-  suggestedPlacements: PlacementSuggestion[];
-  stats: any;
+interface Classification {
+  safe: string[];
+  sensitive: string[];
+  source: 'ai' | 'pattern-fallback';
 }
 
-interface ToolRecommendation {
-  name: string;
-  category: 'data-read' | 'data-write' | 'action' | 'query';
-  description: string;
-  shouldEnable: boolean;
-  requiresApproval: boolean;
-  sensitiveParams?: string[];
-  suggestedAgents?: string[];
-}
+type Placement = 'everywhere' | 'specific' | 'developer';
 
-interface AgentConfig {
-  name: string;
-  systemPrompt: string;
-  enabledTools: string[];
-  description?: string;
+interface InitResult {
+  context: InitContext;
+  classification: Classification;
+  placement: Placement;
+  specificPages?: string[];
 }
 
-interface PlacementSuggestion {
-  file: string;
-  location: string;
-  agentName: string;
-}
+// State
+let rl: readline.Interface;
 
-// Configuration
-const EXCLUDE_PATHS = [
-  'node_modules',
-  '.git',
-  'dist',
-  'build',
-  '.next',
-  'out',
-  '__tests__',
-  '*.test.*',
-  '*.spec.*',
-];
-
-// Helper: Create readline interface
-function createPrompt() {
-  return readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-}
-
-// Helper: Ask a question
-function ask(rl: readline.Interface, question: string): Promise<string> {
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      resolve(answer.trim());
-    });
-  });
-}
+// ============================================================================
+// PHASE 1: Deterministic Discovery
+// ============================================================================
 
-// Helper: Confirm action
-async function confirm(rl: readline.Interface, question: string): Promise<boolean> {
-  const answer = await ask(rl, `${question} (y/n): `);
-  return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
-}
-
-// Step 1: Check for API key
-async function checkApiKey(rl: readline.Interface): Promise<{ apiKey: string; projectId: string }> {
-  console.log('\n📋 Step 1: Authentication\n');
-
-  let apiKey: string | undefined;
-  let foundInFile: string | undefined;
+async function discoverContext(): Promise<InitContext> {
+  const projectRoot = process.cwd();
 
-  // Check multiple env files in order of preference
-  const envFiles = ['.env.local', '.env'];
+  console.log('Scanning your project...\n');
 
-  for (const envFile of envFiles) {
-    const envPath = path.join(process.cwd(), envFile);
-    if (fs.existsSync(envPath)) {
-      const envContent = fs.readFileSync(envPath, 'utf-8');
-      const match = envContent.match(/ARCTEN_API_KEY=([^\s\n]+)/);
-      if (match) {
-        apiKey = match[1];
-        foundInFile = envFile;
-        console.log(`✓ Found API key in ${envFile}`);
-        break;
-      }
+  // Detect framework
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  let framework: InitContext['framework'] = 'unknown';
+
+  if (fs.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.next) {
+      const hasAppDir = fs.existsSync(path.join(projectRoot, 'app'));
+      framework = hasAppDir ? 'nextjs-app' : 'nextjs-pages';
+    } else if (deps.vite) {
+      framework = 'vite';
     }
   }
 
-  // If not found, prompt
-  if (!apiKey) {
-    console.log('No API key found in .env or .env.local files.');
-    console.log('\n📍 Get your API key from: https://arcten.com/dashboard');
-    apiKey = await ask(rl, '\nEnter your API key: ');
+  // Discover functions
+  let functions = await discoverFunctionsInDirectory(projectRoot, {
+    functionsOnly: true,
+    exportedOnly: true,
+  });
 
-    if (!apiKey) {
-      console.error('❌ API key is required');
-      process.exit(1);
-    }
+  functions = filterLikelyTools(functions);
 
-    // Save to .env.local (preferred for local development)
-    const envPath = path.join(process.cwd(), '.env.local');
-    const envEntry = `\nARCTEN_API_KEY=${apiKey}\n`;
-    fs.appendFileSync(envPath, envEntry);
-    console.log('✓ Saved API key to .env.local');
-  }
-
-  // Extract project ID from API key (format: sk_proj_xxxxx_yyyyy)
-  const projectIdMatch = apiKey.match(/sk_(proj_[a-zA-Z0-9]+)_/);
-  if (!projectIdMatch) {
-    console.error('❌ Invalid API key format');
+  if (functions.length === 0) {
+    console.log('No exported functions found in your project.');
+    console.log('');
+    console.log('Create a tools file (e.g., app/tools.ts) with exported functions:');
+    console.log('');
+    console.log('  export function getOrders(status: string) { ... }');
+    console.log('  export function createOrder(data: OrderData) { ... }');
+    console.log('');
     process.exit(1);
   }
 
-  const projectId = projectIdMatch[1];
-  console.log(`✓ Project ID: ${projectId}`);
+  // Find the primary tools file (most functions)
+  const fileGroups = new Map<string, DiscoveredFunction[]>();
+  for (const fn of functions) {
+    const file = fn.file;
+    if (!fileGroups.has(file)) {
+      fileGroups.set(file, []);
+    }
+    fileGroups.get(file)!.push(fn);
+  }
 
-  return { apiKey, projectId };
-}
+  // Sort by function count and pick the best
+  const sortedFiles = [...fileGroups.entries()].sort((a, b) => b[1].length - a[1].length);
+  const [toolsFile, toolFunctions] = sortedFiles[0];
 
-// Step 2: Scan codebase
-async function scanCodebase(): Promise<CodebaseContext> {
-  console.log('\n📂 Step 2: Scanning codebase...\n');
+  const toolsFileRelative = path.relative(projectRoot, toolsFile);
 
-  const projectRoot = process.cwd();
+  // Check for API key
+  const auth = checkApiKey(projectRoot);
+  if (!auth) {
+    console.log('No API key found.');
+    console.log('');
+    console.log('Get your API key from: https://arcten.com/dashboard');
+    console.log('');
 
-  // Detect framework
-  const framework = detectFramework(projectRoot);
-  console.log(`✓ Detected framework: ${framework.name} (${framework.type})`);
+    const apiKeyInput = await askQuestion('Paste your API key: ');
+    const projectIdMatch = apiKeyInput.match(/sk_(proj_[a-zA-Z0-9]+)_/);
 
-  // Get dependencies
-  const dependencies = getDependencies(projectRoot);
-  console.log(`✓ Found ${Object.keys(dependencies).length} dependencies`);
+    if (!projectIdMatch) {
+      console.log('Invalid API key format. Expected: sk_proj_xxxxx_yyyyy');
+      process.exit(1);
+    }
 
-  // Scan for functions
-  const functions = await scanFunctions(projectRoot);
-  console.log(`✓ Found ${functions.length} functions`);
+    // Save to .env.local
+    const envPath = path.join(projectRoot, '.env.local');
+    let envContent = '';
+    if (fs.existsSync(envPath)) {
+      envContent = fs.readFileSync(envPath, 'utf-8');
+    }
+    if (!envContent.includes('ARCTEN_API_KEY')) {
+      envContent += `\nARCTEN_API_KEY=${apiKeyInput}\n`;
+      envContent += `NEXT_PUBLIC_ARCTEN_API_URL=https://api.arcten.com\n`;
+      fs.writeFileSync(envPath, envContent.trim() + '\n');
+      console.log('  Saved API key to .env.local');
+    }
 
-  // Build file tree
-  const fileTree = buildFileTree(projectRoot);
+    return {
+      projectRoot,
+      framework,
+      toolsFile,
+      toolsFileRelative,
+      functions: toolFunctions,
+      apiKey: apiKeyInput,
+      projectId: projectIdMatch[1],
+      serverUrl: process.env.ARCTEN_SERVER_URL || 'https://api.arcten.com',
+    };
+  }
 
-  // Debug: log context size
-  const contextStr = JSON.stringify({
-    fileTree,
-    framework,
-    dependencies,
-    functions,
-    stats: {
-      totalFunctions: functions.length,
-      skippedPaths: EXCLUDE_PATHS,
-    },
-  });
-  console.log(`📊 Context size: ${(contextStr.length / 1024).toFixed(2)} KB (~${Math.round(contextStr.length / 4)} tokens)`);
+  console.log(`Found ${framework === 'nextjs-app' ? 'Next.js App Router' : framework} project`);
+  console.log(`Found ${toolFunctions.length} functions in ${toolsFileRelative}`);
+  console.log('');
 
   return {
-    fileTree,
+    projectRoot,
     framework,
-    dependencies,
-    functions,
-    stats: {
-      totalFunctions: functions.length,
-      skippedPaths: EXCLUDE_PATHS,
-    },
+    toolsFile,
+    toolsFileRelative,
+    functions: toolFunctions,
+    apiKey: auth.apiKey,
+    projectId: auth.projectId,
+    serverUrl: process.env.ARCTEN_SERVER_URL || 'https://api.arcten.com',
   };
 }
 
-// Helper: Detect framework
-function detectFramework(projectRoot: string): CodebaseContext['framework'] {
-  const packageJsonPath = path.join(projectRoot, 'package.json');
+// ============================================================================
+// PHASE 2: Deterministic Classification
+// ============================================================================
 
-  if (!fs.existsSync(packageJsonPath)) {
-    return { name: 'Unknown', type: 'unknown' };
-  }
-
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-
-  if (deps.next) {
-    const hasAppDir = fs.existsSync(path.join(projectRoot, 'app'));
-    return {
-      name: hasAppDir ? 'Next.js App Router' : 'Next.js Pages Router',
-      version: deps.next,
-      type: hasAppDir ? 'nextjs-app' : 'nextjs-pages',
-    };
-  }
+async function classifyTools(context: InitContext): Promise<Classification> {
+  console.log('Classifying tools...');
 
-  if (deps.vite) {
-    return { name: 'Vite', version: deps.vite, type: 'vite' };
-  }
+  const toolsToClassify = context.functions.map(f => ({
+    name: f.name,
+    jsDoc: f.jsDocComment,
+  }));
 
-  if (deps['react-scripts']) {
-    return { name: 'Create React App', version: deps['react-scripts'], type: 'cra' };
-  }
+  // Try AI classification first
+  try {
+    const response = await fetch(`${context.serverUrl}/ai-init/classify`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-arcten-api-key': context.apiKey,
+      },
+      body: JSON.stringify({ tools: toolsToClassify }),
+    });
 
-  return { name: 'Unknown', type: 'unknown' };
-}
+    if (response.ok) {
+      const result = await response.json() as {
+        classifications: Record<string, 'safe' | 'sensitive'>;
+        safe: string[];
+        sensitive: string[];
+      };
 
-// Helper: Get dependencies
-function getDependencies(projectRoot: string): Record<string, string> {
-  const packageJsonPath = path.join(projectRoot, 'package.json');
+      console.log(`  ${result.safe.length} safe (auto-execute)`);
+      console.log(`  ${result.sensitive.length} sensitive (needs approval)`);
+      console.log('');
 
-  if (!fs.existsSync(packageJsonPath)) {
-    return {};
+      return {
+        safe: result.safe,
+        sensitive: result.sensitive,
+        source: 'ai',
+      };
+    }
+  } catch {
+    // Fall through to pattern-based
   }
 
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-  return { ...packageJson.dependencies };
-}
-
-// Helper: Scan for functions (reuses existing autoDiscoverAndExtract)
-async function scanFunctions(projectRoot: string): Promise<FunctionMetadata[]> {
-  console.log('🔍 Using TypeScript AST to scan for exported functions...');
-
-  // Generate metadata file using existing extraction logic
-  const outputPath = path.join(projectRoot, '.arcten', 'tool-metadata.ts');
-
-  // Ensure .arcten directory exists
-  const arctenDir = path.dirname(outputPath);
-  if (!fs.existsSync(arctenDir)) {
-    fs.mkdirSync(arctenDir, { recursive: true });
+  // Pattern-based fallback
+  const safePatterns = /^(get|list|search|find|fetch|load|calculate|count)/i;
+  const sensitivePatterns = /^(create|update|delete|set|add|remove|regenerate)/i;
+  const sensitiveReads = /^(get|fetch).*(api.?key|credential|secret|password|token)/i;
+
+  const safe: string[] = [];
+  const sensitive: string[] = [];
+
+  for (const tool of toolsToClassify) {
+    if (sensitiveReads.test(tool.name)) {
+      sensitive.push(tool.name);
+    } else if (sensitivePatterns.test(tool.name)) {
+      sensitive.push(tool.name);
+    } else if (safePatterns.test(tool.name)) {
+      safe.push(tool.name);
+    } else {
+      sensitive.push(tool.name); // Default to sensitive
+    }
   }
 
-  // Run the auto-discovery
-  await autoDiscoverAndExtract(projectRoot, outputPath);
+  console.log(`  ${safe.length} safe (auto-execute)`);
+  console.log(`  ${sensitive.length} sensitive (needs approval)`);
+  console.log('');
 
-  // Read the generated metadata
-  const content = fs.readFileSync(outputPath, 'utf-8');
-  const metadataMatch = content.match(/export const toolMetadata = ([\s\S]+) as const;/);
+  return { safe, sensitive, source: 'pattern-fallback' };
+}
 
-  if (!metadataMatch) {
-    return [];
-  }
+// ============================================================================
+// PHASE 3: Placement Menu
+// ============================================================================
 
-  const metadata = JSON.parse(metadataMatch[1]);
-  const functions: FunctionMetadata[] = [];
+async function showPlacementMenu(): Promise<Placement> {
+  console.log('Where should your agent appear?\n');
+  console.log('  [1] 🌍 Everywhere - sidebar on every page');
+  console.log('  [2] 📄 Specific pages - only where you choose');
+  console.log('  [3] 🔧 Developer mode - just the hook, build your own UI');
+  console.log('');
 
-  // Convert to wizard format
-  for (const [name, fn] of Object.entries(metadata.functions as any)) {
-    // Find which file this function was discovered from
-    const fileIndex = metadata.discoveredFrom.findIndex((f: string) =>
-      content.includes(name)
-    );
+  const answer = await askQuestion('Choose (1/2/3): ');
+  const choice = answer.trim();
 
-    functions.push({
-      name,
-      file: metadata.discoveredFrom[fileIndex] || metadata.discoveredFrom[0] || 'unknown',
-      params: Object.entries(fn.parameters?.properties || {}).map(([paramName, prop]: [string, any]) => ({
-        name: paramName,
-        type: prop.type || 'any',
-      })),
-      returnType: fn.returnType,
-      jsDoc: fn.description,
-      sourceCode: `${name}(${Object.keys(fn.parameters?.properties || {}).join(', ')})`,
-    });
+  if (choice === '2' || choice.toLowerCase().includes('specific')) {
+    return 'specific';
+  } else if (choice === '3' || choice.toLowerCase().includes('dev')) {
+    return 'developer';
   }
 
-  return functions;
+  return 'everywhere';
 }
 
-// Helper: Build file tree (limited depth to reduce tokens)
-function buildFileTree(projectRoot: string, depth: number = 0, maxDepth: number = 2): string {
-  if (depth >= maxDepth) return '';
+// ============================================================================
+// PHASE 4: Deterministic File Creation
+// ============================================================================
 
-  const entries = fs.readdirSync(projectRoot, { withFileTypes: true });
-  let tree = '';
+async function createAllFiles(result: InitResult): Promise<string[]> {
+  const { context, classification, placement } = result;
+  const { projectRoot, toolsFileRelative, projectId, framework } = context;
+  const createdFiles: string[] = [];
 
-  for (const entry of entries) {
-    if (EXCLUDE_PATHS.some(p => entry.name.includes(p.replace('*', '')))) {
-      continue;
-    }
+  console.log('Creating files...\n');
 
-    const indent = '  '.repeat(depth);
-    tree += `${indent}${entry.isDirectory() ? '📁' : '📄'} ${entry.name}\n`;
+  // Determine app directory based on framework
+  const appDir = framework === 'nextjs-app' ? 'app' : 'src';
+  const appDirPath = path.join(projectRoot, appDir);
 
-    if (entry.isDirectory() && depth < maxDepth - 1) {
-      tree += buildFileTree(path.join(projectRoot, entry.name), depth + 1, maxDepth);
-    }
+  // 1. Create .arcten/config.ts
+  const arctenDir = path.join(projectRoot, '.arcten');
+  if (!fs.existsSync(arctenDir)) {
+    fs.mkdirSync(arctenDir, { recursive: true });
   }
 
-  return tree;
-}
-
-// Step 2.5: Handle missing descriptions
-async function handleMissingDescriptions(
-  rl: readline.Interface,
-  functions: FunctionMetadata[]
-): Promise<FunctionMetadata[]> {
-  // Find functions with generic "Execute X" descriptions
-  const missingDescriptions = functions.filter(fn =>
-    !fn.jsDoc || fn.jsDoc.startsWith('Execute ')
-  );
-
-  if (missingDescriptions.length === 0) {
-    return functions;
-  }
+  const configContent = `// Arcten configuration
+export const arctenConfig = {
+  projectId: "${projectId}",
+  toolFile: "./${toolsFileRelative.replace(/\\/g, '/')}",
+  routes: [
+    { pattern: "/*", agentName: "default" },
+  ],
+} as const;
+`;
+  fs.writeFileSync(path.join(arctenDir, 'config.ts'), configContent);
+  createdFiles.push('.arcten/config.ts');
+  console.log('  Created .arcten/config.ts');
+
+  // 2. Create app/api/arcten/token/route.ts (Next.js App Router only)
+  if (framework === 'nextjs-app') {
+    const tokenDir = path.join(appDirPath, 'api', 'arcten', 'token');
+    if (!fs.existsSync(tokenDir)) {
+      fs.mkdirSync(tokenDir, { recursive: true });
+    }
 
-  console.log(`\n⚠️  ${missingDescriptions.length} function${missingDescriptions.length > 1 ? 's are' : ' is'} missing JSDoc descriptions\n`);
-  console.log('How would you like to handle these?');
-  console.log('  1. Edit descriptions now (one by one)');
-  console.log('  2. Skip - I\'ll add JSDoc comments manually');
-  console.log('  3. Skip - I\'ll edit in dashboard later');
+    const tokenRouteContent = `import { verifyToken } from "@arcteninc/core/server";
+import { NextRequest, NextResponse } from "next/server";
 
-  const choice = await ask(rl, '\n? Choose option (1-3): ');
+export async function POST(req: NextRequest) {
+  try {
+    const { user } = await req.json();
+    const apiKey = process.env.ARCTEN_API_KEY;
 
-  if (choice === '1') {
-    // Edit descriptions one by one
-    console.log('');
-    for (const fn of missingDescriptions) {
-      console.log(`📝 ${fn.name} (${fn.file})`);
-      console.log(`   Current: ${fn.jsDoc || `Execute ${fn.name}`}\n`);
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: "ARCTEN_API_KEY not configured" },
+        { status: 500 }
+      );
+    }
 
-      const newDesc = await ask(rl, '   Enter description (or press Enter to skip): ');
+    const tokenResponse = await verifyToken({
+      apiKey,
+      user: user || { id: "anonymous", name: "User" },
+      apiUrl: process.env.NEXT_PUBLIC_ARCTEN_API_URL || "https://api.arcten.com",
+    });
 
-      if (newDesc.trim()) {
-        fn.jsDoc = newDesc.trim();
-        console.log(`   ✓ Updated description for ${fn.name}\n`);
-      } else {
-        console.log(`   ⏭️  Skipped ${fn.name}\n`);
-      }
-    }
-    console.log('✅ Description editing complete\n');
-  } else {
-    console.log('\n⏭️  Skipping description editing\n');
-    console.log('💡 You can add JSDoc comments to your code or edit descriptions in the dashboard.');
+    return NextResponse.json(tokenResponse);
+  } catch (error: any) {
+    console.error("Token generation error:", error);
+    return NextResponse.json(
+      { error: error.message || "Failed to generate token" },
+      { status: 500 }
+    );
   }
-
-  return functions;
 }
+`;
+    fs.writeFileSync(path.join(tokenDir, 'route.ts'), tokenRouteContent);
+    createdFiles.push(`${appDir}/api/arcten/token/route.ts`);
+    console.log(`  Created ${appDir}/api/arcten/token/route.ts`);
+  }
 
-// Step 3: Get user intent
-async function getUserIntent(rl: readline.Interface): Promise<string> {
-  console.log('\n💭 Step 3: Define your agent\'s purpose\n');
-  console.log('Examples:');
-  console.log('  - "Help customers place orders and track shipments"');
-  console.log('  - "Answer questions about our product documentation"');
-  console.log('  - "Assist with user account management"');
+  // 3. Create wrapper component based on placement
+  const toolsImportPath = path.relative(appDirPath, context.toolsFile).replace(/\.ts$/, '').replace(/\\/g, '/');
 
-  const intent = await ask(rl, '\n? What should your AI agent do?\n> ');
+  if (placement === 'everywhere') {
+    const wrapperContent = `"use client";
 
-  if (!intent) {
-    console.error('❌ Intent is required');
-    process.exit(1);
-  }
+import { ArctenAgent } from "@arcteninc/core";
+import { toolMetadata } from "../.arcten/tool-metadata";
+import { allTools, safeToolNames } from "../.arcten/arcten.tools";
 
-  return intent;
+interface ArctenWrapperProps {
+  children: React.ReactNode;
 }
 
-// Helper: Get JWT token from API key
-async function getAuthToken(apiKey: string, serverUrl: string): Promise<string> {
-  console.log(`🔑 Getting auth token from ${serverUrl}/token...`);
-
-  try {
-    const response = await fetch(`${serverUrl}/token`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ apiKey }),
-    });
-
-    console.log(`🔑 Token response status: ${response.status}`);
+export function ArctenWrapper({ children }: ArctenWrapperProps) {
+  return (
+    <div className="flex h-screen">
+      <div className="flex-1 overflow-auto">
+        {children}
+      </div>
+      <ArctenAgent
+        apiBaseUrl={process.env.NEXT_PUBLIC_ARCTEN_API_URL || "https://api.arcten.com"}
+        user={{ id: "user-1", name: "User" }}
+        tools={allTools}
+        safeToolNames={safeToolNames}
+        toolMetadata={toolMetadata.functions}
+      />
+    </div>
+  );
+}
 
-    if (!response.ok) {
-      const error = await response.json();
-      console.error(`🔑 Token error:`, error);
-      throw new Error(error.error || 'Failed to authenticate');
-    }
+export default ArctenWrapper;
+`;
+    fs.writeFileSync(path.join(appDirPath, 'ArctenWrapper.tsx'), wrapperContent);
+    createdFiles.push(`${appDir}/ArctenWrapper.tsx`);
+    console.log(`  Created ${appDir}/ArctenWrapper.tsx`);
+
+    // 4. Modify layout.tsx to wrap with ArctenWrapper
+    const layoutPath = path.join(appDirPath, 'layout.tsx');
+    if (fs.existsSync(layoutPath)) {
+      let layoutContent = fs.readFileSync(layoutPath, 'utf-8');
+
+      // Add import if not present
+      if (!layoutContent.includes('ArctenWrapper')) {
+        // Add import at the top (after existing imports)
+        const importStatement = `import { ArctenWrapper } from "./ArctenWrapper";\n`;
+        const lastImportIndex = layoutContent.lastIndexOf('import ');
+        if (lastImportIndex !== -1) {
+          const endOfImport = layoutContent.indexOf('\n', lastImportIndex);
+          layoutContent = layoutContent.slice(0, endOfImport + 1) + importStatement + layoutContent.slice(endOfImport + 1);
+        } else {
+          layoutContent = importStatement + layoutContent;
+        }
 
-    const data = await response.json();
-    const token = data.clientToken || data.token; // Server returns "clientToken"
-    console.log(`🔑 Got token: ${token ? token.substring(0, 20) + '...' : 'NO TOKEN'}`);
+        // Wrap {children} with <ArctenWrapper>
+        layoutContent = layoutContent.replace(
+          /(\{children\})/,
+          '<ArctenWrapper>{children}</ArctenWrapper>'
+        );
 
-    if (!token) {
-      throw new Error('No token received from server');
+        fs.writeFileSync(layoutPath, layoutContent);
+        createdFiles.push(`${appDir}/layout.tsx (modified)`);
+        console.log(`  Modified ${appDir}/layout.tsx`);
+      }
     }
+  } else if (placement === 'specific') {
+    // Create standalone component for specific pages
+    const componentContent = `"use client";
+
+import { ArctenAgent } from "@arcteninc/core";
+import { toolMetadata } from "../.arcten/tool-metadata";
+import { allTools, safeToolNames } from "../.arcten/arcten.tools";
+
+export function ArctenChat() {
+  return (
+    <ArctenAgent
+      apiBaseUrl={process.env.NEXT_PUBLIC_ARCTEN_API_URL || "https://api.arcten.com"}
+      user={{ id: "user-1", name: "User" }}
+      tools={allTools}
+      safeToolNames={safeToolNames}
+      toolMetadata={toolMetadata.functions}
+    />
+  );
+}
 
-    return token;
-  } catch (error: any) {
-    if (error.cause?.code === 'ENOTFOUND' || error.cause?.code === 'ECONNREFUSED' || error.message.includes('fetch')) {
-      console.error(`\n❌ Unable to connect to: ${serverUrl}`);
-      console.error('\nPossible issues:');
-      console.error('  • No internet connection');
-      console.error('  • API server is down');
-      console.error('  • Firewall blocking the request');
-      throw new Error('Connection failed');
+export default ArctenChat;
+`;
+    const componentsDir = path.join(projectRoot, 'components');
+    if (!fs.existsSync(componentsDir)) {
+      fs.mkdirSync(componentsDir, { recursive: true });
     }
-    throw error;
+    fs.writeFileSync(path.join(componentsDir, 'ArctenChat.tsx'), componentContent);
+    createdFiles.push('components/ArctenChat.tsx');
+    console.log('  Created components/ArctenChat.tsx');
+    console.log('');
+    console.log('  Import it in your pages:');
+    console.log('    import { ArctenChat } from "@/components/ArctenChat";');
+    console.log('');
+  } else {
+    // Developer mode - just show hook usage
+    console.log('');
+    console.log('  Developer mode - use the hook directly:');
+    console.log('');
+    console.log('    import { useAgent } from "@arcteninc/core";');
+    console.log('    import { allTools, safeToolNames } from "./.arcten/arcten.tools";');
+    console.log('    import { toolMetadata } from "./.arcten/tool-metadata";');
+    console.log('');
+    console.log('    const { messages, sendMessage } = useAgent({');
+    console.log('      tools: allTools,');
+    console.log('      safeToolNames,');
+    console.log('      toolMetadata: toolMetadata.functions,');
+    console.log('    });');
+    console.log('');
   }
-}
 
-// Step 4: Estimate cost
-async function estimateCost(apiKey: string, serverUrl: string, context: CodebaseContext): Promise<AnalysisEstimate> {
-  console.log('\n💰 Estimating analysis cost...\n');
+  // 5. Update package.json scripts
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 
-  try {
-    const url = `${serverUrl}/tools/analyze/estimate`;
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ context }),
-    });
+    let modified = false;
 
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.error || 'Failed to estimate cost');
+    // Add arcten sync to dev and build (runs silently if no changes)
+    if (pkg.scripts?.dev && !pkg.scripts.dev.includes('arcten sync')) {
+      pkg.scripts.dev = `arcten sync --yes && ${pkg.scripts.dev}`;
+      modified = true;
     }
-
-    return await response.json();
-  } catch (error: any) {
-    if (error.cause?.code === 'ENOTFOUND' || error.cause?.code === 'ECONNREFUSED' || error.message.includes('fetch')) {
-      console.error(`\n❌ Unable to connect to: ${serverUrl}`);
-      console.error('\nPossible issues:');
-      console.error('  • No internet connection');
-      console.error('  • API server is down');
-      console.error('  • Firewall blocking the request');
-      console.error('\n💡 Tip: Use --allow-all flag to skip analysis and enable all tools');
-      throw new Error('Connection failed');
+    if (pkg.scripts?.build && !pkg.scripts.build.includes('arcten sync')) {
+      pkg.scripts.build = `arcten sync --yes && ${pkg.scripts.build}`;
+      modified = true;
     }
-    throw error;
-  }
-}
 
-// Step 5: Confirm analysis
-async function confirmAnalysis(rl: readline.Interface, estimate: AnalysisEstimate): Promise<boolean> {
-  console.log('┌─────────────────────────────────────────────────┐');
-  console.log('│  💰 AI Analysis (Billable)                      │');
-  console.log('│                                                 │');
-  console.log(`│  Estimated cost: $${estimate.estimatedCost.toFixed(2)}`.padEnd(50) + '│');
-  console.log(`│  ${estimate.functionCount} functions across ${estimate.chunkCount} chunk${estimate.chunkCount > 1 ? 's' : ''}`.padEnd(50) + '│');
-  console.log('│                                                 │');
-
-  if (estimate.willBeChunked) {
-    console.log('│  ⚠️  Large codebase - will process in chunks    │');
-    console.log('│                                                 │');
+    if (modified) {
+      fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+      createdFiles.push('package.json (modified)');
+      console.log('  Updated package.json scripts');
+    }
   }
 
-  console.log('│  This will be deducted from your subscription.  │');
-  console.log('│                                                 │');
-  console.log('│  The AI will:                                   │');
-  console.log(`│  • Categorize your ${estimate.functionCount} functions`.padEnd(50) + '│');
-  console.log('│  • Suggest which to enable for your use case    │');
-  console.log('│  • Recommend agent configurations               │');
-  console.log('│  • Suggest where to place the agent             │');
-  console.log('└─────────────────────────────────────────────────┘');
   console.log('');
-
-  return await confirm(rl, `? Continue with analysis ($${estimate.estimatedCost.toFixed(2)})?`);
+  return createdFiles;
 }
 
-// Step 6: Run analysis
-async function runAnalysis(
-  apiKey: string,
-  serverUrl: string,
-  context: CodebaseContext,
-  userIntent: string
-): Promise<AnalysisResult> {
-  console.log('\n🤖 Analyzing with AI...\n');
-
-  // Get JWT token from API key
-  const token = await getAuthToken(apiKey, serverUrl);
-  console.log(`📡 Using token for analysis: ${token ? token.substring(0, 20) + '...' : 'NO TOKEN'}`);
-  console.log(`📡 Calling: ${serverUrl}/tools/analyze`);
-
-  const response = await fetch(`${serverUrl}/tools/analyze`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${token}`,
-    },
-    body: JSON.stringify({ context, userIntent }),
-  });
-
-  console.log(`📡 Analysis response status: ${response.status}`);
-
-  if (!response.ok) {
-    const error = await response.json();
-    console.error(`📡 Analysis error response:`, error);
-    throw new Error(error.error || 'Analysis failed');
-  }
-
-  const result = await response.json();
-  console.log(`📡 Analysis result:`, JSON.stringify(result).substring(0, 200));
-
-  if (!result || !result.success) {
-    throw new Error(result?.error || 'Analysis failed - invalid response');
-  }
-
-  const tokensUsed = result.tokensUsed || 0;
-  const actualCost = result.stats?.actualCost || 0;
-
-  console.log(`✓ Analysis complete - ${tokensUsed.toLocaleString()} tokens used`);
-  console.log(`  Actual cost: $${actualCost.toFixed(2)}`);
+// ============================================================================
+// PHASE 5: AI Review (disabled - endpoint not implemented)
+// ============================================================================
 
-  return result;
+async function aiReviewFiles(_result: InitResult, _createdFiles: string[]): Promise<void> {
+  // AI review is optional and requires server endpoint /ai-init/review
+  // Skipping for now since the generated files are deterministic
 }
 
-// Step 7: Sync to dashboard
-async function syncToDashboard(
-  apiKey: string,
-  serverUrl: string,
-  projectId: string,
-  tools: ToolRecommendation[],
-  agents?: AgentConfig[]
-): Promise<void> {
-  console.log('\n☁️  Step 7: Syncing to dashboard...\n');
-
-  // Convert tools to the format expected by bulkUpsert
-  const toolsData = tools.map(tool => ({
-    name: tool.name,
-    description: tool.description,
-    signature: JSON.stringify({ /* simplified */ }),
-    sourceFile: undefined, // Not tracked in wizard yet
-    category: tool.category,
-    isEnabled: tool.shouldEnable,
-    isOverridable: true,
-    requiresApproval: tool.requiresApproval,
-    sensitiveParams: tool.sensitiveParams || [],
-  }));
+// ============================================================================
+// PHASE 6: Run Sync
+// ============================================================================
 
-  // Convert agents to the format expected by bulkUpsert
-  const agentsData = agents?.map(agent => ({
-    name: agent.name,
-    systemPrompt: agent.systemPrompt,
-    enabledTools: agent.enabledTools,
-    description: agent.description || `Agent: ${agent.name}`,
-  })) || [];
+async function runSync(): Promise<void> {
+  console.log('Running sync...\n');
 
   try {
-    // Get JWT token
-    const token = await getAuthToken(apiKey, serverUrl);
-
-    // Call server endpoint which will handle Convex mutation
-    const response = await fetch(`${serverUrl}/tools/sync`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${token}`,
-      },
-      body: JSON.stringify({
-        projectId,
-        tools: toolsData,
-        agents: agentsData,
-      }),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => 'Unknown error');
-      throw new Error(`Failed to sync: ${response.status} ${errorText}`);
-    }
-
-    const result = await response.json();
-
-    if (!result.success) {
-      throw new Error(result.error || 'Failed to sync to dashboard');
-    }
-
-    console.log(`✅ Synced ${tools.length} tools${agents && agents.length > 0 ? ` and ${agents.length} agents` : ''} to dashboard`);
-
-    if (result.upserted) {
-      const created = result.upserted.filter((t: any) => t.created).length;
-      const updated = result.upserted.filter((t: any) => !t.created).length;
-      console.log(`   📝 Tools - Created: ${created} | Updated: ${updated}`);
-    }
-
-    if (result.agents && agents && agents.length > 0) {
-      const agentCreated = result.agents.filter((a: any) => a.created).length;
-      const agentUpdated = result.agents.filter((a: any) => !a.created).length;
-      console.log(`   📝 Agents - Created: ${agentCreated} | Updated: ${agentUpdated}`);
+    // Get script directory (ESM compatible)
+    const scriptDir = path.dirname(new URL(import.meta.url).pathname).replace(/^\/([A-Z]:)/, '$1');
+
+    // Run arcten sync which handles extract-types + tool array generation
+    const syncScript = path.join(scriptDir, 'cli-sync-wrapper.cjs');
+    if (fs.existsSync(syncScript)) {
+      execSync(`node "${syncScript}" --yes`, {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+      });
+    } else {
+      // Fallback: run extract-types directly
+      console.log('  Running arcten-extract-types...');
+      const extractScript = path.join(scriptDir, 'cli-extract-types-auto-wrapper.js');
+      if (fs.existsSync(extractScript)) {
+        execSync(`node "${extractScript}"`, {
+          cwd: process.cwd(),
+          stdio: ['inherit', 'pipe', 'pipe'],
+        });
+      } else {
+        execSync('npx arcten-extract-types', {
+          cwd: process.cwd(),
+          stdio: ['inherit', 'pipe', 'pipe'],
+        });
+      }
+      console.log('  Done');
     }
   } catch (error: any) {
-    console.error(`❌ Failed to sync: ${error.message}`);
-    throw error;
+    console.log('  Warning: Sync encountered an error');
+    console.log('  You can run `arcten sync` manually after setup');
   }
 }
 
-// Step 7.5: Display placement suggestions
-async function displayPlacementSuggestions(
-  placements: PlacementSuggestion[]
-): Promise<void> {
-  if (!placements || placements.length === 0) {
-    return;
-  }
+// ============================================================================
+// Helper Functions
+// ============================================================================
 
-  console.log('\n📍 Suggested Placements:\n');
+function checkApiKey(projectRoot: string): { apiKey: string; projectId: string } | null {
+  const envFiles = ['.env.local', '.env'];
 
-  for (const placement of placements) {
-    console.log(`  ${placement.file}`);
-    console.log(`  └─ Location: ${placement.location}`);
-    console.log(`  └─ Agent: ${placement.agentName}`);
-    console.log('');
+  for (const envFile of envFiles) {
+    const envPath = path.join(projectRoot, envFile);
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, 'utf-8');
+      const match = envContent.match(/ARCTEN_API_KEY=([^\s\n]+)/);
+      if (match) {
+        const key = match[1];
+        const projectIdMatch = key.match(/sk_(proj_[a-zA-Z0-9]+)_/);
+        if (projectIdMatch) {
+          return { apiKey: key, projectId: projectIdMatch[1] };
+        }
+      }
+    }
   }
 
-  console.log('💡 Integration Steps:\n');
-  console.log('  1. Install @arcteninc/core: bun add @arcteninc/core');
-  console.log('  2. Import and use the agent in your components:');
-  console.log('');
-  console.log('     import { useAgent } from "@arcteninc/core";');
-  console.log('     import { arctenConfig } from "./.arcten/config";');
-  console.log('');
-  console.log('     function MyComponent() {');
-  console.log('       const agent = useAgent({');
-  console.log('         projectId: arctenConfig.projectId,');
-  console.log('         agentName: "default",');
-  console.log('         tools: myTools,');
-  console.log('       });');
-  console.log('');
-  console.log('       return (');
-  console.log('         <div>');
-  console.log('           {agent.messages.map(m => <div key={m.id}>{m.content}</div>)}');
-  console.log('         </div>');
-  console.log('       );');
-  console.log('     }');
-  console.log('');
-  console.log('  3. For pre-built UI, use <ArctenAgent /> component');
-  console.log('');
-  console.log('  For more info: https://arcten.com/docs/integration');
-  console.log('');
+  return null;
 }
 
-// Generate agent profiles from user description
-async function generateAgents(
-  apiKey: string,
-  serverUrl: string,
-  description: string,
-  functions: FunctionMetadata[]
-): Promise<AgentConfig[]> {
-  const token = await getAuthToken(apiKey, serverUrl);
-
-  const tools = functions.map(fn => ({
-    name: fn.name,
-    description: fn.jsDoc || `Function: ${fn.name}`,
-  }));
-
-  const response = await fetch(`${serverUrl}/tools/generate-agents`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${token}`,
-    },
-    body: JSON.stringify({
-      description,
-      tools,
-    }),
+function askQuestion(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
   });
-
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => 'Unknown error');
-    throw new Error(`Failed to generate agents: ${response.status} ${errorText}`);
-  }
-
-  const result = await response.json();
-
-  if (!result.success || !result.agents) {
-    throw new Error(result.error || 'Failed to generate agent profiles');
-  }
-
-  return result.agents;
 }
 
-// Step 8: Generate local config files
-async function generateLocalConfig(
-  projectId: string,
-  agentName: string = 'default'
-): Promise<void> {
-  console.log('\n📁 Step 8: Generating local configuration...\n');
-
-  try {
-    // Create .arcten directory if it doesn't exist
-    const arctenDir = path.join(process.cwd(), '.arcten');
-    if (!fs.existsSync(arctenDir)) {
-      fs.mkdirSync(arctenDir, { recursive: true });
-    }
-
-    // Generate .arcten/config.ts
-    const configContent = `/**
- * Arcten Configuration
- * Generated by: arcten init
- *
- * This file contains your project ID and route configurations.
- * Modify this file to change which agents are used on different routes.
- */
-
-export const arctenConfig = {
-  projectId: "${projectId}",
-  routes: [
-    // Default route - matches all pages
-    { pattern: "/*", agentName: "${agentName}" },
-
-    // Add more route-specific agents here
-    // Example:
-    // { pattern: "/products/*", agentName: "sales-assistant" },
-    // { pattern: "/support/*", agentName: "support-bot" },
-  ],
-} as const;
-`;
-
-    const configPath = path.join(arctenDir, 'config.ts');
-    fs.writeFileSync(configPath, configContent, 'utf-8');
-    console.log(`✅ Created ${path.relative(process.cwd(), configPath)}`);
+// ============================================================================
+// Main
+// ============================================================================
 
-    // Generate .arcten/README.md
-    const readmeContent = `# Arcten Configuration
-
-This directory contains configuration files generated by \`arcten init\`.
-
-## Files
-
-- \`config.ts\` - Project ID and route configuration
-- \`tool-metadata.ts\` - (Optional) Build-time tool metadata
-
-## Usage
-
-Import the config in your application:
-
-\`\`\`typescript
-import { arctenConfig } from './.arcten/config';
-import { useAgent } from '@arcteninc/core';
+async function main() {
+  console.log('');
+  console.log('  ___  ____________ _____ _____ _   _ ');
+  console.log(' / _ \\ | ___ \\ ___ \\_   _|  ___| \\ | |');
+  console.log('/ /_\\ \\| |_/ / |   / | | | |__ |  \\| |');
+  console.log('|  _  ||    /| |   | | | |  __|| . ` |');
+  console.log('| | | || |\\ \\| |__/\\ | | | |___| |\\  |');
+  console.log('\\_| |_/\\_| \\_\\____/  \\_/ \\____/\\_| \\_/');
+  console.log('');
+  console.log('  Setup Wizard');
+  console.log('');
 
-function MyComponent() {
-  const agent = useAgent({
-    projectId: arctenConfig.projectId,
-    agentName: "default",
-    tools: myTools,
+  // Create readline interface
+  rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
   });
 
-  // Use agent.messages, agent.sendMessage, etc.
-}
-\`\`\`
-
-For more information, visit https://arcten.com/docs
-`;
-
-    const readmePath = path.join(arctenDir, 'README.md');
-    fs.writeFileSync(readmePath, readmeContent, 'utf-8');
-    console.log(`✅ Created ${path.relative(process.cwd(), readmePath)}`);
-
-  } catch (error: any) {
-    console.error(`❌ Failed to generate config: ${error.message}`);
-    throw error;
-  }
-}
+  try {
+    // PHASE 1: Deterministic Discovery
+    const context = await discoverContext();
 
-// Main wizard
-async function main() {
-  // Check for flags
-  const args = process.argv.slice(2);
-  const skipAnalysis = args.includes('--skip-analysis');
-  const allowAll = args.includes('--allow-all');
+    // PHASE 2: Deterministic Classification
+    const classification = await classifyTools(context);
 
-  if (allowAll) {
-    console.log('');
-    console.log('╔═══════════════════════════════════════════════╗');
-    console.log('║                                               ║');
-    console.log('║      🔓 Arcten Setup (Allow All) 🔓          ║');
-    console.log('║                                               ║');
-    console.log('╚═══════════════════════════════════════════════╝');
-    console.log('');
-  } else if (skipAnalysis) {
-    console.log('');
-    console.log('╔═══════════════════════════════════════════════╗');
-    console.log('║                                               ║');
-    console.log('║          🔄 Arcten Sync Tools 🔄              ║');
-    console.log('║                                               ║');
-    console.log('╚═══════════════════════════════════════════════╝');
-    console.log('');
-  } else {
-    console.log('');
-    console.log('╔═══════════════════════════════════════════════╗');
-    console.log('║                                               ║');
-    console.log('║          🚀 Arcten Setup Wizard 🚀            ║');
-    console.log('║                                               ║');
-    console.log('╚═══════════════════════════════════════════════╝');
+    // Show classification summary
+    console.log('Classification:');
+    if (classification.safe.length > 0) {
+      console.log(`  Safe: ${classification.safe.slice(0, 5).join(', ')}${classification.safe.length > 5 ? '...' : ''}`);
+    }
+    if (classification.sensitive.length > 0) {
+      console.log(`  Sensitive: ${classification.sensitive.slice(0, 5).join(', ')}${classification.sensitive.length > 5 ? '...' : ''}`);
+    }
     console.log('');
-  }
-
-  const rl = createPrompt();
-  const serverUrl = process.env.ARCTEN_SERVER_URL || 'https://api.arcten.com';
 
-  try {
-    // Check for existing setup
-    const arctenDir = path.join(process.cwd(), '.arcten');
-    const hasExistingSetup = fs.existsSync(arctenDir);
-
-    if (hasExistingSetup && !skipAnalysis && !allowAll) {
-      console.log('⚠️  Arcten is already configured in this project!\n');
-      console.log('📁 Found existing .arcten/ directory\n');
-      console.log('Running init again will:');
-      console.log('  • Overwrite your .arcten/config.ts file');
-      console.log('  • Run AI analysis again (costs money)');
-      console.log('  • Resync all tools to dashboard\n');
-
-      const shouldContinue = await confirm(rl, 'Do you want to continue and reconfigure?');
-
-      if (!shouldContinue) {
-        console.log('\n💡 Tip: To re-sync tools without analysis, use:');
-        console.log('   arcten sync\n');
-        rl.close();
-        process.exit(0);
-      }
+    const classificationOk = await askQuestion('Does this look right? (y/n): ');
+    if (classificationOk.toLowerCase() === 'n') {
+      console.log('');
+      console.log('You can adjust classifications later by editing .arcten/sync-state.json');
+      console.log('and running `arcten sync`.');
       console.log('');
     }
 
-    // Step 1: Authentication
-    const { apiKey, projectId } = await checkApiKey(rl);
-
-    // Step 2: Scan codebase
-    const context = await scanCodebase();
-
-    // Step 2.5: Handle missing descriptions (only in full wizard mode, not sync/allow-all)
-    if (!skipAnalysis && !allowAll) {
-      context.functions = await handleMissingDescriptions(rl, context.functions);
-    }
-
-    // Step 3: Sync all tools to dashboard
-    console.log('\n☁️  Syncing tools to dashboard...\n');
-    const tools: ToolRecommendation[] = context.functions.map(fn => ({
-      name: fn.name,
-      category: 'query' as const,
-      description: fn.jsDoc || `Function: ${fn.name}`,
-      shouldEnable: allowAll, // Enable all in allow-all mode
-      requiresApproval: false,
-      sensitiveParams: [],
-    }));
-
-    await syncToDashboard(apiKey, serverUrl, projectId, tools);
-    console.log(`✅ Synced ${tools.length} tools to dashboard\n`);
-
-    // Step 4: Create agents
-    let agents: AgentConfig[] = [];
-
-    if (skipAnalysis) {
-      // Just create default agent
-      agents = [{
-        name: 'default',
-        systemPrompt: 'You are a helpful assistant.',
-        enabledTools: context.functions.map(f => f.name),
-        description: 'General assistant',
-      }];
-    } else {
-      // Ask user to describe agents
-      console.log('📋 Tools synced. Now let\'s create your agent(s).\n');
-      const agentDescription = await ask(rl,
-        'Describe the agent(s) you want (or press Enter for a default agent):\n> '
-      );
+    // PHASE 3: Placement Menu
+    const placement = await showPlacementMenu();
+    console.log('');
 
-      if (!agentDescription.trim()) {
-        // Default agent
-        agents = [{
-          name: 'default',
-          systemPrompt: 'You are a helpful assistant.',
-          enabledTools: context.functions.map(f => f.name),
-          description: 'General assistant',
-        }];
-      } else {
-        // Generate agents via LLM
-        console.log('\n🤖 Generating agent profiles...\n');
-        agents = await generateAgents(apiKey, serverUrl, agentDescription, context.functions);
-
-        // Show what will be created
-        console.log('🤖 Agents to create:\n');
-        for (const agent of agents) {
-          console.log(`  📌 ${agent.name}: ${agent.description}`);
-          console.log(`     Tools: ${agent.enabledTools.length} of ${context.functions.length}\n`);
-        }
+    const result: InitResult = {
+      context,
+      classification,
+      placement,
+    };
 
-        const confirm = await ask(rl, 'Create these agents? (Y/n): ');
-        if (confirm.toLowerCase() === 'n') {
-          // Fallback to default
-          agents = [{
-            name: 'default',
-            systemPrompt: 'You are a helpful assistant.',
-            enabledTools: context.functions.map(f => f.name),
-            description: 'General assistant',
-          }];
-        }
-      }
-    }
+    // PHASE 4: Deterministic File Creation
+    const createdFiles = await createAllFiles(result);
 
-    // Step 5: Sync agents
-    console.log('\n☁️  Syncing agents to dashboard...\n');
-    await syncToDashboard(apiKey, serverUrl, projectId, tools, agents);
-    console.log(`✅ Synced ${agents.length} agent(s) to dashboard\n`);
+    // PHASE 5: AI Review
+    await aiReviewFiles(result, createdFiles);
 
-    // Step 6: Generate local config
-    await generateLocalConfig(projectId, agents[0].name);
+    // PHASE 6: Run Sync
+    await runSync();
 
-    console.log('\n✅ Setup complete!\n');
-    console.log(`📍 Dashboard: https://arcten.com/dashboard/projects/${projectId}`);
     console.log('');
-
+    console.log('Setup complete!');
+    console.log('');
+    console.log('Run `bun dev` (or `npm run dev`) to start your app.');
+    console.log('');
   } catch (error: any) {
-    console.error('\n❌ Error:', error.message);
+    console.error('Error:', error.message);
     process.exit(1);
   } finally {
     rl.close();
   }
 }
 
-// Run if executed directly
-if (require.main === module) {
-  main().catch((error) => {
-    console.error('Fatal error:', error);
-    process.exit(1);
-  });
-}
+// Run
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});
 
 export { main };