ace-interview-prep 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# ace
+
+[![npm version](https://img.shields.io/npm/v/ace-interview-prep.svg)](https://www.npmjs.com/package/ace-interview-prep)
+[![CI](https://github.com/neel/ace-interview-prep/actions/workflows/ci.yml/badge.svg)](https://github.com/neel/ace-interview-prep/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+A CLI tool for staff-engineer-level frontend interview preparation. Scaffolds questions with test cases, tracks progress with scorecards, and provides LLM-powered feedback.
+
+## Install
+
+```bash
+npm install -g ace-interview-prep
+```
+
+Or run directly with npx:
+
+```bash
+npx ace-interview-prep help
+```
+
+## Quick Start
+
+### 1. Configure API Keys
+
+```bash
+ace setup
+```
+
+Stores your OpenAI / Anthropic API keys in `~/.ace/config.json` (one-time, works across all workspaces).
+
+```bash
+# Non-interactive
+ace setup --openai-key sk-... --anthropic-key sk-ant-...
+```
+
+### 2. Initialize a Workspace
+
+Navigate to any folder where you want to practice:
+
+```bash
+ace init
+```
+
+Creates a `questions/` directory and vitest config files. Then install the test dependencies:
+
+```bash
+npm install vitest happy-dom @testing-library/jest-dom
+```
+
+### 3. Practice
+
+```bash
+# Generate a question via LLM
+ace generate --topic "debounce" --category js-ts --difficulty medium
+
+# Interactive brainstorm mode
+ace generate --brainstorm
+
+# Manually add a question
+ace add
+
+# List all questions
+ace list
+
+# Run tests
+ace test debounce
+ace test              # run all
+ace test --watch      # watch mode
+
+# Get LLM feedback
+ace feedback debounce
+
+# View scorecard
+ace score debounce
+
+# Reset a question
+ace reset debounce
+```
+
+## Question Categories
+
+| Category | Slug | Type |
+|----------|------|------|
+| JS/TS Puzzles | `js-ts` | Coding |
+| Web Components | `web-components` | Coding |
+| React Web Apps | `react-apps` | Coding |
+| LeetCode Data Structures | `leetcode-ds` | Coding |
+| LeetCode Algorithms | `leetcode-algo` | Coding |
+| System Design — Frontend | `design-fe` | Design |
+| System Design — Backend | `design-be` | Design |
+| System Design — Full Stack | `design-full` | Design |
+
+## How It Works
+
+1. **Pick a question** from the dashboard (`ace list`) or generate one (`ace generate`).
+2. **Open the question folder** — read `README.md` for the problem statement.
+3. **Write your solution** in the solution file (`solution.ts`, `App.tsx`, `component.ts`, or `notes.md`).
+4. **Run tests** with `ace test <slug>` to check your work.
+5. **Get feedback** with `ace feedback <slug>` for an LLM-powered code or design review.
+6. **Track progress** with `ace score <slug>` and `ace list`.
+
+## Configuration
+
+**Global** (`~/.ace/`) — API keys stored once, shared across all workspaces.
+
+- `~/.ace/config.json` — primary config (created by `ace setup`)
+- `~/.ace/.env` — fallback (dotenv format)
+- Environment variables — final fallback
+
+**Workspace** — each workspace gets its own `questions/` directory and test config.
+
+## Seed Questions
+
+Ships with 8 starter questions (one per category) so you can begin practicing immediately after install.
+
+## Development
+
+```bash
+git clone https://github.com/neel/ace-interview-prep.git
+cd ace-interview-prep
+npm install
+npm run ace help
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full development guide.
+
+## License
+
+[MIT](LICENSE)

package/dist/commands/add.js

@@ -0,0 +1,92 @@
+import prompts from "prompts";
+import chalk from "chalk";
+import { CATEGORIES, CATEGORY_SLUGS, slugify } from "../lib/categories.js";
+import { scaffoldQuestion } from "../lib/scaffold.js";
+import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
+async function run(_args) {
+  const root = resolveWorkspaceRoot();
+  if (!isWorkspaceInitialized(root)) {
+    console.log(chalk.yellow("\nWorkspace not initialized. Running init...\n"));
+    const initModule = await import("./init.js");
+    await initModule.run([]);
+    console.log();
+  }
+  console.log(chalk.cyan("\n--- Add a Question Manually ---\n"));
+  const { category } = await prompts({
+    type: "select",
+    name: "category",
+    message: "Category:",
+    choices: CATEGORY_SLUGS.map((s) => ({ title: CATEGORIES[s].name, value: s }))
+  });
+  if (!category) return;
+  const { difficulty } = await prompts({
+    type: "select",
+    name: "difficulty",
+    message: "Difficulty:",
+    choices: [
+      { title: "Easy", value: "easy" },
+      { title: "Medium", value: "medium" },
+      { title: "Hard", value: "hard" }
+    ]
+  });
+  if (!difficulty) return;
+  const { title } = await prompts({
+    type: "text",
+    name: "title",
+    message: "Question title:",
+    validate: (v) => v.length > 0 ? true : "Title is required"
+  });
+  if (!title) return;
+  const slug = slugify(title);
+  const { description } = await prompts({
+    type: "text",
+    name: "description",
+    message: "Problem description (paste markdown, press Enter when done):"
+  });
+  const config = CATEGORIES[category];
+  let signature;
+  let testCode;
+  let solutionCode;
+  if (config.type === "coding") {
+    const sigResult = await prompts({
+      type: "text",
+      name: "signature",
+      message: "Function/component signature (optional):"
+    });
+    signature = sigResult.signature || void 0;
+    const testResult = await prompts({
+      type: "text",
+      name: "testCode",
+      message: "Paste test code (optional, press Enter to skip):"
+    });
+    testCode = testResult.testCode || void 0;
+    const solResult = await prompts({
+      type: "text",
+      name: "solutionCode",
+      message: "Paste starter/solution code (optional, press Enter to skip):"
+    });
+    solutionCode = solResult.solutionCode || void 0;
+  }
+  try {
+    const questionDir = scaffoldQuestion({
+      title,
+      slug,
+      category,
+      difficulty,
+      description: description || "",
+      signature,
+      testCode,
+      solutionCode
+    });
+    console.log(chalk.green(`
+Created: questions/${category}/${slug}/`));
+    console.log(chalk.dim(`  ${questionDir}`));
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(chalk.red(err.message));
+    }
+  }
+}
+export {
+  run
+};

package/dist/commands/feedback.js

@@ -0,0 +1,133 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { findQuestion, readScorecard, writeScorecard } from "../lib/scorecard.js";
+import { CATEGORIES, isDesignCategory } from "../lib/categories.js";
+import { chatStream, requireProvider } from "../lib/llm.js";
+import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
+const PROMPTS_DIR = path.resolve(import.meta.dirname, "../prompts");
+function loadPrompt(name) {
+  return fs.readFileSync(path.join(PROMPTS_DIR, name), "utf-8");
+}
+function parseArgs(args) {
+  let slug;
+  let provider;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--provider" && args[i + 1]) {
+      provider = args[++i];
+    } else if (!arg.startsWith("--")) {
+      slug = arg;
+    }
+  }
+  return { slug, provider };
+}
+async function run(args) {
+  const root = resolveWorkspaceRoot();
+  if (!isWorkspaceInitialized(root)) {
+    console.error(chalk.red("\nError: Workspace not initialized."));
+    console.error(chalk.dim("Run `ace init` in this folder first.\n"));
+    process.exit(1);
+  }
+  const parsed = parseArgs(args);
+  if (!parsed.slug) {
+    console.error(chalk.red("Missing question slug."));
+    console.error(chalk.dim("Usage: npm run ace feedback <slug>"));
+    return;
+  }
+  const question = findQuestion(parsed.slug);
+  if (!question) {
+    console.error(chalk.red(`Question not found: ${parsed.slug}`));
+    return;
+  }
+  const provider = requireProvider(parsed.provider);
+  const config = CATEGORIES[question.category];
+  const isDesign = isDesignCategory(question.category);
+  const readmePath = path.join(question.dir, "README.md");
+  const readme = fs.existsSync(readmePath) ? fs.readFileSync(readmePath, "utf-8") : "";
+  let systemPrompt;
+  let userContent;
+  if (isDesign) {
+    systemPrompt = loadPrompt("design-review.md");
+    const notesPath = path.join(question.dir, "notes.md");
+    const notes = fs.existsSync(notesPath) ? fs.readFileSync(notesPath, "utf-8") : "";
+    if (!notes.trim() || notes.includes("<!-- List the core features")) {
+      console.error(chalk.yellow("Notes file appears to be empty. Write your design notes first!"));
+      console.error(chalk.dim(`Edit: questions/${question.category}/${parsed.slug}/notes.md`));
+      return;
+    }
+    const designSubType = question.category === "design-fe" ? "frontend" : question.category === "design-be" ? "backend" : "full-stack";
+    userContent = `## Design Sub-Type: ${designSubType}
+
+## Problem Statement
+${readme}
+
+## Candidate's Design Notes
+${notes}`;
+  } else {
+    systemPrompt = loadPrompt("code-review.md");
+    const solutionFiles = config.solutionFiles;
+    let solutionContent = "";
+    for (const f of solutionFiles) {
+      const fp = path.join(question.dir, f);
+      if (fs.existsSync(fp)) {
+        const content = fs.readFileSync(fp, "utf-8");
+        solutionContent += `
+--- ${f} ---
+${content}
+`;
+      }
+    }
+    if (!solutionContent.trim() || solutionContent.includes("// TODO: implement")) {
+      console.error(chalk.yellow("Solution appears to be the default stub. Write your solution first!"));
+      return;
+    }
+    let testContent = "";
+    for (const f of config.testFiles) {
+      const fp = path.join(question.dir, f);
+      if (fs.existsSync(fp)) {
+        testContent += `
+--- ${f} ---
+${fs.readFileSync(fp, "utf-8")}
+`;
+      }
+    }
+    userContent = `## Problem Statement
+${readme}
+
+## Candidate's Solution Code
+${solutionContent}
+
+## Test Cases
+${testContent}`;
+  }
+  console.log(chalk.cyan(`
+--- LLM ${isDesign ? "Design" : "Code"} Review: ${parsed.slug} ---`));
+  console.log(chalk.dim(`Provider: ${provider}
+`));
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userContent }
+  ];
+  const stream = await chatStream(provider, messages);
+  let fullResponse = "";
+  for await (const chunk of stream) {
+    process.stdout.write(chunk);
+    fullResponse += chunk;
+  }
+  console.log("\n");
+  const scorecard = readScorecard(question.category, parsed.slug);
+  if (scorecard) {
+    scorecard.llmFeedback = fullResponse;
+    const scoreMatch = fullResponse.match(/Overall.*?(\d+(?:\.\d+)?)\s*\/\s*5/i);
+    if (scoreMatch && scorecard.attempts.length > 0) {
+      const lastAttempt = scorecard.attempts[scorecard.attempts.length - 1];
+      lastAttempt.llmScore = parseFloat(scoreMatch[1]);
+    }
+    writeScorecard(question.category, parsed.slug, scorecard);
+    console.log(chalk.dim("Feedback saved to scorecard."));
+  }
+}
+export {
+  run
+};

package/dist/commands/generate.js

@@ -0,0 +1,224 @@
+import fs from "node:fs";
+import path from "node:path";
+import prompts from "prompts";
+import chalk from "chalk";
+import { CATEGORIES, CATEGORY_SLUGS, slugify } from "../lib/categories.js";
+import { chat, chatStream, requireProvider } from "../lib/llm.js";
+import { scaffoldQuestion } from "../lib/scaffold.js";
+import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
+const PROMPTS_DIR = path.resolve(import.meta.dirname, "../prompts");
+function parseArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = "true";
+      }
+    }
+  }
+  return result;
+}
+function loadPrompt(name) {
+  return fs.readFileSync(path.join(PROMPTS_DIR, name), "utf-8");
+}
+function extractJSON(text) {
+  const match = text.match(/```json\s*([\s\S]*?)```/);
+  if (match) return match[1].trim();
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (jsonMatch) return jsonMatch[0];
+  return text;
+}
+async function directMode(provider, topic, category, difficulty) {
+  const systemPrompt = loadPrompt("question-generate.md");
+  const categoryConfig = CATEGORIES[category];
+  console.log(chalk.cyan(`
+Generating ${categoryConfig.name} question: "${topic}" (${difficulty})...`));
+  const userMessage = `Generate a ${difficulty} difficulty ${categoryConfig.name} interview question about: ${topic}
+
+Category slug: ${category}
+Question type: ${categoryConfig.type}`;
+  const response = await chat(provider, [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userMessage }
+  ], true);
+  let parsed;
+  try {
+    parsed = JSON.parse(extractJSON(response));
+  } catch {
+    console.error(chalk.red("Failed to parse LLM response as JSON. Raw response:"));
+    console.error(response);
+    return;
+  }
+  const slug = parsed.slug || slugify(parsed.title || topic);
+  const questionDir = scaffoldQuestion({
+    title: parsed.title || topic,
+    slug,
+    category,
+    difficulty,
+    description: parsed.description || "",
+    signature: parsed.signature,
+    testCode: parsed.testCode,
+    solutionCode: parsed.solutionCode
+  });
+  console.log(chalk.green(`
+Created: questions/${category}/${slug}/`));
+  console.log(chalk.dim(`  ${questionDir}`));
+}
+async function brainstormMode(provider) {
+  const systemPrompt = loadPrompt("question-brainstorm.md");
+  const messages = [
+    { role: "system", content: systemPrompt }
+  ];
+  console.log(chalk.cyan("\n--- Brainstorm Mode ---"));
+  console.log(chalk.dim('Chat with the LLM to design a question. Type "done" when ready to scaffold.\n'));
+  const { area } = await prompts({
+    type: "text",
+    name: "area",
+    message: "What area do you want to practice?"
+  });
+  if (!area) return;
+  messages.push({
+    role: "user",
+    content: `I want to practice: ${area}. Suggest some question directions across relevant categories.`
+  });
+  while (true) {
+    console.log(chalk.dim("\nThinking...\n"));
+    const stream = await chatStream(provider, messages);
+    let fullResponse = "";
+    for await (const chunk of stream) {
+      process.stdout.write(chunk);
+      fullResponse += chunk;
+    }
+    console.log("\n");
+    messages.push({ role: "assistant", content: fullResponse });
+    const { userInput } = await prompts({
+      type: "text",
+      name: "userInput",
+      message: chalk.dim('Your response (or "done" to scaffold, "quit" to exit):')
+    });
+    if (!userInput || userInput.toLowerCase() === "quit" || userInput.toLowerCase() === "q") {
+      console.log(chalk.yellow("Exiting brainstorm."));
+      return;
+    }
+    if (userInput.toLowerCase() === "done" || userInput.toLowerCase() === "y") {
+      break;
+    }
+    messages.push({ role: "user", content: userInput });
+  }
+  console.log(chalk.cyan("\nNow let me finalize the question..."));
+  const { category } = await prompts({
+    type: "select",
+    name: "category",
+    message: "Which category?",
+    choices: CATEGORY_SLUGS.map((s) => ({ title: CATEGORIES[s].name, value: s }))
+  });
+  const { difficulty } = await prompts({
+    type: "select",
+    name: "difficulty",
+    message: "Difficulty?",
+    choices: [
+      { title: "Easy", value: "easy" },
+      { title: "Medium", value: "medium" },
+      { title: "Hard", value: "hard" }
+    ]
+  });
+  if (!category || !difficulty) return;
+  const generatePrompt = loadPrompt("question-generate.md");
+  const brainstormSummary = messages.filter((m) => m.role !== "system").map((m) => `${m.role}: ${m.content}`).join("\n\n");
+  const categoryConfig = CATEGORIES[category];
+  const response = await chat(
+    provider,
+    [
+      { role: "system", content: generatePrompt },
+      {
+        role: "user",
+        content: `Based on the following brainstorm conversation, generate a structured ${difficulty} ${categoryConfig.name} interview question.
+
+Category slug: ${category}
+Question type: ${categoryConfig.type}
+
+Brainstorm conversation:
+${brainstormSummary}`
+      }
+    ],
+    true
+  );
+  let parsed;
+  try {
+    parsed = JSON.parse(extractJSON(response));
+  } catch {
+    console.error(chalk.red("Failed to parse LLM response. Raw:"));
+    console.error(response);
+    return;
+  }
+  const slug = parsed.slug || slugify(parsed.title || "brainstorm-question");
+  const questionDir = scaffoldQuestion({
+    title: parsed.title,
+    slug,
+    category,
+    difficulty,
+    description: parsed.description || "",
+    signature: parsed.signature,
+    testCode: parsed.testCode,
+    solutionCode: parsed.solutionCode
+  });
+  console.log(chalk.green(`
+Created: questions/${category}/${slug}/`));
+  console.log(chalk.dim(`  ${questionDir}`));
+}
+async function run(args) {
+  const parsed = parseArgs(args);
+  const root = resolveWorkspaceRoot();
+  if (!isWorkspaceInitialized(root)) {
+    console.log(chalk.yellow("\nWorkspace not initialized. Running init...\n"));
+    const initModule = await import("./init.js");
+    await initModule.run([]);
+    console.log();
+  }
+  const provider = requireProvider(parsed.provider);
+  console.log(chalk.dim(`Using LLM provider: ${provider}`));
+  if (parsed.brainstorm === "true") {
+    await brainstormMode(provider);
+    return;
+  }
+  if (!parsed.topic) {
+    console.error(chalk.red("Missing --topic. Use --brainstorm for interactive mode."));
+    console.error(chalk.dim('Example: npm run ace generate -- --topic "debounce" --category js-ts --difficulty medium'));
+    return;
+  }
+  let category = parsed.category;
+  let difficulty = parsed.difficulty;
+  if (!category) {
+    const result = await prompts({
+      type: "select",
+      name: "category",
+      message: "Which category?",
+      choices: CATEGORY_SLUGS.map((s) => ({ title: CATEGORIES[s].name, value: s }))
+    });
+    category = result.category;
+  }
+  if (!difficulty) {
+    const result = await prompts({
+      type: "select",
+      name: "difficulty",
+      message: "Difficulty?",
+      choices: [
+        { title: "Easy", value: "easy" },
+        { title: "Medium", value: "medium" },
+        { title: "Hard", value: "hard" }
+      ]
+    });
+    difficulty = result.difficulty;
+  }
+  if (!category || !difficulty) return;
+  await directMode(provider, parsed.topic, category, difficulty);
+}
+export {
+  run
+};

package/dist/commands/init.js

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { getQuestionsDir, isWorkspaceInitialized } from "../lib/paths.js";
+function parseArgs(args) {
+  return {
+    force: args.includes("--force"),
+    writeScripts: args.includes("--write-scripts")
+  };
+}
+const VITEST_CONFIG_TEMPLATE = `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'happy-dom',
+    include: ['questions/**/*.test.{ts,tsx}'],
+    testTimeout: 10000,
+    setupFiles: ['vitest.setup.ts'],
+  },
+});
+`;
+const VITEST_SETUP_TEMPLATE = `import '@testing-library/jest-dom/vitest';
+`;
+const PACKAGE_JSON_SCRIPTS = {
+  ace: "tsx cli/index.ts",
+  test: "vitest run",
+  "test:watch": "vitest"
+};
+async function run(args) {
+  const { force, writeScripts } = parseArgs(args);
+  const root = process.cwd();
+  console.log(chalk.cyan("\n--- Initialize Workspace ---"));
+  console.log(chalk.dim(`Workspace: ${root}
+`));
+  if (isWorkspaceInitialized(root) && !force) {
+    console.log(chalk.yellow("\u2713 Workspace already initialized (questions/ exists)"));
+    console.log(chalk.dim("Use --force to reinitialize.\n"));
+    return;
+  }
+  const changes = [];
+  const questionsDir = getQuestionsDir(root);
+  if (!fs.existsSync(questionsDir)) {
+    fs.mkdirSync(questionsDir, { recursive: true });
+    changes.push("Created questions/");
+  }
+  const vitestConfigPath = path.join(root, "vitest.config.ts");
+  if (!fs.existsSync(vitestConfigPath) || force) {
+    fs.writeFileSync(vitestConfigPath, VITEST_CONFIG_TEMPLATE, "utf-8");
+    changes.push(force && fs.existsSync(vitestConfigPath) ? "Overwrote vitest.config.ts" : "Created vitest.config.ts");
+  }
+  const vitestSetupPath = path.join(root, "vitest.setup.ts");
+  if (!fs.existsSync(vitestSetupPath) || force) {
+    fs.writeFileSync(vitestSetupPath, VITEST_SETUP_TEMPLATE, "utf-8");
+    changes.push(force && fs.existsSync(vitestSetupPath) ? "Overwrote vitest.setup.ts" : "Created vitest.setup.ts");
+  }
+  const packageJsonPath = path.join(root, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    if (writeScripts) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        pkg.scripts = pkg.scripts || {};
+        let added = false;
+        for (const [key, value] of Object.entries(PACKAGE_JSON_SCRIPTS)) {
+          if (!pkg.scripts[key]) {
+            pkg.scripts[key] = value;
+            added = true;
+          }
+        }
+        if (added) {
+          fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+          changes.push("Added scripts to package.json");
+        }
+      } catch (err) {
+        console.warn(chalk.yellow("Warning: Could not update package.json scripts"));
+      }
+    }
+  }
+  if (changes.length > 0) {
+    console.log(chalk.green("\u2713 Workspace initialized:\n"));
+    for (const change of changes) {
+      console.log(chalk.dim(`  \u2022 ${change}`));
+    }
+  } else {
+    console.log(chalk.green("\u2713 Workspace already initialized (no changes needed)"));
+  }
+  console.log();
+  console.log(chalk.bold("Next steps:"));
+  console.log(chalk.dim("  1. Install dependencies (if not already installed):"));
+  console.log(chalk.dim("     npm install vitest happy-dom @testing-library/jest-dom"));
+  console.log(chalk.dim("  2. Configure API keys:"));
+  console.log(chalk.dim("     ace setup"));
+  console.log(chalk.dim("  3. Generate or add questions:"));
+  console.log(chalk.dim('     ace generate --topic "debounce"'));
+  console.log(chalk.dim("     ace add"));
+  console.log();
+}
+export {
+  run
+};