@utopia-ai/cli 0.1.0

package/src/cli/commands/codex.ts

@@ -0,0 +1,193 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+import { loadConfig, configExists } from '../utils/config.js';
+
+interface ContextResponse {
+  count: number;
+  keywords?: string[];
+  probes: Array<{
+    id: string;
+    projectId: string;
+    probeType: string;
+    timestamp: string;
+    file: string;
+    line: number;
+    functionName: string;
+    data: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+  }>;
+}
+
+function formatProbeForContext(probe: ContextResponse['probes'][number]): string {
+  const lines: string[] = [];
+  lines.push(`[${probe.probeType.toUpperCase()}] ${probe.functionName || '(anonymous)'} in ${probe.file}:${probe.line}`);
+  lines.push(`  Timestamp: ${probe.timestamp}`);
+
+  const data = probe.data;
+  switch (probe.probeType) {
+    case 'error':
+      if (data.errorType) lines.push(`  Error: ${data.errorType}: ${data.message}`);
+      if (data.stack) {
+        const stackLines = String(data.stack).split('\n').slice(0, 5);
+        lines.push(`  Stack:\n    ${stackLines.join('\n    ')}`);
+      }
+      if (data.codeLine) lines.push(`  Code: ${data.codeLine}`);
+      break;
+
+    case 'database':
+      if (data.operation) lines.push(`  Operation: ${data.operation}`);
+      if (data.query) lines.push(`  Query: ${String(data.query).slice(0, 200)}`);
+      if (data.duration !== undefined) lines.push(`  Duration: ${data.duration}ms`);
+      if (data.rowCount !== undefined) lines.push(`  Rows: ${data.rowCount}`);
+      break;
+
+    case 'api':
+      if (data.method && data.url) lines.push(`  ${data.method} ${data.url}`);
+      if (data.statusCode !== undefined) lines.push(`  Status: ${data.statusCode}`);
+      if (data.duration !== undefined) lines.push(`  Duration: ${data.duration}ms`);
+      if (data.error) lines.push(`  Error: ${data.error}`);
+      break;
+
+    case 'infra':
+      if (data.provider) lines.push(`  Provider: ${data.provider}`);
+      if (data.region) lines.push(`  Region: ${data.region}`);
+      if (data.serviceType) lines.push(`  Service: ${data.serviceType}`);
+      if (data.memoryUsage !== undefined) lines.push(`  Memory: ${data.memoryUsage}MB`);
+      break;
+
+    case 'function':
+      if (data.duration !== undefined) lines.push(`  Duration: ${data.duration}ms`);
+      if (data.llmContext) lines.push(`  LLM Context: ${String(data.llmContext).slice(0, 300)}`);
+      if (data.args) lines.push(`  Args: ${JSON.stringify(data.args).slice(0, 200)}`);
+      break;
+
+    default: {
+      const dataStr = JSON.stringify(data);
+      if (dataStr.length < 300) {
+        lines.push(`  Data: ${dataStr}`);
+      }
+      break;
+    }
+  }
+
+  return lines.join('\n');
+}
+
+async function fetchProductionContext(
+  endpoint: string,
+  prompt: string,
+): Promise<string | null> {
+  try {
+    const url = new URL('/api/v1/probes/context', endpoint);
+    url.searchParams.set('prompt', prompt);
+    url.searchParams.set('limit', '10');
+
+    const response = await fetch(url.toString(), {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = (await response.json()) as ContextResponse;
+
+    if (data.count === 0) {
+      return null;
+    }
+
+    const sections: string[] = [];
+
+    // Group probes by type
+    const byType: Record<string, ContextResponse['probes']> = {};
+    for (const probe of data.probes) {
+      if (!byType[probe.probeType]) byType[probe.probeType] = [];
+      byType[probe.probeType].push(probe);
+    }
+
+    for (const [type, probes] of Object.entries(byType)) {
+      sections.push(`--- ${type.toUpperCase()} PROBES (${probes.length}) ---`);
+      for (const probe of probes) {
+        sections.push(formatProbeForContext(probe));
+      }
+      sections.push('');
+    }
+
+    return sections.join('\n');
+  } catch {
+    return null;
+  }
+}
+
+export const codexCommand = new Command('codex')
+  .description('Run OpenAI Codex CLI with production context from Utopia')
+  .argument('<prompt...>', 'The prompt to pass to Codex')
+  .action(async (promptParts: string[]) => {
+    const cwd = process.cwd();
+    const prompt = promptParts.join(' ');
+
+    if (!configExists(cwd)) {
+      console.log(chalk.red('\n  Error: No .utopia/config.json found.'));
+      console.log(chalk.dim('  Run "utopia init" first to set up your project.\n'));
+      process.exit(1);
+    }
+
+    const config = await loadConfig(cwd);
+
+    console.log(chalk.bold.cyan('\n  Fetching production context from Utopia...\n'));
+
+    const context = await fetchProductionContext(
+      config.dataEndpoint,
+      prompt,
+    );
+
+    let enrichedPrompt: string;
+
+    if (context) {
+      console.log(chalk.green('  Production context retrieved successfully.'));
+      console.log(chalk.dim('  Enriching prompt with production data...\n'));
+
+      enrichedPrompt = [
+        '[PRODUCTION CONTEXT from Utopia]',
+        context,
+        '[END PRODUCTION CONTEXT]',
+        '',
+        prompt,
+      ].join('\n');
+    } else {
+      console.log(chalk.yellow('  No production context available (service may not be running).'));
+      console.log(chalk.dim('  Passing prompt to Codex without enrichment.\n'));
+      enrichedPrompt = prompt;
+    }
+
+    console.log(chalk.dim('  Launching Codex...\n'));
+
+    const child = spawn('codex', [enrichedPrompt], {
+      stdio: 'inherit',
+      shell: true,
+      cwd,
+      env: {
+        ...process.env,
+        UTOPIA_PROJECT_ID: config.projectId,
+        UTOPIA_ENDPOINT: config.dataEndpoint,
+      },
+    });
+
+    child.on('close', (code) => {
+      process.exit(code ?? 0);
+    });
+
+    child.on('error', (err) => {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        console.log(chalk.red('\n  Error: "codex" command not found.'));
+        console.log(chalk.dim('  Install OpenAI Codex CLI: npm install -g @openai/codex\n'));
+      } else {
+        console.log(chalk.red(`\n  Error: Failed to launch Codex: ${err.message}\n`));
+      }
+      process.exit(1);
+    });
+  });

package/src/cli/commands/context.ts

@@ -0,0 +1,188 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig, configExists } from '../utils/config.js';
+
+interface ProbeResult {
+  id: string;
+  projectId: string;
+  probeType: string;
+  timestamp: string;
+  file: string;
+  line: number;
+  functionName: string;
+  data: Record<string, unknown>;
+  metadata: Record<string, unknown>;
+}
+
+interface ContextResponse {
+  count: number;
+  keywords?: string[];
+  probes: ProbeResult[];
+}
+
+function formatProbe(probe: ProbeResult): string {
+  const lines: string[] = [];
+  const typeColor = getTypeColor(probe.probeType);
+
+  lines.push(`  ${typeColor(probe.probeType.toUpperCase())} ${chalk.white(probe.functionName || '(anonymous)')} ${chalk.dim(`in ${probe.file}:${probe.line}`)}`);
+  lines.push(chalk.dim(`    ${probe.timestamp}`));
+
+  // Format data based on probe type
+  const data = probe.data;
+  switch (probe.probeType) {
+    case 'error':
+      if (data.errorType) lines.push(chalk.red(`    ${data.errorType}: ${data.message}`));
+      if (data.stack) {
+        const stackLines = String(data.stack).split('\n').slice(0, 3);
+        for (const sl of stackLines) {
+          lines.push(chalk.dim(`    ${sl.trim()}`));
+        }
+      }
+      break;
+
+    case 'database':
+      if (data.operation) lines.push(`    Operation: ${chalk.cyan(String(data.operation))}`);
+      if (data.query) lines.push(chalk.dim(`    Query: ${String(data.query).slice(0, 120)}`));
+      if (data.duration !== undefined) lines.push(chalk.dim(`    Duration: ${data.duration}ms`));
+      break;
+
+    case 'api':
+      if (data.method && data.url) {
+        lines.push(`    ${chalk.cyan(String(data.method))} ${String(data.url)}`);
+      }
+      if (data.statusCode !== undefined) {
+        const statusNum = Number(data.statusCode);
+        const statusStr = String(data.statusCode);
+        const statusColor = statusNum >= 400 ? chalk.red : statusNum >= 300 ? chalk.yellow : chalk.green;
+        lines.push(`    Status: ${statusColor(statusStr)}`);
+      }
+      if (data.duration !== undefined) lines.push(chalk.dim(`    Duration: ${data.duration}ms`));
+      break;
+
+    case 'infra':
+      if (data.provider) lines.push(`    Provider: ${chalk.cyan(String(data.provider))}`);
+      if (data.region) lines.push(`    Region: ${chalk.cyan(String(data.region))}`);
+      if (data.memoryUsage !== undefined) lines.push(chalk.dim(`    Memory: ${data.memoryUsage}MB`));
+      break;
+
+    case 'function':
+      if (data.duration !== undefined) lines.push(chalk.dim(`    Duration: ${data.duration}ms`));
+      if (data.llmContext) lines.push(chalk.magenta(`    Context: ${String(data.llmContext).slice(0, 200)}`));
+      break;
+
+    default: {
+      const dataStr = JSON.stringify(data, null, 2);
+      if (dataStr.length < 200) {
+        lines.push(chalk.dim(`    ${dataStr}`));
+      }
+      break;
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function getTypeColor(type: string): (s: string) => string {
+  switch (type) {
+    case 'error': return chalk.bgRed.white;
+    case 'database': return chalk.bgBlue.white;
+    case 'api': return chalk.bgGreen.white;
+    case 'infra': return chalk.bgYellow.black;
+    case 'function': return chalk.bgMagenta.white;
+    default: return chalk.bgGray.white;
+  }
+}
+
+export const contextCommand = new Command('context')
+  .description('Query production context from the Utopia data service')
+  .argument('<prompt>', 'The context query')
+  .option('--file <file>', 'Focus on a specific file')
+  .option('--type <type>', 'Filter by probe type (error, database, api, infra, function)')
+  .option('--limit <n>', 'Maximum number of results', '20')
+  .action(async (prompt: string, options) => {
+    const cwd = process.cwd();
+
+    if (!configExists(cwd)) {
+      console.log(chalk.red('\n  Error: No .utopia/config.json found.'));
+      console.log(chalk.dim('  Run "utopia init" first to set up your project.\n'));
+      process.exit(1);
+    }
+
+    const config = await loadConfig(cwd);
+    const endpoint = config.dataEndpoint;
+
+    console.log(chalk.bold.cyan('\n  Querying production context...\n'));
+    console.log(chalk.dim(`  Query: "${prompt}"`));
+
+    // Build query URL
+    const url = new URL('/api/v1/probes/context', endpoint);
+    url.searchParams.set('prompt', prompt);
+    url.searchParams.set('limit', options.limit as string);
+
+    if (options.file) {
+      // If filtering by file, also do a direct probes query
+      url.searchParams.set('file', options.file as string);
+    }
+
+    try {
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text();
+        console.log(chalk.red(`\n  Error: Data service returned ${response.status}`));
+        console.log(chalk.dim(`  ${errorBody}\n`));
+        process.exit(1);
+      }
+
+      const data = (await response.json()) as ContextResponse;
+
+      if (data.keywords && data.keywords.length > 0) {
+        console.log(chalk.dim(`  Keywords: ${data.keywords.join(', ')}`));
+      }
+      console.log(chalk.dim(`  Results: ${data.count}\n`));
+
+      if (data.count === 0) {
+        console.log(chalk.yellow('  No matching probes found.'));
+        console.log(chalk.dim('  Try a broader query or check that probes are being collected.\n'));
+        return;
+      }
+
+      // Filter by type if specified
+      let probes = data.probes;
+      if (options.type) {
+        probes = probes.filter((p) => p.probeType === options.type);
+        if (probes.length === 0) {
+          console.log(chalk.yellow(`  No probes of type "${options.type}" found in results.\n`));
+          return;
+        }
+      }
+
+      // Filter by file if specified (server may not support file param in context endpoint)
+      if (options.file) {
+        const fileFilter = options.file as string;
+        probes = probes.filter((p) => p.file.includes(fileFilter));
+      }
+
+      for (const probe of probes) {
+        console.log(formatProbe(probe));
+        console.log('');
+      }
+
+      console.log(chalk.dim(`  Showing ${probes.length} of ${data.count} results.\n`));
+    } catch (err) {
+      const errorMessage = (err as Error).message;
+      if (errorMessage.includes('ECONNREFUSED') || errorMessage.includes('fetch failed')) {
+        console.log(chalk.red('\n  Error: Could not connect to the Utopia data service.'));
+        console.log(chalk.dim(`  Endpoint: ${endpoint}`));
+        console.log(chalk.dim('  Make sure the service is running: utopia serve\n'));
+      } else {
+        console.log(chalk.red(`\n  Error: ${errorMessage}\n`));
+      }
+      process.exit(1);
+    }
+  });

package/src/cli/commands/destruct.ts

@@ -0,0 +1,237 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { resolve } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync, rmSync } from 'node:fs';
+import { configExists } from '../utils/config.js';
+
+const SNAPSHOT_DIR = '.utopia/snapshots';
+
+/**
+ * Collect all snapshot files with their relative paths.
+ */
+function collectSnapshots(snapshotBase: string): { rel: string; snapPath: string }[] {
+  const results: { rel: string; snapPath: string }[] = [];
+
+  function walk(dir: string): void {
+    let entries: string[];
+    try { entries = readdirSync(dir); } catch { return; }
+    for (const entry of entries) {
+      const full = resolve(dir, entry);
+      try {
+        const st = statSync(full);
+        if (st.isDirectory()) {
+          walk(full);
+        } else if (st.isFile()) {
+          const rel = full.substring(snapshotBase.length + 1);
+          results.push({ rel, snapPath: full });
+        }
+      } catch { /* skip */ }
+    }
+  }
+
+  walk(snapshotBase);
+  return results;
+}
+
+/**
+ * Apply the user's post-instrument changes on top of the snapshot.
+ *
+ * Strategy:
+ *   1. Take the snapshot (original pre-probe file)
+ *   2. Take the current file (has probes + maybe user changes)
+ *   3. Remove probe blocks from the current file
+ *   4. Diff the stripped-current vs snapshot — the diff is the user's changes
+ *   5. Return the snapshot if no user changes, or the stripped-current if there are user changes
+ *
+ * "Probe block" = a `// utopia:probe` (or `# utopia:probe`) comment followed by
+ * its try/catch (or try/except) block, plus any `__utopia_start` timing line above,
+ * plus the utopia import if no other probes remain.
+ */
+function stripProbesFromContent(content: string, isPython: boolean): string {
+  const marker = isPython ? '# utopia:probe' : '// utopia:probe';
+  const lines = content.split('\n');
+  const linesToRemove = new Set<number>();
+
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() !== marker) continue;
+    linesToRemove.add(i);
+
+    // Check for __utopia_start timing line above
+    let above = i - 1;
+    while (above >= 0 && lines[above].trim() === '') above--;
+    if (above >= 0 && (lines[above].trim().startsWith('const __utopia_start') || lines[above].trim().startsWith('_utopia_start'))) {
+      linesToRemove.add(above);
+    }
+
+    // Remove the try block that follows
+    let j = i + 1;
+    while (j < lines.length && lines[j].trim() === '') j++;
+
+    if (isPython) {
+      // Python: try: ... except ...: pass
+      if (j < lines.length && lines[j].trim().startsWith('try:')) {
+        const tryIndent = lines[j].length - lines[j].trimStart().length;
+        linesToRemove.add(j);
+        let k = j + 1;
+        while (k < lines.length) {
+          const line = lines[k];
+          if (line.trim() === '') { linesToRemove.add(k); k++; continue; }
+          const indent = line.length - line.trimStart().length;
+          if (indent <= tryIndent && line.trim() !== '') {
+            if (line.trim().startsWith('except')) {
+              linesToRemove.add(k);
+              k++;
+              while (k < lines.length) {
+                const eline = lines[k];
+                if (eline.trim() === '') { linesToRemove.add(k); k++; continue; }
+                if ((eline.length - eline.trimStart().length) <= tryIndent) break;
+                linesToRemove.add(k); k++;
+              }
+              break;
+            }
+            break;
+          }
+          linesToRemove.add(k); k++;
+        }
+      }
+    } else {
+      // JS/TS: try { ... } catch { ... }
+      if (j < lines.length && lines[j].trim().startsWith('try {')) {
+        let braceDepth = 0;
+        let inCatch = false;
+        for (let k = j; k < lines.length; k++) {
+          for (const ch of lines[k]) {
+            if (ch === '{') braceDepth++;
+            if (ch === '}') braceDepth--;
+          }
+          linesToRemove.add(k);
+          if (lines[k].includes('catch')) inCatch = true;
+          if (braceDepth === 0 && (inCatch || k > j)) break;
+        }
+      }
+    }
+  }
+
+  let result = lines.filter((_line, idx) => !linesToRemove.has(idx)).join('\n');
+
+  // Remove utopia import if no probes remain
+  if (isPython) {
+    if (!result.includes('utopia_runtime.report')) {
+      result = result.replace(/^import utopia_runtime\s*\n?/gm, '');
+    }
+  } else {
+    if (!result.includes('__utopia.report') && !result.includes('__utopia.init')) {
+      result = result.replace(/import\s*\{[^}]*__utopia[^}]*\}\s*from\s*['"]utopia-runtime['"];?\s*\n?/g, '');
+    }
+  }
+
+  // Remove leftover timing vars
+  result = result.replace(/^\s*const\s+__utopia_start\s*=\s*Date\.now\(\);?\s*\n/gm, '');
+  result = result.replace(/^\s*_utopia_start\s*=\s*time\.time\(\)\s*\n/gm, '');
+
+  // Clean up consecutive blank lines
+  result = result.replace(/\n{3,}/g, '\n\n');
+  result = result.replace(/[ \t]+$/gm, '');
+
+  return result;
+}
+
+export const destructCommand = new Command('destruct')
+  .description('Remove all Utopia probes from the codebase')
+  .option('--dry-run', 'Show what would be restored without changing files', false)
+  .action(async (options) => {
+    const cwd = process.cwd();
+
+    if (!configExists(cwd)) {
+      console.log(chalk.red('\n  Error: No .utopia/config.json found.\n'));
+      process.exit(1);
+    }
+
+    const snapshotBase = resolve(cwd, SNAPSHOT_DIR);
+
+    if (!existsSync(snapshotBase)) {
+      console.log(chalk.yellow('\n  No snapshots found. Nothing to restore.'));
+      console.log(chalk.dim('  Snapshots are created when you run "utopia instrument" or "utopia reinstrument".\n'));
+      return;
+    }
+
+    const snapshots = collectSnapshots(snapshotBase);
+
+    if (snapshots.length === 0) {
+      console.log(chalk.yellow('\n  No snapshots found. Nothing to restore.\n'));
+      return;
+    }
+
+    console.log(chalk.bold.cyan('\n  Utopia Destruct\n'));
+
+    if (options.dryRun) {
+      console.log(chalk.yellow('  Dry run — no files will be modified.\n'));
+    }
+
+    console.log(chalk.dim(`  Found ${snapshots.length} file snapshot(s)\n`));
+
+    let restored = 0;
+    let merged = 0;
+    let skipped = 0;
+
+    for (const { rel, snapPath } of snapshots) {
+      const targetPath = resolve(cwd, rel);
+
+      if (!existsSync(targetPath)) { skipped++; continue; }
+
+      const snapshot = readFileSync(snapPath, 'utf-8');
+      const current = readFileSync(targetPath, 'utf-8');
+
+      if (current === snapshot) { skipped++; continue; }
+
+      // Check if the file has user changes beyond probes
+      const isPython = rel.endsWith('.py');
+      const strippedCurrent = stripProbesFromContent(current, isPython);
+
+      // Normalize whitespace for comparison — Claude Code may reformat slightly
+      const normalize = (s: string) => s.replace(/\s+/g, ' ').trim();
+
+      // If stripped current matches snapshot (ignoring whitespace), no user changes — restore exactly
+      if (normalize(strippedCurrent) === normalize(snapshot)) {
+        if (options.dryRun) {
+          console.log(chalk.dim(`  [dry-run] Restore: ${rel}`));
+        } else {
+          writeFileSync(targetPath, snapshot);
+          console.log(chalk.green(`  Restored: ${rel}`));
+        }
+        restored++;
+      } else {
+        // File has user changes + probes — strip probes, keep user changes
+        if (options.dryRun) {
+          console.log(chalk.dim(`  [dry-run] Strip probes (user changes preserved): ${rel}`));
+        } else {
+          writeFileSync(targetPath, strippedCurrent);
+          console.log(chalk.yellow(`  Stripped probes (user changes preserved): ${rel}`));
+        }
+        merged++;
+      }
+    }
+
+    console.log('');
+    if (options.dryRun) {
+      console.log(chalk.yellow(`  Would restore ${restored}, strip ${merged}, skip ${skipped} file(s).\n`));
+    } else {
+      try {
+        rmSync(snapshotBase, { recursive: true, force: true });
+      } catch { /* ignore */ }
+
+      // Clean up copied Python runtime if it exists
+      const pythonRuntimeDir = resolve(cwd, 'utopia_runtime');
+      if (existsSync(pythonRuntimeDir)) {
+        try {
+          rmSync(pythonRuntimeDir, { recursive: true, force: true });
+          console.log(chalk.dim('  Removed utopia_runtime/ directory.'));
+        } catch { /* ignore */ }
+      }
+
+      if (restored > 0) console.log(chalk.bold.green(`  ${restored} file(s) restored to exact pre-instrument state.`));
+      if (merged > 0) console.log(chalk.yellow(`  ${merged} file(s) had user changes — probes stripped, your changes preserved.`));
+      if (skipped > 0) console.log(chalk.dim(`  ${skipped} file(s) unchanged.`));
+      console.log('');
+    }
+  });