ccraft 1.0.11 → 1.0.13

package/src/commands/create.js

@@ -1,568 +0,0 @@
-import { resolve, join, basename } from 'path';
-import { mkdirSync, existsSync, writeFileSync, readdirSync } from 'fs';
-import { execFileSync } from 'child_process';
-import chalk from 'chalk';
-import ora from 'ora';
-import { gatherCreateProfile, gatherPersona, gatherUserProfile, gatherMcpConfig, confirmInstallation } from '../prompts/gather.js';
-import { themedInput } from '../ui/prompts.js';
-import { callGenerate, ApiError } from '../utils/api-client.js';
-import { runPreflight } from '../utils/preflight.js';
-import { writeApiFiles, buildFileList } from '../utils/api-file-writer.js';
-import { setupMcps } from '../utils/mcp-setup.js';
-import { scoreWithClaude } from '../utils/claude-scorer.js';
-import { optimizeSettings } from '../utils/claude-optimizer.js';
-import { rewriteClaudeMd } from '../utils/claude-rewriter.js';
-import { detectProject } from '../utils/detect-project.js';
-import { analyzeWithClaude } from '../utils/claude-analyzer.js';
-import { analyzeDescription } from '../utils/description-analyzer.js';
-import { platformCmd } from '../utils/run-claude.js';
-import { runBootstrap } from '../utils/bootstrap-runner.js';
-import {
-  writeAnalysisCache,
-  writeUserProfile,
-  updateManifest,
-  readAnalysisCache,
-  promoteCache,
-  cleanupAnalysisCache,
-} from '../utils/analysis-cache.js';
-import { VERSION, VIBE_DEFAULTS } from '../constants.js';
-import * as logger from '../utils/logger.js';
-
-// UI modules
-import { renderBanner } from '../ui/brand.js';
-import { renderComponentBreakdown, renderMcpStatus, renderFileResults } from '../ui/tables.js';
-import { renderSuccessCard } from '../ui/cards.js';
-import { runInstallTasks, runVerifyTasks, runFinalizeTasks } from '../ui/tasks.js';
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function renderCreatePhase(number, name, totalPhases) {
-  const w = Math.min((process.stdout.columns || 80) - 4, 56);
-  const label = `Phase ${number} of ${totalPhases}`;
-  const inner = ` ${label} \u2500\u2500 ${name} `;
-  const tailLen = Math.max(2, w - inner.length - 2);
-  console.log();
-  console.log(chalk.bold.cyan(`  \u2500\u2500${inner}${'\u2500'.repeat(tailLen)}`));
-  console.log();
-}
-
-function countTotalItems(summary, selectedCandidateIds) {
-  const countBucket = (bucket) => {
-    if (!bucket) return 0;
-    return Object.values(bucket).reduce(
-      (sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0),
-      0,
-    );
-  };
-  let total = countBucket(summary.guaranteed);
-  if (selectedCandidateIds === null) {
-    total += countBucket(summary.candidates);
-  } else {
-    total += selectedCandidateIds.length;
-  }
-  return total;
-}
-
-// ── Main command ─────────────────────────────────────────────────────────────
-
-/**
- * Create command — build a new project from scratch.
- *
- * Step 1: Welcome & Setup (env check + API key)
- * Step 2: Project Setup (name, description, mkdir, git init)
- * Step 3: Configuration & Install (synthetic analysis → server → write .claude/)
- * Step 4: Bootstrap (hand off to Claude CLI /bootstrap:auto)
- * Step 5: Post-bootstrap Sync (re-analyze, rewrite CLAUDE.md, finalize)
- */
-export async function runCreate(options = {}) {
-  const TOTAL_PHASES = 5;
-  let targetDir;
-
-  try {
-    // ================================================================
-    // STEP 1: Welcome & Setup
-    // ================================================================
-    renderBanner(VERSION);
-    renderCreatePhase(1, 'Welcome & Setup', TOTAL_PHASES);
-
-    // ── Pre-flight checks (Claude Code + API key + server) ──────
-    await runPreflight({
-      interactive: !options.yes,
-      requireClaude: true,
-    });
-
-    // ================================================================
-    // STEP 2: Project Setup
-    // ================================================================
-    renderCreatePhase(2, 'Project Setup', TOTAL_PHASES);
-
-    let createProfile;
-    if (options.yes) {
-      createProfile = {
-        name: options.name || 'my-project',
-        description: options.description || 'A new project',
-        projectType: 'monolith',
-      };
-      logger.info(`Non-interactive mode — creating ${chalk.bold(createProfile.name)} (monolith).`);
-    } else {
-      createProfile = await gatherCreateProfile();
-    }
-
-    let { name, description, projectType } = createProfile;
-
-    // Resolve target directory
-    const parentDir = resolve(options.dir || process.cwd());
-    let useCurrentDir = false;
-
-    if (!name) {
-      // Empty name = use current directory — must be empty
-      targetDir = parentDir;
-      useCurrentDir = true;
-      const contents = readdirSync(targetDir).filter((f) => f !== '.git');
-      if (contents.length > 0) {
-        logger.error(`Current directory ${chalk.bold(targetDir)} is not empty. Cannot create a project here.`);
-        process.exit(1);
-      }
-      name = basename(targetDir) || 'my-project';
-    } else {
-      // Named project — re-prompt if directory already exists
-      targetDir = join(parentDir, name);
-      while (existsSync(targetDir)) {
-        logger.warn(`Directory ${chalk.bold(name)} already exists.`);
-        const newName = await themedInput({
-          message: 'Enter a different project name:',
-          hint: 'Letters, numbers, dots, hyphens, underscores only.',
-          validate: (v) => {
-            const t = v.trim();
-            if (!t) return 'Name is required.';
-            if (!/^[a-zA-Z0-9._-]+$/.test(t)) return 'Only letters, numbers, dots, hyphens, and underscores allowed.';
-            return true;
-          },
-        });
-        name = newName.trim();
-        targetDir = join(parentDir, name);
-      }
-    }
-
-    // Create directory + git init
-    const spinner1 = ora(useCurrentDir ? 'Initializing project in current directory...' : 'Creating project directory...').start();
-    if (!useCurrentDir) {
-      mkdirSync(targetDir, { recursive: true });
-    }
-
-    // Write a minimal .gitignore
-    writeFileSync(
-      join(targetDir, '.gitignore'),
-      'node_modules/\ndist/\nbuild/\n.env\n.env.*\n!.env.example\n*.log\n.DS_Store\nThumbs.db\n',
-      'utf8',
-    );
-
-    // git init
-    try {
-      const { file, args } = platformCmd('git', ['init']);
-      execFileSync(file, args, { cwd: targetDir, stdio: 'pipe', windowsHide: true });
-      spinner1.succeed(useCurrentDir
-        ? `Initialized project in ${chalk.bold(targetDir)} with git.`
-        : `Created ${chalk.bold(name)}/ with git initialized.`);
-    } catch {
-      spinner1.succeed(useCurrentDir
-        ? `Initialized project in ${chalk.bold(targetDir)} (git init skipped — git not available).`
-        : `Created ${chalk.bold(name)}/ (git init skipped — git not available).`);
-    }
-
-    // ── Persona selection ────────────────────────────────────────────
-    let persona;
-    if (options.yes) {
-      persona = 'developer'; // non-interactive: always developer defaults
-    } else if (options.pro) {
-      persona = 'developer'; // interactive developer mode: skip persona prompt
-    } else {
-      persona = await gatherPersona();
-    }
-
-    const isVibe = persona === 'vibe';
-
-    // Build user profile
-    let userProfile;
-    if (options.yes) {
-      userProfile = {
-        intents: ['implementing', 'debugging', 'refactoring', 'testing', 'reviewing'],
-        sourceControl: 'github',
-        documentTools: [],
-      };
-      logger.info('Non-interactive mode — using default profile.');
-    } else if (isVibe) {
-      userProfile = { ...VIBE_DEFAULTS };
-      logger.info('Vibe mode — using streamlined defaults.');
-    } else {
-      userProfile = await gatherUserProfile();
-    }
-    userProfile.persona = persona;
-
-    // ================================================================
-    // STEP 3: Configuration & Install
-    // ================================================================
-    renderCreatePhase(3, 'Configuration', TOTAL_PHASES);
-
-    // Analyze description with Claude to infer tech stack
-    let descAnalysis = null;
-    {
-      const spinnerAnalyze = ora('Analyzing your requirements...').start();
-      const { analysis, failReason } = await analyzeDescription(description, projectType);
-      if (analysis) {
-        descAnalysis = analysis;
-        const parts = [];
-        if (analysis.frameworks.length) parts.push(analysis.frameworks.join(', '));
-        if (analysis.languages.length) parts.push(analysis.languages.join(', '));
-        if (analysis.databases.length) parts.push(analysis.databases.join(', '));
-        spinnerAnalyze.succeed(
-          parts.length
-            ? `Detected stack: ${chalk.bold(parts.join(' + '))}`
-            : 'Requirements analyzed.',
-        );
-      } else {
-        spinnerAnalyze.info(`Stack inference skipped${failReason ? ` (${failReason})` : ''} — using defaults.`);
-      }
-    }
-
-    // Build project info — enriched with description analysis if available
-    const syntheticProjectInfo = {
-      name,
-      description,
-      projectType,
-      languages: descAnalysis?.languages?.length ? descAnalysis.languages : [],
-      frameworks: descAnalysis?.frameworks?.length ? descAnalysis.frameworks : [],
-      codeStyle: descAnalysis?.codeStyle?.length ? descAnalysis.codeStyle : [],
-      cicd: descAnalysis?.cicd?.length ? descAnalysis.cicd : [],
-      subprojects: descAnalysis?.subprojects?.length ? descAnalysis.subprojects : [],
-      architecture: descAnalysis?.architecture || '',
-      buildCommands: descAnalysis?.buildCommands || {},
-      complexity: descAnalysis?.complexity ?? 0.3,
-      metrics: descAnalysis?.metrics || null,
-      entryPoints: descAnalysis?.entryPoints || [],
-      coreModules: descAnalysis?.coreModules || [],
-      testFramework: descAnalysis?.testFramework || '',
-      packageManager: descAnalysis?.packageManager || '',
-      languageDistribution: descAnalysis?.languageDistribution || null,
-    };
-
-    const syntheticDetected = {
-      ...syntheticProjectInfo,
-      sensitiveFiles: { found: [], gitignoreCovers: true },
-      _rootFiles: [],
-      databases: descAnalysis?.databases?.length ? descAnalysis.databases : [],
-    };
-
-    // Call server
-    const spinner3 = ora('Calling claude-craft server...').start();
-
-    let apiResponse;
-    try {
-      apiResponse = await callGenerate(
-        userProfile,
-        {
-          ...syntheticProjectInfo,
-          detectedFiles: [],
-          databases: syntheticDetected.databases,
-        },
-        { projectPath: targetDir },
-      );
-      spinner3.succeed('Server returned configuration.');
-    } catch (err) {
-      spinner3.fail('Server request failed.');
-      if (err instanceof ApiError) {
-        logger.error(err.message);
-        process.exit(1);
-      }
-      throw err;
-    }
-
-    const { summary, mcpConfigs } = apiResponse;
-
-    // Validate we got components
-    const guaranteedCount = summary?.guaranteed
-      ? Object.values(summary.guaranteed).reduce((s, arr) => s + (Array.isArray(arr) ? arr.length : 0), 0)
-      : 0;
-
-    if (guaranteedCount === 0) {
-      logger.warn('Server returned zero guaranteed components. Continuing with core defaults.');
-    }
-
-    // Display scoring summary
-    console.log();
-    renderComponentBreakdown(summary);
-
-    // MCP selection — auto-select core/role/stack for new projects (no stack to score against)
-    let selectedMcps;
-    let mcpKeys = {};
-    const securityConfig = { addSecurityGitignore: true };
-
-    if (options.yes || isVibe) {
-      selectedMcps = mcpConfigs.filter(
-        (m) => m.tier === 'core' || m.tier === 'role' || m.tier === 'stack' || m.tier === 'auto' || m.recommended,
-      );
-    } else {
-      const mcpResult = await gatherMcpConfig(mcpConfigs);
-      selectedMcps = mcpResult.selectedMcps;
-      mcpKeys = mcpResult.mcpKeys;
-
-      const finalSummary = { ...summary, mcps: selectedMcps.map((m) => ({ id: m.id, tier: m.tier })) };
-      const proceed = await confirmInstallation(finalSummary);
-      if (!proceed) {
-        console.log();
-        logger.info('Cancelled.');
-        process.exit(0);
-      }
-    }
-
-    // Cache analysis and profile
-    try {
-      writeAnalysisCache(targetDir, syntheticProjectInfo, syntheticDetected, null);
-      writeUserProfile(targetDir, userProfile);
-    } catch (cacheErr) {
-      logger.debug(`Analysis cache write failed: ${cacheErr.message}`);
-    }
-
-    // Write files
-    let results;
-    let filesToWrite;
-    let selectedCandidateIds = null;
-
-    try {
-      const installCtx = await runInstallTasks({
-        apiResponse,
-        selectedCandidateIds: null,
-        targetDir,
-        selectedMcps,
-        mcpKeys,
-        securityConfig,
-        detected: syntheticDetected,
-        buildFileList,
-        writeApiFiles,
-        scoreWithClaude,
-      });
-
-      results = installCtx.results;
-      filesToWrite = installCtx.filesToWrite;
-      selectedCandidateIds = installCtx.selectedCandidateIds ?? null;
-    } catch {
-      // Fallback to direct write
-      const spinnerWrite = ora('Writing configuration files...').start();
-      filesToWrite = buildFileList(apiResponse, null);
-      results = await writeApiFiles(filesToWrite, targetDir, {
-        force: true,
-        selectedMcpIds: selectedMcps.map((m) => m.id),
-        mcpKeys,
-        securityConfig,
-        detected: syntheticDetected,
-      });
-      spinnerWrite.succeed('Configuration generated.');
-    }
-
-    // Update manifest
-    try {
-      if (filesToWrite) updateManifest(targetDir, results, filesToWrite);
-    } catch (cacheErr) {
-      logger.debug(`Manifest update failed: ${cacheErr.message}`);
-    }
-
-    // Display file results
-    renderFileResults(results);
-
-    // MCP verification
-    let mcpResults = [];
-    if (selectedMcps.length > 0) {
-      console.log();
-      try {
-        const verifyCtx = await runVerifyTasks(selectedMcps, mcpKeys, { setupMcps, targetDir });
-        mcpResults = verifyCtx.mcpResults;
-      } catch {
-        const spinnerMcp = ora('Verifying MCP servers...').start();
-        mcpResults = await setupMcps(selectedMcps, mcpKeys, {
-          healthCheck: true,
-          targetDir,
-          onStatus: (id, status) => {
-            if (status === 'verifying') spinnerMcp.text = `Verifying ${id}...`;
-            else if (status === 'testing') spinnerMcp.text = `Health-checking ${id}...`;
-          },
-        });
-        spinnerMcp.succeed('MCP verification complete.');
-      }
-
-      renderMcpStatus(mcpResults);
-    }
-
-    // ================================================================
-    // STEP 4: Bootstrap
-    // ================================================================
-    renderCreatePhase(4, 'Bootstrap', TOTAL_PHASES);
-
-    console.log(chalk.dim('  Handing off to Claude to scaffold your project...'));
-    console.log(chalk.dim('  This may take several minutes. Activity log:'));
-    console.log();
-
-    let bootstrapSucceeded = true;
-    try {
-      await runBootstrap(targetDir, description);
-    } catch (err) {
-      bootstrapSucceeded = false;
-      console.log();
-      logger.warn('Bootstrap did not complete: ' + err.message);
-      logger.info('Your .claude/ configuration is still intact. You can run /bootstrap:auto manually inside the project.');
-      console.log();
-    }
-
-    // ================================================================
-    // STEP 5: Post-Bootstrap Sync
-    // ================================================================
-    renderCreatePhase(5, 'Finalization', TOTAL_PHASES);
-
-    if (bootstrapSucceeded) {
-      // Re-analyze the now-real project
-      try {
-        const spinner5 = ora('Re-analyzing project...').start();
-        const fsDetected = await detectProject(targetDir);
-
-        let projectInfo;
-        try {
-          const { analysis } = await analyzeWithClaude(targetDir);
-          if (analysis) {
-            projectInfo = {
-              name: analysis.name || fsDetected.name || name,
-              description: analysis.description || fsDetected.description || description,
-              projectType: analysis.projectType || fsDetected.projectType || projectType,
-              languages: analysis.languages?.length ? analysis.languages : fsDetected.languages,
-              frameworks: analysis.frameworks?.length ? analysis.frameworks : fsDetected.frameworks,
-              codeStyle: analysis.codeStyle?.length ? analysis.codeStyle : fsDetected.codeStyle,
-              cicd: analysis.cicd?.length ? analysis.cicd : fsDetected.cicd,
-              subprojects: analysis.subprojects?.length ? analysis.subprojects : fsDetected.subprojects,
-              architecture: analysis.architecture || '',
-              buildCommands: analysis.buildCommands || {},
-              complexity: analysis.complexity ?? 0.5,
-              metrics: analysis.metrics || null,
-              entryPoints: analysis.entryPoints || [],
-              coreModules: analysis.coreModules || [],
-              testFramework: analysis.testFramework || '',
-              packageManager: analysis.packageManager || fsDetected.packageManager || '',
-              languageDistribution: analysis.languageDistribution || fsDetected.languageDistribution || null,
-            };
-          } else {
-            projectInfo = buildProjectInfoFromFs(fsDetected, name, description, projectType);
-          }
-        } catch {
-          projectInfo = buildProjectInfoFromFs(fsDetected, name, description, projectType);
-        }
-
-        spinner5.succeed('Project re-analyzed.');
-
-        // Overwrite cache with real data
-        const detected = { ...fsDetected, ...projectInfo };
-        writeAnalysisCache(targetDir, projectInfo, detected, null);
-        writeUserProfile(targetDir, userProfile);
-      } catch (err) {
-        logger.debug(`Post-bootstrap analysis failed: ${err.message}`);
-      }
-    }
-
-    // Finalize — optimize settings + rewrite CLAUDE.md
-    try {
-      await runFinalizeTasks({
-        targetDir,
-        readAnalysisCache,
-        optimizeSettings,
-        rewriteClaudeMd,
-      });
-    } catch {
-      // Fallback to sequential
-      const spinnerOpt = ora('Optimizing settings...').start();
-      const optResult = optimizeSettings(targetDir);
-      if (optResult.status === 'ok' && optResult.applied > 0) {
-        spinnerOpt.succeed(`Optimized ${optResult.applied} setting(s).`);
-      } else {
-        spinnerOpt.succeed('Settings reviewed \u2014 no changes needed.');
-      }
-
-      const spinnerMd = ora('Rewriting CLAUDE.md...').start();
-      const cache = readAnalysisCache(targetDir);
-      const rewritten = await rewriteClaudeMd(targetDir, cache);
-      if (rewritten) {
-        spinnerMd.succeed('CLAUDE.md rewritten.');
-      } else {
-        spinnerMd.warn('CLAUDE.md rewrite skipped \u2014 using template version.');
-      }
-    }
-
-    // ── Success ──────────────────────────────────────────────────────
-    const totalItems = countTotalItems(summary, selectedCandidateIds);
-    const mcpsNeedingKeys = mcpResults.filter((r) => r.status === 'needs-key');
-
-    renderSuccessCard({
-      totalItems,
-      mcpCount: selectedMcps.length,
-      mcpsNeedingKeys,
-      persona,
-    });
-
-    console.log();
-    if (bootstrapSucceeded) {
-      logger.success(isVibe
-        ? `Project ${chalk.bold(name)} is ready! Start Claude and describe what you want.`
-        : `Project ${chalk.bold(name)} created and bootstrapped!`);
-      console.log(chalk.dim(`  cd ${name} && claude`));
-    } else {
-      logger.success(isVibe
-        ? `Project ${chalk.bold(name)} is ready! Run Claude to finish setup.`
-        : `Project ${chalk.bold(name)} created with Claude configuration.`);
-      console.log(chalk.dim(`  cd ${name} && claude -p "/bootstrap:auto ${description}"`));
-    }
-    console.log();
-  } catch (err) {
-    if (
-      err &&
-      (err.name === 'ExitPromptError' ||
-        err.constructor?.name === 'ExitPromptError' ||
-        err.message?.includes('User force closed'))
-    ) {
-      console.log();
-      logger.info('Cancelled.');
-      process.exit(0);
-    }
-
-    console.log();
-    logger.error(err.message || String(err));
-    process.exit(1);
-  } finally {
-    if (targetDir) {
-      try {
-        promoteCache(targetDir);
-        cleanupAnalysisCache(targetDir);
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  }
-}
-
-// ── Helper: build projectInfo from filesystem detection only ─────────────────
-
-function buildProjectInfoFromFs(fsDetected, name, description, projectType) {
-  return {
-    name: fsDetected.name || name,
-    description: fsDetected.description || description,
-    projectType: fsDetected.projectType || projectType,
-    languages: fsDetected.languages?.length ? fsDetected.languages : [],
-    frameworks: fsDetected.frameworks || [],
-    codeStyle: fsDetected.codeStyle || [],
-    cicd: fsDetected.cicd || [],
-    subprojects: fsDetected.subprojects || [],
-    architecture: '',
-    buildCommands: {},
-    complexity: 0.5,
-    metrics: null,
-    entryPoints: [],
-    coreModules: [],
-    testFramework: '',
-    packageManager: fsDetected.packageManager || '',
-    languageDistribution: fsDetected.languageDistribution || null,
-  };
-}

package/src/utils/claude-scorer.js

@@ -1,101 +0,0 @@
-/**
- * Claude-powered scoring for optional candidates.
- *
- * Uses the local Claude CLI to evaluate which optional candidates
- * should be included in the configuration.
- */
-import { isClaudeAvailable, runClaude } from './run-claude.js';
-import { extractJsonObject } from './json-extract.js';
-import * as logger from './logger.js';
-
-/**
- * Score optional candidates using Claude.
- *
- * @param {string} scoringPrompt - Prompt generated by the server
- * @param {string} targetDir     - Project root (cwd for Claude)
- * @returns {Promise<{ selected: string[], reasoning: string }>}
- *   Falls back to selecting ALL candidates if Claude is unavailable.
- */
-export async function scoreWithClaude(scoringPrompt, targetDir) {
-  if (!isClaudeAvailable()) {
-    logger.warn('Claude CLI not available — including all optional candidates.');
-    return { selected: null, reasoning: 'Claude unavailable — inclusive fallback' };
-  }
-
-  try {
-    const output = await runClaude([
-      '-p',
-      '--max-turns', '3',
-    ], { cwd: targetDir, stdinInput: scoringPrompt });
-
-    // Parse the scoring result directly (no JSON wrapper to extract)
-    const result = parseScoreResult(output);
-    if (result) {
-      return result;
-    }
-
-    logger.warn('Claude did not return valid scoring JSON — including all candidates.');
-    logger.debug(`Raw output (first 500 chars): ${(output || '').slice(0, 500)}`);
-    return { selected: null, reasoning: 'Parse failure — inclusive fallback' };
-  } catch (err) {
-    if (err.killed) {
-      logger.warn('Claude scoring timed out — including all candidates.');
-    } else {
-      logger.warn('Claude scoring failed — including all candidates.');
-    }
-    return { selected: null, reasoning: 'Error — inclusive fallback' };
-  }
-}
-
-/**
- * Parse Claude's scoring response.
- * Handles both raw JSON and JSON embedded in markdown fences.
- */
-function parseScoreResult(text) {
-  if (!text) return null;
-
-  const tryParse = (obj) => {
-    // V3 format: { selections: [{ id, category, include, reason }] }
-    if (Array.isArray(obj.selections)) {
-      const selected = obj.selections.filter((s) => s.include).map((s) => s.id);
-      const reasoning = obj.selections
-        .filter((s) => s.reason)
-        .map((s) => `${s.id}: ${s.include ? 'included' : 'excluded'} — ${s.reason}`)
-        .join('; ');
-      return { selected, reasoning };
-    }
-    // Fallback: { selected: ["id1", "id2"], reasoning: "..." }
-    if (Array.isArray(obj.selected)) {
-      return { selected: obj.selected, reasoning: obj.reasoning || '' };
-    }
-    return null;
-  };
-
-  // Try direct JSON parse
-  try {
-    const result = tryParse(JSON.parse(text.trim()));
-    if (result) return result;
-  } catch {
-    // Not direct JSON
-  }
-
-  // Try extracting JSON from markdown code fence
-  const fenceMatch = text.match(/```(?:json)?\s*\n([\s\S]*?)```/);
-  if (fenceMatch) {
-    try {
-      const result = tryParse(JSON.parse(fenceMatch[1].trim()));
-      if (result) return result;
-    } catch {
-      // Invalid JSON in fence
-    }
-  }
-
-  // Use brace-balanced extraction
-  const obj = extractJsonObject(text, 'selections') || extractJsonObject(text, 'selected');
-  if (obj) {
-    const result = tryParse(obj);
-    if (result) return result;
-  }
-
-  return null;
-}