@codeyam/codeyam-cli 0.1.0-staging.8df382d → 0.1.0-staging.a890816

package/codeyam-cli/src/commands/editor.js

@@ -0,0 +1,1037 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { runAnalysisForEntities } from "../utils/analysisRunner.js";
+import { ProgressReporter } from "../utils/progress.js";
+import { initializeEnvironment } from "../utils/database.js";
+import { loadEntities, loadAnalyses } from "../../../packages/database/index.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const STEP_LABELS = {
+    1: 'Plan',
+    2: 'Prototype',
+    3: 'Confirm',
+    4: 'Deconstruct',
+    5: 'Extract',
+    6: 'Glossary',
+    7: 'Analyze',
+    8: 'App Scenarios',
+    9: 'User Scenarios',
+    10: 'Verify',
+    11: 'Review',
+};
+/**
+ * Append a JSONL log entry to .codeyam/logs/editor-log.jsonl
+ */
+function logEvent(root, event, data) {
+    try {
+        const logsDir = path.join(root, '.codeyam', 'logs');
+        fs.mkdirSync(logsDir, { recursive: true });
+        const logPath = path.join(logsDir, 'editor-log.jsonl');
+        const entry = JSON.stringify({
+            ts: new Date().toISOString(),
+            event,
+            ...data,
+        });
+        fs.appendFileSync(logPath, entry + '\n', 'utf8');
+    }
+    catch {
+        // Logging is best-effort
+    }
+}
+/**
+ * Get the project root (where .codeyam/ lives) or cwd.
+ */
+function getProjectRoot() {
+    return process.env.CODEYAM_ROOT_PATH || process.cwd();
+}
+/**
+ * Path to the editor step state file.
+ */
+function getStatePath(root) {
+    return path.join(root, '.codeyam', 'editor-step.json');
+}
+/**
+ * Read the current editor state, or null if none.
+ */
+function readState(root) {
+    const statePath = getStatePath(root);
+    try {
+        const content = fs.readFileSync(statePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write the editor state.
+ */
+function writeState(root, state) {
+    const statePath = getStatePath(root);
+    const dir = path.dirname(statePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+/**
+ * Clear the editor state (for starting a new feature).
+ */
+function clearState(root) {
+    const statePath = getStatePath(root);
+    try {
+        fs.unlinkSync(statePath);
+    }
+    catch {
+        // File doesn't exist, that's fine
+    }
+}
+/**
+ * Check if a project has been scaffolded (package.json exists).
+ */
+function hasProject(root) {
+    return fs.existsSync(path.join(root, 'package.json'));
+}
+/**
+ * Get the CodeYam server port from env or default.
+ */
+function getServerPort() {
+    return process.env.CODEYAM_PORT || '3111';
+}
+/**
+ * Print a checklist item.
+ * Inline backtick-wrapped text is highlighted in cyan for visibility.
+ */
+function checkbox(text) {
+    // Highlight `backtick-wrapped` segments in cyan
+    const highlighted = text.replace(/`([^`]+)`/g, (_m, code) => chalk.cyan(code));
+    console.log(`  ${chalk.dim('[ ]')} ${highlighted}`);
+}
+/**
+ * Print a section header.
+ */
+function stepHeader(step, title, feature) {
+    console.log();
+    console.log(chalk.bold.cyan(`━━━ Step ${step}: ${title} ━━━`));
+    if (feature) {
+        console.log(chalk.dim(`Feature: "${feature}"`));
+    }
+    console.log();
+}
+/**
+ * Print a colored progress tracker showing all 11 steps.
+ * Steps before `current` are green ✓, `current` is bold cyan →, future steps are dim ○.
+ */
+function printProgressTracker(current) {
+    console.log();
+    console.log(chalk.dim('┌─────────────────────────────────────┐'));
+    for (let i = 1; i <= 11; i++) {
+        const label = STEP_LABELS[i];
+        const num = i < 10 ? ` ${i}` : `${i}`;
+        const content = `${num}. ${label.padEnd(28)}`;
+        if (i < current) {
+            console.log(chalk.dim('  │') + chalk.green(`  ✓  ${content}`) + chalk.dim('│'));
+        }
+        else if (i === current) {
+            console.log(chalk.dim('  │') + chalk.bold.cyan(`  →  ${content}`) + chalk.dim('│'));
+        }
+        else {
+            console.log(chalk.dim(`  │  ○  ${content}│`));
+        }
+    }
+    console.log(chalk.dim('  └─────────────────────────────────────┘'));
+}
+/**
+ * Print a hard STOP gate directing to the next command.
+ *
+ * Options:
+ * - confirm: true  → step requires user confirmation before proceeding (steps 1, 3, 11)
+ */
+function stopGate(current, opts) {
+    console.log();
+    console.log(chalk.bold.red('━━━ STOP ━━━'));
+    console.log();
+    console.log(chalk.red('Complete each checklist item above before proceeding to the next step.'));
+    if (opts?.confirm) {
+        console.log();
+        console.log(chalk.yellow('Wait for user confirmation before moving on.'));
+    }
+    console.log();
+    console.log(chalk.bold.yellow('Present the following progress tracker to the user (copy it verbatim):'));
+    printProgressTracker(current);
+    console.log();
+    console.log(chalk.yellow('For the CURRENT step (→), show each checklist item with ✓ (done) or ✗ (skipped + reason).'));
+    console.log(chalk.yellow('If any items are ✗, explain why and ask if the user wants to address them.'));
+    console.log();
+    if (current < 10) {
+        console.log(chalk.green('When done, run: ') +
+            chalk.bold(`codeyam editor ${current + 1}`));
+    }
+    else {
+        console.log(chalk.green('Feature complete! Run: ') +
+            chalk.bold('codeyam editor 1') +
+            chalk.green(' to start the next feature'));
+    }
+    console.log();
+}
+// ─── Setup (no args, no project) ──────────────────────────────────────
+function printSetup(root) {
+    const port = getServerPort();
+    logEvent(root, 'setup');
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Editor Mode: Project Setup ━━━'));
+    console.log();
+    console.log("No project detected. Let's get started.");
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Read `.codeyam/editor-mode-context.md` for session state');
+    checkbox('Ask the user what they want to build');
+    console.log();
+    console.log(chalk.bold.red('━━━ STOP ━━━'));
+    console.log();
+    console.log(chalk.red('Ask the user what they want to build, then run:'));
+    console.log();
+    console.log(chalk.green('  ') + chalk.bold('codeyam editor 1 --feature "Feature Name"'));
+    console.log(chalk.dim('  Replace "Feature Name" with a short title for what the user described.'));
+    console.log(chalk.dim('  Step 1 will guide you through planning and getting user confirmation before any code is written.'));
+    console.log();
+}
+// ─── Cycle overview (no args, has project) ────────────────────────────
+function printCycleOverview(root, state) {
+    logEvent(root, 'overview', state ? { feature: state.feature, step: state.step } : {});
+    console.log();
+    console.log(chalk.bold.cyan('━━━ Editor Mode: Feature Cycle ━━━'));
+    console.log();
+    if (state) {
+        console.log(chalk.yellow(`Current: Step ${state.step} (${state.label}) — "${state.feature}"`));
+        console.log();
+        console.log(chalk.green('Continue with: ') +
+            chalk.bold(`codeyam editor ${state.step}`));
+        console.log(chalk.dim('Or run ') +
+            chalk.bold('codeyam editor 1') +
+            chalk.dim(' to start a new feature'));
+    }
+    else {
+        console.log('Each feature follows 11 steps. You MUST run each command in order:');
+        console.log();
+        console.log(`  ${chalk.bold.yellow(' 1')} ${chalk.bold('Plan')}            — Plan the feature, confirm with user`);
+        console.log(`  ${chalk.bold.yellow(' 2')} ${chalk.bold('Prototype')}       — Build a working prototype fast`);
+        console.log(`  ${chalk.bold.yellow(' 3')} ${chalk.bold('Confirm')}         — Confirm prototype with user`);
+        console.log(`  ${chalk.bold.yellow(' 4')} ${chalk.bold('Deconstruct')}     — Read code, plan all extractions`);
+        console.log(`  ${chalk.bold.yellow(' 5')} ${chalk.bold('Extract')}         — TDD extraction of functions + components`);
+        console.log(`  ${chalk.bold.yellow(' 6')} ${chalk.bold('Glossary')}        — Record functions in glossary`);
+        console.log(`  ${chalk.bold.yellow(' 7')} ${chalk.bold('Analyze')}         — Analyze and verify components`);
+        console.log(`  ${chalk.bold.yellow(' 8')} ${chalk.bold('App Scenarios')}   — Create app-level scenarios`);
+        console.log(`  ${chalk.bold.yellow(' 9')} ${chalk.bold('User Scenarios')}  — Create user-persona scenarios`);
+        console.log(`  ${chalk.bold.yellow('10')} ${chalk.bold('Verify')}          — Review screenshots, check for errors`);
+        console.log(`  ${chalk.bold.yellow('11')} ${chalk.bold('Review')}          — Present summary, get approval`);
+        console.log();
+        console.log(chalk.green('Start now: ') + chalk.bold('codeyam editor 1'));
+    }
+    console.log();
+}
+// ─── Step 1: Plan ─────────────────────────────────────────────────────
+function printStep1(root, feature) {
+    clearState(root);
+    // If feature is provided, save initial state so step 2 can pick it up
+    if (feature) {
+        const now = new Date().toISOString();
+        writeState(root, {
+            feature,
+            step: 1,
+            label: STEP_LABELS[1],
+            startedAt: now,
+            featureStartedAt: now,
+        });
+    }
+    logEvent(root, 'step', { step: 1, label: 'Plan', feature });
+    stepHeader(1, 'Plan', feature);
+    console.log('Plan the feature before writing ANY code.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Read `.codeyam/glossary.json` for reusable functions/components');
+    checkbox('Ask the user what they want to build (if not already described)');
+    checkbox('Ask clarifying questions using `AskUserQuestion` with selectable options');
+    console.log(chalk.dim('    Use AskUserQuestion for EVERY clarifying question — give 2-4 concrete options the user can pick from.'));
+    console.log(chalk.dim('    Focus on what the USER will see and do, not on databases, APIs, or components.'));
+    console.log(chalk.dim('    Good: "What should happen when there are no results?" → options: "Show empty state message", "Show suggestions"'));
+    console.log(chalk.dim('    Bad:  Free-form text asking "What do you think about the data model?"'));
+    console.log(chalk.dim('    You can ask up to 4 questions at once. Bundle related questions into a single AskUserQuestion call.'));
+    checkbox("Summarize what you'll build in plain language the user can verify against their vision");
+    console.log();
+    console.log(chalk.bold('Present a selection menu to the user (use AskUserQuestion):'));
+    console.log(chalk.green('    "Looks good, start building!"') +
+        chalk.dim(' — proceed to step 2'));
+    console.log(chalk.yellow('    "I\'d like some changes"') +
+        chalk.dim(' — user describes changes, you revise the plan, then re-present'));
+    console.log();
+    console.log(chalk.dim('This step is for understanding user goals and getting buy-in. Code comes in Step 2.'));
+    console.log();
+    console.log(chalk.bold.red('━━━ STOP ━━━'));
+    console.log();
+    console.log(chalk.red('Complete each checklist item above before proceeding to the next step.'));
+    console.log();
+    console.log(chalk.yellow('Wait for user confirmation before moving on.'));
+    console.log();
+    console.log(chalk.bold.yellow('Present the following progress tracker to the user (copy it verbatim):'));
+    printProgressTracker(1);
+    console.log();
+    console.log(chalk.yellow('For the CURRENT step (→), show each checklist item with ✓ (done) or ✗ (skipped + reason).'));
+    console.log(chalk.yellow('If any items are ✗, explain why and ask if the user wants to address them.'));
+    console.log();
+    console.log(chalk.green('When done, run: ') +
+        chalk.bold('codeyam editor 2 --feature "Feature Name"'));
+    console.log(chalk.dim('  Replace "Feature Name" with a short title for what you just described.'));
+    console.log();
+}
+// ─── Step 2: Prototype ────────────────────────────────────────────────
+function printStep2(root, feature) {
+    const port = getServerPort();
+    const projectExists = hasProject(root);
+    const now = new Date().toISOString();
+    writeState(root, {
+        feature,
+        step: 2,
+        label: STEP_LABELS[2],
+        startedAt: now,
+        featureStartedAt: now,
+    });
+    logEvent(root, 'step', { step: 2, label: 'Prototype', feature });
+    stepHeader(2, 'Prototype', feature);
+    console.log('Build fast with real data. Prioritize speed over quality.');
+    console.log();
+    // If no project exists yet, include scaffolding instructions first
+    if (!projectExists) {
+        const templateDir = path.join(__dirname, '..', '..', 'templates', 'nextjs-prisma-sqlite');
+        const hasTemplate = fs.existsSync(templateDir);
+        console.log(chalk.bold('Scaffold the project:'));
+        if (hasTemplate) {
+            checkbox('Copy the project template and install dependencies');
+            console.log();
+            console.log(chalk.dim('  Copy template (Next.js + Prisma 7 + SQLite, pre-configured):'));
+            console.log(chalk.dim(`  cp -r ${templateDir}/* .`));
+            console.log(chalk.dim(`  cp ${templateDir}/.env .`));
+            console.log(chalk.dim(`  cp ${templateDir}/gitignore .gitignore`));
+            console.log(chalk.dim('  npm install'));
+            console.log();
+            checkbox('Define your data models in `prisma/schema.prisma`');
+            console.log(chalk.dim("  Replace the placeholder Todo model with your app's models"));
+            console.log();
+            checkbox('Push schema and seed the database');
+            console.log(chalk.dim('  npm run db:push'));
+            console.log(chalk.dim('  # Edit prisma/seed.ts with your seed data, then:'));
+            console.log(chalk.dim('  npm run db:seed'));
+            console.log();
+            console.log(chalk.dim('  See PRISMA_SETUP.md for Prisma patterns and important warnings.'));
+            console.log(chalk.dim('  Key: import { prisma } from "@/app/lib/prisma" in API routes.'));
+            console.log(chalk.dim('  Key: Seed scripts must use the adapter pattern (see prisma/seed.ts).'));
+        }
+        else {
+            checkbox('Scaffold the project (Next.js recommended) using temp-dir-rsync pattern');
+            console.log();
+            console.log(chalk.dim('  Scaffolding pattern (avoids .claude/ conflicts):'));
+            console.log(chalk.dim('  SCAFFOLD_DIR="/tmp/codeyam-scaffold-$$" && mkdir -p "$SCAFFOLD_DIR"'));
+            console.log(chalk.dim('  npx create-next-app@latest "$SCAFFOLD_DIR" --typescript --tailwind --eslint \\'));
+            console.log(chalk.dim('    --app --no-src-dir --no-import-alias --no-react-compiler --turbopack'));
+            console.log(chalk.dim('  rsync -a --exclude=\'.git\' "$SCAFFOLD_DIR/" . && rm -rf "$SCAFFOLD_DIR"'));
+            console.log();
+            checkbox('Set up Prisma + SQLite database');
+            console.log(chalk.dim('  npm install prisma @prisma/client @prisma/adapter-better-sqlite3 better-sqlite3'));
+            console.log(chalk.dim('  npm install -D @types/better-sqlite3'));
+            console.log(chalk.dim('  npx prisma init --datasource-provider sqlite'));
+            console.log(chalk.dim('  # Define schema, then: npx prisma db push'));
+        }
+        console.log();
+        checkbox('Initialize git so analysis and commits work');
+        console.log(chalk.dim('  git init && git add -A && git commit -m "Initial commit"'));
+        console.log();
+        checkbox('Run `codeyam init --force --keep-server` to detect the project and configure it');
+        console.log(chalk.dim('  This auto-detects webapps and configures the start command for analysis'));
+        console.log();
+        checkbox('Verify `.codeyam/config.json` has `startCommand` in the webapp entry');
+        console.log(chalk.dim('  Should look like: "startCommand": { "command": "sh", "args": ["-c", "npm run dev -- --port $PORT"] }'));
+        console.log(chalk.dim('  If missing, add it manually. $PORT is replaced at runtime by the analyzer.'));
+        console.log();
+        checkbox(`Notify CodeYam: \`curl -s -X POST http://localhost:${port}/api/editor-refresh\``);
+        console.log();
+        console.log(chalk.bold('Build the feature:'));
+    }
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Create/update API routes (real database reads via Prisma)');
+    checkbox('Seed the database with demo data');
+    checkbox('Build the page/feature UI components');
+    checkbox('Verify the dev server shows the changes');
+    console.log();
+    console.log(chalk.bold('Verify the dev server:'));
+    console.log(chalk.dim(`  # Get dev server URL: curl -s http://localhost:${port}/api/editor-dev-server`));
+    console.log(chalk.dim('  # Check page loads: curl -s -o /dev/null -w "%{http_code}" http://localhost:<dev-port>'));
+    console.log(chalk.dim('  # Check API routes: curl -s http://localhost:<dev-port>/api/your-route'));
+    console.log();
+    console.log(chalk.bold('Verify before proceeding:'));
+    console.log(chalk.yellow('  Verify everything works before presenting the prototype to the user.'));
+    checkbox('Verify the page loads: curl the dev server URL and confirm HTTP 200 (not an error page)');
+    checkbox('Verify API routes return valid JSON: curl each route and confirm no error responses');
+    checkbox('Check for broken images: look at any <img> src attributes and verify the assets exist');
+    checkbox('Check the dev server terminal output for runtime errors (missing modules, failed imports)');
+    console.log(chalk.dim('    If any check fails, fix the issue and re-verify before proceeding.'));
+    console.log();
+    console.log(chalk.dim('Focus on building the prototype. Scenarios and refactoring happen in later steps.'));
+    stopGate(2);
+}
+// ─── Step 3: Confirm ──────────────────────────────────────────────────
+function printStep3(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 3,
+        label: STEP_LABELS[3],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 3, label: 'Confirm', feature });
+    stepHeader(3, 'Confirm', feature);
+    console.log('Summarize what was built and get user confirmation.');
+    console.log();
+    console.log(chalk.bold('Before presenting — verify everything works:'));
+    checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/editor-refresh\``);
+    checkbox('Verify the page loads without errors (no error pages, no blank screens)');
+    checkbox('Verify all images and assets render correctly (no broken images)');
+    checkbox('Verify API routes return valid data (curl each route)');
+    console.log(chalk.yellow('    Do not present to the user until all checks pass. Fix issues first.'));
+    console.log();
+    console.log(chalk.bold('Then present to the user:'));
+    checkbox('Summarize what was built (routes, components, data)');
+    checkbox('Show the user the current state of the prototype');
+    console.log();
+    console.log(chalk.bold('Present a selection menu to the user (use AskUserQuestion):'));
+    console.log(chalk.green('    "Yes, this looks right!"') +
+        chalk.dim(' — proceed to step 4'));
+    console.log(chalk.yellow('    "I\'d like some changes"') +
+        chalk.dim(' — user describes changes, you make them, then re-present'));
+    console.log();
+    console.log(chalk.dim('Wait for user approval before moving on. Refactoring and scenarios happen in later steps.'));
+    stopGate(3, { confirm: true });
+}
+// ─── Step 4: Deconstruct ──────────────────────────────────────────────
+function printStep4(root, feature) {
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 4,
+        label: STEP_LABELS[4],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 4, label: 'Deconstruct', feature });
+    stepHeader(4, 'Deconstruct', feature);
+    console.log(chalk.bold('Goal: pages contain ONLY components. Components contain ONLY sub-components.'));
+    console.log(chalk.yellow('This step is read and plan only. Code extraction happens in step 5.'));
+    console.log();
+    console.log(chalk.bold.red('THE RULE: No direct JSX in page files.'));
+    console.log(chalk.yellow('  After extraction, a page/route file should import and compose components — nothing else.'));
+    console.log(chalk.yellow('  Every distinct visual section in the page is its own component.'));
+    console.log(chalk.yellow('  Every component that renders multiple distinct sections should be split into sub-components.'));
+    console.log(chalk.yellow('  If a component has N visually distinct parts, it should compose N sub-components.'));
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Read `.codeyam/glossary.json` — note reusable functions/components');
+    checkbox('Read EVERY file created or modified in this session');
+    console.log(chalk.yellow('    For EACH file, identify EVERY extractable piece:'));
+    console.log(chalk.yellow('    Components: headers, nav, loading states, empty states, error states,'));
+    console.log(chalk.yellow('      badges/pills, image containers, card sections, form fields, modals,'));
+    console.log(chalk.yellow('      titles, descriptions, rating displays, status indicators, buttons'));
+    console.log(chalk.yellow('    Functions: data transforms, calculations, formatting, validation,'));
+    console.log(chalk.yellow('      API response shaping, any logic that is not directly about rendering'));
+    console.log(chalk.yellow('    Hooks: data fetching, state management, side effects'));
+    console.log();
+    checkbox('Write a numbered extraction plan listing EVERYTHING you will extract');
+    console.log(chalk.yellow('    The end state: every page file is ONLY imports + component composition.'));
+    console.log(chalk.yellow('    No raw <div>, <span>, <h1>, <p>, <img>, or <ul> in page files.'));
+    console.log(chalk.yellow('    Every visual section in every component is itself a component.'));
+    console.log();
+    console.log(chalk.yellow('    For each item in the plan, note:'));
+    console.log(chalk.yellow('    — What it is (component, function, hook)'));
+    console.log(chalk.yellow('    — Where it currently lives (source file + approximate lines)'));
+    console.log(chalk.yellow('    — Where it will go (new file path)'));
+    console.log();
+    console.log(chalk.dim('Present the numbered plan, then proceed to step 5 to execute it.'));
+    stopGate(4);
+}
+// ─── Step 5: Extract ──────────────────────────────────────────────────
+function printStep5(root, feature) {
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 5,
+        label: STEP_LABELS[5],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 5, label: 'Extract', feature });
+    stepHeader(5, 'Extract', feature);
+    console.log('Execute your extraction plan from step 4.');
+    console.log();
+    console.log(chalk.bold('Components:'));
+    checkbox('Extract each component from your plan into its own file');
+    checkbox('Page/route files must contain ZERO direct JSX — only imported components');
+    checkbox('Every component that renders multiple sections must be split into sub-components');
+    console.log(chalk.dim('    No tests needed — visual verification happens in step 7'));
+    console.log();
+    console.log(chalk.bold('Library functions (TDD):'));
+    checkbox('For each function: write MULTIPLE failing tests FIRST, then extract to make them pass');
+    console.log(chalk.dim('    Cover: typical inputs, edge cases, empty/null inputs, error conditions'));
+    console.log(chalk.dim('    Aim for 3-8 test cases per function depending on complexity'));
+    checkbox('Place test files next to source: `app/lib/drinks.ts` → `app/lib/drinks.test.ts`');
+    console.log(chalk.yellow('  Tests ARE the only coverage for library functions — step 7 only captures component screenshots.'));
+    console.log();
+    console.log(chalk.bold('Recursive pass:'));
+    checkbox('Re-read EVERY new file you just created — extract components from components, functions from functions');
+    checkbox('Keep going until every file is a thin shell: just imports and composition');
+    console.log(chalk.yellow('    Check: does any file contain raw <div>, <span>, <h1>, <p>, <img>, or <ul>?'));
+    console.log(chalk.yellow('    If yes → that JSX section is a component waiting to be extracted.'));
+    console.log();
+    console.log(chalk.bold('Verify before proceeding:'));
+    checkbox('Run all tests and verify they pass');
+    checkbox('Page files contain ONLY imports + component composition — no raw HTML tags');
+    checkbox('Every component renders ONE thing or composes sub-components — no multi-section JSX');
+    console.log(chalk.dim('Reuse glossary functions when they fit naturally. Extract a new function when the use case diverges.'));
+    console.log();
+    console.log(chalk.dim('Focus on TDD for functions and extraction for components. Scenarios come in later steps.'));
+    stopGate(5);
+}
+// ─── Step 6: Glossary ─────────────────────────────────────────────────
+function printStep6(root, feature) {
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 6,
+        label: STEP_LABELS[6],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 6, label: 'Glossary', feature });
+    stepHeader(6, 'Glossary', feature);
+    console.log('Record all new functions/components in `.codeyam/glossary.json`.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox("Read `.codeyam/glossary.json` (create if it doesn't exist)");
+    checkbox('Add an entry for each new function/component extracted in step 5');
+    checkbox('Each entry should have: name, filePath, description, parameters, returnType, tags, feature');
+    checkbox('For each function with a test file from step 5, set `testFile` to the relative path');
+    console.log();
+    console.log(chalk.bold('Entry format:'));
+    console.log(chalk.dim('  { "name": "calculateTotal", "filePath": "app/utils/pricing.ts",'));
+    console.log(chalk.dim('    "description": "Calculates total price including tax and discounts",'));
+    console.log(chalk.dim('    "parameters": [{ "name": "items", "type": "CartItem[]" }],'));
+    console.log(chalk.dim('    "returnType": "number", "tags": ["pricing"],'));
+    console.log(chalk.dim('    "testFile": "app/utils/pricing.test.ts",'));
+    console.log(chalk.dim(`    "feature": "${feature}", "createdAt": "..." }`));
+    console.log();
+    console.log(chalk.dim('Focus on updating the glossary. Application code and scenarios come in later steps.'));
+    stopGate(6);
+}
+// ─── Step 7: Analyze ──────────────────────────────────────────────────
+function printStep7(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 7,
+        label: STEP_LABELS[7],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 7, label: 'Analyze', feature });
+    stepHeader(7, 'Analyze and Verify', feature);
+    console.log('Verify visual components (via isolation routes) and library functions (via tests).');
+    console.log();
+    console.log(chalk.bold('Visual Components — Component Isolation:'));
+    checkbox('List all files with new/modified visual components from step 5');
+    checkbox('Ensure `.gitignore` includes `**/codeyam-isolate*` (add if missing)');
+    checkbox('For each visual component:');
+    console.log(chalk.dim('    1. Read the source AND find where it is used in the app to understand:'));
+    console.log(chalk.dim('       — Props/interface'));
+    console.log(chalk.dim('       — Container width in the real app (e.g. card in a 3-col grid → max-w-sm)'));
+    console.log(chalk.dim('    2. Plan multiple scenarios that exercise the component like tests:'));
+    console.log(chalk.dim('       — Default/happy path with typical data'));
+    console.log(chalk.dim('       — Edge cases: empty/missing data, long text, maximum items, zero counts'));
+    console.log(chalk.dim('       — Different visual states: loading, error, disabled, selected, hover'));
+    console.log(chalk.dim('       — Boundary values: single item vs many, min/max ratings, very long names'));
+    console.log(chalk.dim('    3. Create ONE isolation route per component with a scenarios map and ?s= query param:'));
+    console.log(chalk.dim('       Remix:   app/routes/codeyam-isolate.ComponentName.tsx → /codeyam-isolate/ComponentName'));
+    console.log(chalk.dim('       Next.js: app/codeyam-isolate/ComponentName/page.tsx → /codeyam-isolate/ComponentName'));
+    console.log(chalk.dim('       The route defines a `scenarios` object mapping scenario names to props,'));
+    console.log(chalk.dim('       reads `?s=ScenarioName` from the URL, and renders the component with those props.'));
+    console.log(chalk.dim('       Wrap the component in a capture container with id="codeyam-capture":'));
+    console.log(chalk.dim('       <div id="codeyam-capture" style={{ display:"inline-block", padding:"20px" }}>'));
+    console.log(chalk.dim('         <div style={{ width:"100%", maxWidth:"..." }}> ← match the app\'s container width'));
+    console.log(chalk.dim('       e.g. card in a 3-col grid → maxWidth:"24rem", full-width component → omit maxWidth'));
+    console.log(chalk.dim('       The screenshot captures just this wrapper, so the component fills the image.'));
+    console.log(chalk.dim('       Center the wrapper on the page (flexbox center both axes) and set a page background'));
+    console.log(chalk.dim('       color that matches where the component normally appears (e.g. white for light UIs).'));
+    console.log(chalk.dim('    4. Wait 2 seconds for HMR, then register + capture each scenario:'));
+    console.log(chalk.dim(`       codeyam editor register '{"name":"ComponentName - Scenario",`));
+    console.log(chalk.dim(`         "componentName":"ComponentName","componentPath":"path/to/file.tsx",`));
+    console.log(chalk.dim(`         "url":"/codeyam-isolate/ComponentName?s=Scenario",`));
+    console.log(chalk.dim(`         "mockData":{"routes":{"/api/...":{"body":[...]}}}}'`));
+    console.log(chalk.dim('       url is a PATH (starts with /) — the proxy routes it and intercepts API calls'));
+    console.log(chalk.dim('       mockData.routes provides data for API calls the component makes internally'));
+    console.log(chalk.dim('       (omit mockData if the component has no internal API calls)'));
+    console.log(chalk.yellow('    5. IMPORTANT: Check the register response for `clientErrors` array'));
+    console.log(chalk.yellow('       If clientErrors is non-empty → fix the isolation route and re-register'));
+    console.log(chalk.yellow('       Fix client errors and re-register before moving on'));
+    console.log(chalk.dim('    Isolation routes stay in the project (in .gitignore) so the editor preview can display them'));
+    console.log();
+    console.log(chalk.bold('Library Functions — run tests:'));
+    checkbox('Run ALL test files created in step 5');
+    console.log(chalk.dim('    Example: npx vitest run app/lib/drinks.test.ts'));
+    checkbox('Verify every test passes');
+    checkbox('If any test fails, fix the source code and re-run');
+    console.log();
+    console.log(chalk.dim('Do not proceed until both component isolations and library tests pass.'));
+    stopGate(7);
+}
+// ─── Step 8: App Scenarios ────────────────────────────────────────────
+function printStep8(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 8,
+        label: STEP_LABELS[8],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 8, label: 'App Scenarios', feature });
+    stepHeader(8, 'App Scenarios', feature);
+    console.log('Create app-level scenarios representing different data states.');
+    console.log();
+    console.log(chalk.bold('Checklist:'));
+    checkbox('Create scenarios for key data states (empty, loaded, error)');
+    console.log(chalk.dim('    Each scenario provides data across ALL API routes for that state'));
+    console.log(chalk.dim('    Name app scenarios with "App - " prefix: "App - Empty", "App - Full Catalog", "App - API Error"'));
+    checkbox('Register each scenario (auto-captures screenshot):');
+    console.log(chalk.dim(`    codeyam editor register '{"name":"App - Empty","description":"...","mockData":{"routes":{"/api/...":{"body":[...]}}}}'`));
+    checkbox('After each registration, check the response for `clientErrors`');
+    console.log(chalk.yellow('    If clientErrors is non-empty → fix the issue and re-register the scenario'));
+    console.log(chalk.yellow('    Fix client errors and re-register before moving on'));
+    console.log();
+    console.log(chalk.dim('Focus on creating and registering app-level scenarios. Code fixes happen in step 10 if needed.'));
+    stopGate(8);
+}
+// ─── Step 9: User Scenarios ───────────────────────────────────────────
+function printStep9(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 9,
+        label: STEP_LABELS[9],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 9, label: 'User Scenarios', feature });
+    stepHeader(9, 'User Scenarios', feature);
+    console.log('Create per-persona scenarios if the app has users. Skip to step 10 if no users.');
+    console.log();
+    console.log(chalk.bold('If the app has users:'));
+    checkbox('Create scenarios for each user persona (admin, regular user, new user)');
+    console.log(chalk.dim('    Each persona scenario provides data across ALL API routes for that user type'));
+    checkbox('Register each persona scenario (auto-captures screenshot):');
+    console.log(chalk.dim(`    codeyam editor register '{"name":"...","description":"...","mockData":{"routes":{"/api/...":{"body":[...]}}}}'`));
+    checkbox('After each registration, check the response for `clientErrors`');
+    console.log(chalk.yellow('    If clientErrors is non-empty → fix the issue and re-register the scenario'));
+    console.log(chalk.yellow('    Fix client errors and re-register before moving on'));
+    console.log();
+    console.log(chalk.bold('If the app has NO users:'));
+    console.log(chalk.dim('  Skip this step and proceed to step 10 (Verify).'));
+    console.log();
+    console.log(chalk.dim('Focus on creating user-persona scenarios (or skip if no users). Code fixes happen in step 10 if needed.'));
+    stopGate(9);
+}
+// ─── Step 10: Verify ──────────────────────────────────────────────────
+function printStep10(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 10,
+        label: STEP_LABELS[10],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 10, label: 'Verify', feature });
+    stepHeader(10, 'Verify', feature);
+    console.log('Verify component isolation screenshots, editor scenarios, and library tests.');
+    console.log();
+    console.log(chalk.bold('Component isolation screenshots — verify:'));
+    checkbox('Review component screenshots in the App tab (grouped under Components)');
+    checkbox('If any screenshot looks wrong, fix the component code');
+    console.log(chalk.yellow('    After fixing a visual component, re-register the affected scenarios:'));
+    console.log(chalk.dim(`    codeyam editor register '{"name":"ComponentName - Scenario",...}'`));
+    console.log();
+    console.log(chalk.bold('Editor scenarios (App tab) — visual + error check:'));
+    checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/editor-refresh\``);
+    checkbox('Click through each app-level and user-persona scenario in the preview');
+    checkbox(`Check for client-side errors: \`curl -s http://localhost:${port}/api/editor-client-errors\``);
+    console.log(chalk.yellow('    If `hasErrors` is true: list each scenario with errors, fix the source code,'));
+    console.log(chalk.yellow('    re-register the affected scenarios, and re-check until hasErrors is false'));
+    console.log(chalk.dim('    Common errors: React errors, failed fetches, undefined references, hydration mismatches'));
+    checkbox('Verify no broken images in any scenario screenshots');
+    console.log();
+    console.log(chalk.bold('Library functions — test check:'));
+    checkbox('Re-run all test files from step 5 to confirm they still pass');
+    console.log(chalk.dim('    Example: npx vitest run app/lib/drinks.test.ts'));
+    checkbox('If any test fails, fix the source code and re-run');
+    console.log();
+    console.log(chalk.dim('Focus on fixing issues. All component screenshots, scenarios, and tests must be clean before proceeding.'));
+    stopGate(10);
+}
+// ─── Step 11: Review ──────────────────────────────────────────────────
+function printStep11(root, feature) {
+    const port = getServerPort();
+    const prevState = readState(root);
+    writeState(root, {
+        feature,
+        step: 11,
+        label: STEP_LABELS[11],
+        startedAt: new Date().toISOString(),
+        featureStartedAt: prevState?.featureStartedAt || new Date().toISOString(),
+    });
+    logEvent(root, 'step', { step: 11, label: 'Review', feature });
+    stepHeader(11, 'Review', feature);
+    console.log('Present a full summary, verify screenshots, then let the user save or revise.');
+    console.log();
+    console.log(chalk.bold('Phase 1 — Summary:'));
+    checkbox('Summarize the feature that was built');
+    checkbox('List all components and functions created');
+    checkbox('List glossary entries added in step 6');
+    checkbox('List all scenarios (app-level and user-persona)');
+    checkbox('Report analysis status (completed/in-progress from step 7)');
+    checkbox('Report verification status from step 10 (all clean?)');
+    checkbox(`Refresh the preview: \`curl -s -X POST http://localhost:${port}/api/dev-mode-refresh\``);
+    checkbox(`Get scenario list: \`curl -s http://localhost:${port}/api/editor-scenarios\``);
+    checkbox('Present scenarios in a markdown table — one scenario per row');
+    console.log(chalk.yellow('    EVERY scenario must use {{scenario:Name:ID}} — the terminal makes these clickable.'));
+    console.log(chalk.yellow('    Strip the component prefix: "DrinkCard - Default" → just "Default".'));
+    console.log(chalk.yellow('    Component name on first row of each group, blank for subsequent rows.'));
+    console.log();
+    console.log(chalk.dim('    Example:'));
+    console.log(chalk.dim('      | Component | Scenario |'));
+    console.log(chalk.dim('      |---|---|'));
+    console.log(chalk.dim('      | **App** | {{scenario:Full Catalog:abc}} |'));
+    console.log(chalk.dim('      | | {{scenario:Empty:def}} |'));
+    console.log(chalk.dim('      | | {{scenario:Error:ghi}} |'));
+    console.log(chalk.dim('      | **StarRating** | {{scenario:Perfect:jkl}} |'));
+    console.log(chalk.dim('      | | {{scenario:Medium:mno}} |'));
+    console.log();
+    console.log(chalk.bold('Phase 2 — Screenshot & error verification:'));
+    console.log(chalk.yellow('  CRITICAL: Verify screenshots AND check for client-side errors.'));
+    console.log();
+    console.log(chalk.bold('  Component isolation screenshots:'));
+    checkbox('Verify each component has screenshots in the App tab (grouped under Components)');
+    checkbox('If any are missing, re-register them using `codeyam editor register`');
+    console.log();
+    console.log(chalk.bold('  Client-side errors:'));
+    checkbox(`Check for errors: \`curl -s http://localhost:${port}/api/editor-client-errors\``);
+    checkbox('If `hasErrors` is true, list the errors and fix them in the source code');
+    checkbox('After fixing, re-capture affected scenarios to clear the errors');
+    console.log();
+    checkbox('Do not proceed until all components have screenshots and client errors are resolved');
+    console.log();
+    checkbox('Switch the active scenario to the best demo state for the feature');
+    console.log(chalk.dim(`    curl -s -X POST http://localhost:${port}/api/editor-switch-scenario \\`));
+    console.log(chalk.dim(`      -H 'Content-Type: application/json' -d '{"scenarioSlug":"...","scenarioId":"..."}'`));
+    console.log(chalk.dim('    Pick the scenario that best showcases the feature (not an error/empty state)'));
+    checkbox('Present the summary (with screenshot and error status) to the user');
+    console.log();
+    console.log(chalk.bold('Phase 3 — Journal entry (create or update):'));
+    checkbox('Write a concise description of what was built (2-3 sentences)');
+    checkbox(`First time at step 11 — create journal entry with ALL session screenshots:`);
+    console.log(chalk.dim(`    curl -s -X POST http://localhost:${port}/api/editor-journal-entry \\`));
+    console.log(chalk.dim(`      -H 'Content-Type: application/json' \\`));
+    console.log(chalk.dim(`      -d '{"title":"...","type":"feature","description":"...","includeSessionScenarios":true}'`));
+    console.log(chalk.dim('    includeSessionScenarios auto-discovers component + app + user persona screenshots'));
+    checkbox(`Returning after changes — update the existing journal entry:`);
+    console.log(chalk.dim(`    curl -s -X PATCH http://localhost:${port}/api/editor-journal-update \\`));
+    console.log(chalk.dim(`      -H 'Content-Type: application/json' \\`));
+    console.log(chalk.dim(`      -d '{"time":"<journal entry time>","description":"<updated description>"}'`));
+    console.log();
+    console.log(chalk.bold('Phase 4 — Present a selection menu to the user (use AskUserQuestion):'));
+    console.log(chalk.green('    "Save & commit"') +
+        chalk.dim(' — git commit all changes and record in journal'));
+    console.log(chalk.yellow('    "I\'d like to make some changes"') +
+        chalk.dim(' — describe changes, then re-verify'));
+    console.log();
+    console.log(chalk.bold('If the user chooses "Save & commit":'));
+    checkbox(`Git commit using the journal description: \`curl -s -X POST http://localhost:${port}/api/editor-commit -H 'Content-Type: application/json' -d '{"message":"feat: <title>\\n\\n<journal description>"}'\``);
+    console.log(chalk.dim('    The commit message body MUST match the journal description exactly'));
+    checkbox(`Update journal with commit SHA: \`curl -s -X PATCH http://localhost:${port}/api/editor-journal-update -H 'Content-Type: application/json' -d '{"time":"<journal entry time>","commitSha":"<sha>","commitMessage":"feat: <title>"}'\``);
+    console.log(chalk.green('  Then run: ') +
+        chalk.bold('codeyam editor 1') +
+        chalk.green(' to start the next feature'));
+    console.log();
+    console.log(chalk.bold('If the user chooses "Make changes":'));
+    checkbox('Ask what changes the user wants');
+    checkbox('Make the requested changes');
+    console.log(chalk.yellow('  Then run: ') +
+        chalk.bold('codeyam editor 10') +
+        chalk.yellow(' to re-verify, which flows back to step 11'));
+    console.log();
+    console.log(chalk.dim('Complete all phases in order: summary, screenshot verification, journal entry, user menu.'));
+    stopGate(11, { confirm: true });
+}
+// ─── Command definition ───────────────────────────────────────────────
+// ─── Analyze-imports subcommand ────────────────────────────────────────
+/**
+ * `codeyam editor analyze-imports`
+ *
+ * Runs data-structure-only analysis for all glossary entities, then outputs
+ * an import graph and entity data structures as JSON to stdout.
+ */
+async function handleAnalyzeImports() {
+    const root = getProjectRoot();
+    // Read glossary
+    const glossaryPath = path.join(root, '.codeyam', 'glossary.json');
+    if (!fs.existsSync(glossaryPath)) {
+        console.error(chalk.red('Error: .codeyam/glossary.json not found.'));
+        console.error(chalk.dim('  Run codeyam editor 6 to create the glossary first.'));
+        process.exit(1);
+    }
+    let glossaryEntries;
+    try {
+        glossaryEntries = JSON.parse(fs.readFileSync(glossaryPath, 'utf8'));
+    }
+    catch {
+        console.error(chalk.red('Error: Could not parse .codeyam/glossary.json.'));
+        process.exit(1);
+    }
+    if (!Array.isArray(glossaryEntries) || glossaryEntries.length === 0) {
+        console.error(chalk.red('Error: glossary.json is empty.'));
+        process.exit(1);
+    }
+    const filePaths = glossaryEntries.map((e) => e.filePath);
+    const entityNames = glossaryEntries.map((e) => e.name);
+    const progress = new ProgressReporter();
+    // Run data-structure-only analysis for all entities
+    progress.start('Running import analysis for all glossary entities...');
+    try {
+        await runAnalysisForEntities({
+            projectRoot: root,
+            filePaths,
+            entityNames,
+            progress,
+            onlyDataStructure: true,
+        });
+    }
+    catch (err) {
+        progress.fail('Analysis failed');
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red(`Error: ${msg}`));
+        process.exit(1);
+    }
+    progress.succeed('Analysis complete');
+    // Load entities WITH metadata from database
+    progress.start('Loading entity metadata...');
+    await initializeEnvironment();
+    const entities = await loadEntities({});
+    if (!entities || entities.length === 0) {
+        progress.fail('No entities found in database');
+        process.exit(1);
+    }
+    // Deduplicate to latest versions
+    const latestByKey = new Map();
+    for (const entity of entities) {
+        const key = `${entity.name}::${entity.filePath}`;
+        const existing = latestByKey.get(key);
+        if (!existing ||
+            (entity.createdAt &&
+                existing.createdAt &&
+                entity.createdAt > existing.createdAt)) {
+            latestByKey.set(key, entity);
+        }
+    }
+    const entityNameSet = new Set(entityNames);
+    const latestEntities = [...latestByKey.values()].filter((e) => entityNameSet.has(e.name));
+    // Build import graph from importedExports metadata
+    const imports = {};
+    const entityData = {};
+    // Also load analyses for data structures
+    const entityShas = latestEntities.map((e) => e.sha);
+    const analyses = await loadAnalyses({ entityShas });
+    const analysisMap = new Map();
+    if (analyses) {
+        for (const a of analyses) {
+            if (!analysisMap.has(a.entitySha) ||
+                (a.createdAt &&
+                    (!analysisMap.get(a.entitySha).createdAt ||
+                        a.createdAt > analysisMap.get(a.entitySha).createdAt))) {
+                analysisMap.set(a.entitySha, a);
+            }
+        }
+    }
+    for (const entity of latestEntities) {
+        const importedExports = entity.metadata?.importedExports || [];
+        const importedNames = importedExports
+            .map((ie) => ie.name)
+            .filter((name) => entityNameSet.has(name));
+        if (importedNames.length > 0) {
+            imports[entity.name] = importedNames;
+        }
+        // Collect entity data with analysis data structures
+        const analysis = analysisMap.get(entity.sha);
+        const analysisMetadata = analysis?.metadata;
+        entityData[entity.name] = {
+            filePath: entity.filePath || '',
+            entityType: entity.entityType || 'visual',
+            dataForMocks: analysisMetadata?.scenariosDataStructure?.dataForMocks,
+            dependencySchemas: analysisMetadata?.mergedDataStructure?.dependencySchemas,
+        };
+    }
+    progress.succeed('Done');
+    // Output combined JSON
+    const output = { imports, entities: entityData };
+    console.log(JSON.stringify(output, null, 2));
+}
+// ─── Register subcommand ──────────────────────────────────────────────
+/**
+ * `codeyam editor register '{"name":"...","componentName":"...",...}'`
+ *
+ * Thin CLI wrapper around POST /api/editor-register-scenario.
+ * Auto-approved via `Bash(codeyam:*)` — no manual approval needed.
+ */
+async function handleRegister(jsonArg) {
+    if (!jsonArg) {
+        console.error(chalk.red('Error: JSON argument required.'));
+        console.error(chalk.dim('  Usage: codeyam editor register \'{"name":"DrinkCard - Default","componentName":"DrinkCard","url":"/codeyam-isolate/DrinkCard?s=Default"}\''));
+        process.exit(1);
+    }
+    let body;
+    try {
+        body = JSON.parse(jsonArg);
+    }
+    catch {
+        console.error(chalk.red('Error: Invalid JSON.'));
+        console.error(chalk.dim(`  Received: ${jsonArg.slice(0, 200)}`));
+        process.exit(1);
+    }
+    const port = getServerPort();
+    const url = `http://localhost:${port}/api/editor-register-scenario`;
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const data = await res.json();
+        console.log(JSON.stringify(data, null, 2));
+        if (!res.ok) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: Could not reach editor server at ${url}`));
+        console.error(chalk.dim(`  ${msg}`));
+        console.error(chalk.dim('  Is the editor running? Start it with: codeyam editor'));
+        process.exit(1);
+    }
+}
+// ─── Command definition ───────────────────────────────────────────────
+const editorCommand = {
+    command: 'editor [step] [json]',
+    describe: 'Editor mode guided workflow',
+    builder: (yargs) => {
+        return yargs
+            .positional('step', {
+            type: 'string',
+            describe: 'Step number (1-11) or subcommand (register, analyze-imports)',
+        })
+            .positional('json', {
+            type: 'string',
+            describe: 'JSON argument for register subcommand',
+        })
+            .option('feature', {
+            type: 'string',
+            describe: 'Feature name (required for step 2)',
+        });
+    },
+    handler: async (argv) => {
+        const root = getProjectRoot();
+        // Subcommand: codeyam editor register '{"name":"..."}'
+        if (argv.step === 'register') {
+            await handleRegister(argv.json || '');
+            return;
+        }
+        // Subcommand: codeyam editor analyze-imports
+        if (argv.step === 'analyze-imports') {
+            await handleAnalyzeImports();
+            return;
+        }
+        const step = argv.step ? parseInt(argv.step, 10) : undefined;
+        if (step != null && (isNaN(step) || step < 1 || step > 11)) {
+            console.error(chalk.red(`Error: Invalid step "${argv.step}". Must be 1-11.`));
+            process.exit(1);
+        }
+        if (step == null) {
+            // No step specified: setup or overview
+            if (!hasProject(root)) {
+                printSetup(root);
+            }
+            else {
+                const state = readState(root);
+                printCycleOverview(root, state);
+            }
+            return;
+        }
+        const state = readState(root);
+        switch (step) {
+            case 1: {
+                const feature = argv.feature || undefined;
+                printStep1(root, feature);
+                break;
+            }
+            case 2: {
+                const feature = argv.feature || state?.feature;
+                if (!feature) {
+                    console.error(chalk.red('Error: --feature "Feature Name" is required for step 2.'));
+                    console.error(chalk.dim('  Usage: codeyam editor 2 --feature "Drink Rating System"'));
+                    process.exit(1);
+                }
+                printStep2(root, feature);
+                break;
+            }
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+            case 9:
+            case 10:
+            case 11: {
+                const feature = argv.feature || state?.feature;
+                if (!feature) {
+                    console.error(chalk.red('Error: No feature in progress. Run codeyam editor 1 first.'));
+                    process.exit(1);
+                }
+                const stepFns = {
+                    3: printStep3,
+                    4: printStep4,
+                    5: printStep5,
+                    6: printStep6,
+                    7: printStep7,
+                    8: printStep8,
+                    9: printStep9,
+                    10: printStep10,
+                    11: printStep11,
+                };
+                stepFns[step](root, feature);
+                break;
+            }
+        }
+    },
+};
+export default editorCommand;
+//# sourceMappingURL=editor.js.map