ace-interview-prep 0.1.2 → 0.1.3

package/README.md

@@ -50,7 +50,10 @@ npm install vitest happy-dom @testing-library/jest-dom
 ### 3. Practice
 
 ```bash
-# Generate a question via LLM
+# Generate a question interactively (prompts for category, difficulty, topic)
+ace generate
+
+# Or pass flags to skip prompts
 ace generate --topic "debounce" --category js-ts --difficulty medium
 
 # Interactive brainstorm mode
@@ -61,43 +64,59 @@ ace add
 
 # List all questions
 ace list
+```
+
+### 4. Test, Review, Track
 
+All commands below work in three modes:
+- **Interactive** — run with no arguments to pick from a selectable list
+- **Direct** — pass a slug to target a specific question
+- **All** — pass `--all` to operate on every question
+
+```bash
 # Run tests
-ace test debounce
-ace test              # run all
-ace test --watch      # watch mode
+ace test              # pick from list
+ace test debounce     # specific question
+ace test --all        # run all tests
+ace test --watch      # watch mode (with --all)
 
-# Get LLM feedback
-ace feedback debounce
+# Get LLM feedback on your solution
+ace feedback          # pick from list
+ace feedback debounce # specific question
+ace feedback --all    # review all questions (confirms each one)
 
 # View scorecard
-ace score debounce
-
-# Reset a question
-ace reset debounce
+ace score             # pick from list
+ace score debounce    # specific question
+ace score --all       # show all scorecards
+
+# Reset a question to its stub
+ace reset             # pick from list
+ace reset debounce    # specific question
+ace reset --all       # reset everything (with confirmation)
 ```
 
 ## 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 |
+| Category | Slug | Type | Focus |
+|----------|------|------|-------|
+| JS/TS Puzzles | `js-ts` | Coding | Closures, async patterns, type utilities |
+| React Components | `web-components` | Coding | Props, events, composition, reusable UI |
+| React Web Apps | `react-apps` | Coding | Hooks, state, routing, full features |
+| LeetCode Data Structures | `leetcode-ds` | Coding | Trees, graphs, heaps, hash maps |
+| LeetCode Algorithms | `leetcode-algo` | Coding | DP, greedy, two pointers, sorting |
+| System Design — Frontend | `design-fe` | Design | Component architecture, state, rendering |
+| System Design — Backend | `design-be` | Design | APIs, databases, caching, queues |
+| System Design — Full Stack | `design-full` | Design | End-to-end systems, trade-offs |
 
 ## How It Works
 
-1. **Pick a question** from the dashboard (`ace list`) or generate one (`ace generate`).
+1. **Generate a question** — run `ace generate` and follow the prompts (category, difficulty, topic), or use `ace generate --brainstorm` for an interactive design session.
 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`.
+3. **Write your solution** in the solution file (`solution.ts`, `App.tsx`, `Component.tsx`, or `notes.md`).
+4. **Run tests** with `ace test` to pick a question and check your work.
+5. **Get feedback** with `ace feedback` for an LLM-powered code or design review.
+6. **Track progress** with `ace score` and `ace list`.
 
 ## Configuration
 

package/dist/commands/feedback.js

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
+import prompts from "prompts";
 import chalk from "chalk";
-import { findQuestion, readScorecard, writeScorecard } from "../lib/scorecard.js";
+import { findQuestion, readScorecard, writeScorecard, getAllQuestions, promptForSlug } 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";
@@ -12,35 +13,25 @@ function loadPrompt(name) {
 function parseArgs(args) {
   let slug;
   let provider;
+  let all = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--provider" && args[i + 1]) {
       provider = args[++i];
+    } else if (arg === "--all" || arg === "all") {
+      all = true;
     } else if (!arg.startsWith("--")) {
       slug = arg;
     }
   }
-  return { slug, provider };
+  return { slug, provider, all };
 }
-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);
+async function runFeedbackForSlug(slug, provider) {
+  const question = findQuestion(slug);
   if (!question) {
-    console.error(chalk.red(`Question not found: ${parsed.slug}`));
+    console.error(chalk.red(`Question not found: ${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");
@@ -53,7 +44,7 @@ async function run(args) {
     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`));
+      console.error(chalk.dim(`Edit: questions/${question.category}/${slug}/notes.md`));
       return;
     }
     const designSubType = question.category === "design-fe" ? "frontend" : question.category === "design-be" ? "backend" : "full-stack";
@@ -102,7 +93,7 @@ ${solutionContent}
 ${testContent}`;
   }
   console.log(chalk.cyan(`
---- LLM ${isDesign ? "Design" : "Code"} Review: ${parsed.slug} ---`));
+--- LLM ${isDesign ? "Design" : "Code"} Review: ${slug} ---`));
   console.log(chalk.dim(`Provider: ${provider}
 `));
   const messages = [
@@ -116,7 +107,7 @@ ${testContent}`;
     fullResponse += chunk;
   }
   console.log("\n");
-  const scorecard = readScorecard(question.category, parsed.slug);
+  const scorecard = readScorecard(question.category, slug);
   if (scorecard) {
     scorecard.llmFeedback = fullResponse;
     const scoreMatch = fullResponse.match(/Overall.*?(\d+(?:\.\d+)?)\s*\/\s*5/i);
@@ -124,10 +115,54 @@ ${testContent}`;
       const lastAttempt = scorecard.attempts[scorecard.attempts.length - 1];
       lastAttempt.llmScore = parseFloat(scoreMatch[1]);
     }
-    writeScorecard(question.category, parsed.slug, scorecard);
+    writeScorecard(question.category, slug, scorecard);
     console.log(chalk.dim("Feedback saved to scorecard."));
   }
 }
+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);
+  const provider = requireProvider(parsed.provider);
+  if (parsed.all) {
+    const questions = getAllQuestions();
+    if (questions.length === 0) {
+      console.log(chalk.yellow("No questions found. Create one first with `ace generate` or `ace add`."));
+      return;
+    }
+    console.log(chalk.cyan(`
+Running feedback for ${questions.length} question(s)...
+`));
+    for (let i = 0; i < questions.length; i++) {
+      const q = questions[i];
+      console.log(chalk.bold(`
+[${i + 1}/${questions.length}] ${q.slug}`));
+      const { confirm } = await prompts({
+        type: "confirm",
+        name: "confirm",
+        message: `Run feedback for "${q.slug}"?`,
+        initial: true
+      });
+      if (!confirm) {
+        console.log(chalk.dim("Skipped."));
+        continue;
+      }
+      await runFeedbackForSlug(q.slug, provider);
+    }
+    console.log(chalk.green("\nCompleted feedback for all questions."));
+    return;
+  }
+  let selectedSlug = parsed.slug;
+  if (!selectedSlug) {
+    selectedSlug = await promptForSlug();
+    if (!selectedSlug) return;
+  }
+  await runFeedbackForSlug(selectedSlug, provider);
+}
 export {
   run
 };

package/dist/commands/generate.js

@@ -56,6 +56,9 @@ Question type: ${categoryConfig.type}`;
     return;
   }
   const slug = parsed.slug || slugify(parsed.title || topic);
+  if (parsed.solutionCode) {
+    console.log(chalk.dim("Note: Discarded LLM solutionCode; using signature-based stub."));
+  }
   const questionDir = scaffoldQuestion({
     title: parsed.title || topic,
     slug,
@@ -63,8 +66,7 @@ Question type: ${categoryConfig.type}`;
     difficulty,
     description: parsed.description || "",
     signature: parsed.signature,
-    testCode: parsed.testCode,
-    solutionCode: parsed.solutionCode
+    testCode: parsed.testCode
   });
   console.log(chalk.green(`
 Created: questions/${category}/${slug}/`));
@@ -116,7 +118,11 @@ async function brainstormMode(provider) {
     type: "select",
     name: "category",
     message: "Which category?",
-    choices: CATEGORY_SLUGS.map((s) => ({ title: CATEGORIES[s].name, value: s }))
+    choices: CATEGORY_SLUGS.map((s) => ({
+      title: CATEGORIES[s].name,
+      description: CATEGORIES[s].hint,
+      value: s
+    }))
   });
   const { difficulty } = await prompts({
     type: "select",
@@ -158,6 +164,9 @@ ${brainstormSummary}`
     return;
   }
   const slug = parsed.slug || slugify(parsed.title || "brainstorm-question");
+  if (parsed.solutionCode) {
+    console.log(chalk.dim("Note: Discarded LLM solutionCode; using signature-based stub."));
+  }
   const questionDir = scaffoldQuestion({
     title: parsed.title,
     slug,
@@ -165,8 +174,7 @@ ${brainstormSummary}`
     difficulty,
     description: parsed.description || "",
     signature: parsed.signature,
-    testCode: parsed.testCode,
-    solutionCode: parsed.solutionCode
+    testCode: parsed.testCode
   });
   console.log(chalk.green(`
 Created: questions/${category}/${slug}/`));
@@ -187,22 +195,23 @@ async function run(args) {
     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;
+  let topic = parsed.topic;
   if (!category) {
     const result = await prompts({
       type: "select",
       name: "category",
       message: "Which category?",
-      choices: CATEGORY_SLUGS.map((s) => ({ title: CATEGORIES[s].name, value: s }))
+      choices: CATEGORY_SLUGS.map((s) => ({
+        title: CATEGORIES[s].name,
+        description: CATEGORIES[s].hint,
+        value: s
+      }))
     });
     category = result.category;
   }
+  if (!category) return;
   if (!difficulty) {
     const result = await prompts({
       type: "select",
@@ -216,8 +225,17 @@ async function run(args) {
     });
     difficulty = result.difficulty;
   }
-  if (!category || !difficulty) return;
-  await directMode(provider, parsed.topic, category, difficulty);
+  if (!difficulty) return;
+  if (!topic) {
+    const result = await prompts({
+      type: "text",
+      name: "topic",
+      message: "What topic do you want to practice?"
+    });
+    topic = result.topic;
+  }
+  if (!topic) return;
+  await directMode(provider, topic, category, difficulty);
 }
 export {
   run

package/dist/commands/reset.js

@@ -2,38 +2,16 @@ import fs from "node:fs";
 import path from "node:path";
 import prompts from "prompts";
 import chalk from "chalk";
-import { findQuestion, readScorecard, resetScorecard, startNewAttempt, writeScorecard } from "../lib/scorecard.js";
+import { findQuestion, readScorecard, resetScorecard, startNewAttempt, writeScorecard, getAllQuestions, promptForSlug } from "../lib/scorecard.js";
 import { CATEGORIES, isDesignCategory } from "../lib/categories.js";
 import { getStubContent } from "../lib/scaffold.js";
 import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
-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 slug = args.find((a) => !a.startsWith("--"));
-  if (!slug) {
-    console.error(chalk.red("Missing question slug."));
-    console.error(chalk.dim("Usage: npm run ace reset <slug>"));
-    return;
-  }
+function resetQuestion(slug) {
   const question = findQuestion(slug);
   if (!question) {
     console.error(chalk.red(`Question not found: ${slug}`));
     return;
   }
-  const { confirm } = await prompts({
-    type: "confirm",
-    name: "confirm",
-    message: `Reset "${slug}" to unanswered? This will clear your solution.`,
-    initial: false
-  });
-  if (!confirm) {
-    console.log(chalk.yellow("Cancelled."));
-    return;
-  }
   const config = CATEGORIES[question.category];
   const isDesign = isDesignCategory(question.category);
   if (isDesign) {
@@ -44,7 +22,6 @@ async function run(args) {
     }
   } else {
     for (const file of config.solutionFiles) {
-      if (file === "index.html") continue;
       const filePath = path.join(question.dir, file);
       const stubContent = getStubContent(question.category, file);
       if (stubContent) {
@@ -59,8 +36,64 @@ async function run(args) {
     scorecard.status = "untouched";
     writeScorecard(question.category, slug, scorecard);
   }
-  console.log(chalk.green(`
-Reset: questions/${question.category}/${slug}/`));
+  console.log(chalk.green(`Reset: questions/${question.category}/${slug}/`));
+}
+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 hasAll = args.includes("--all") || args.includes("all");
+  const slug = args.find((a) => !a.startsWith("--") && a !== "all");
+  if (hasAll) {
+    const questions = getAllQuestions();
+    if (questions.length === 0) {
+      console.log(chalk.yellow("No questions found. Create one first with `ace generate` or `ace add`."));
+      return;
+    }
+    const { confirm: confirm2 } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: `Reset ALL ${questions.length} question(s) to unanswered? This will clear all solutions.`,
+      initial: false
+    });
+    if (!confirm2) {
+      console.log(chalk.yellow("Cancelled."));
+      return;
+    }
+    console.log(chalk.cyan(`
+Resetting ${questions.length} question(s)...
+`));
+    for (const q of questions) {
+      resetQuestion(q.slug);
+    }
+    console.log(chalk.green("\nCompleted reset for all questions."));
+    console.log(chalk.dim("Solution files restored to stubs. Scorecards updated."));
+    return;
+  }
+  let selectedSlug = slug;
+  if (!selectedSlug) {
+    selectedSlug = await promptForSlug();
+    if (!selectedSlug) return;
+  }
+  const question = findQuestion(selectedSlug);
+  if (!question) {
+    console.error(chalk.red(`Question not found: ${selectedSlug}`));
+    return;
+  }
+  const { confirm } = await prompts({
+    type: "confirm",
+    name: "confirm",
+    message: `Reset "${selectedSlug}" to unanswered? This will clear your solution.`,
+    initial: false
+  });
+  if (!confirm) {
+    console.log(chalk.yellow("Cancelled."));
+    return;
+  }
+  resetQuestion(selectedSlug);
   console.log(chalk.dim("Solution files restored to stubs. Scorecard updated."));
 }
 export {

package/dist/commands/score.js

@@ -1,35 +1,13 @@
 import chalk from "chalk";
-import { findQuestion, readScorecard } from "../lib/scorecard.js";
+import { findQuestion, readScorecard, getAllQuestions, promptForSlug } from "../lib/scorecard.js";
 import { CATEGORIES } from "../lib/categories.js";
 import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
-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 slug = args.find((a) => !a.startsWith("--"));
-  if (!slug) {
-    console.error(chalk.red("Missing question slug."));
-    console.error(chalk.dim("Usage: npm run ace score <slug>"));
-    return;
-  }
-  const question = findQuestion(slug);
-  if (!question) {
-    console.error(chalk.red(`Question not found: ${slug}`));
-    return;
-  }
-  const scorecard = readScorecard(question.category, slug);
-  if (!scorecard) {
-    console.error(chalk.red("No scorecard found for this question."));
-    return;
-  }
-  const config = CATEGORIES[question.category];
+function displayScorecard(slug, category, scorecard) {
+  const config = CATEGORIES[category];
   console.log(`
 ${chalk.bold.cyan("Scorecard:")} ${chalk.bold(scorecard.title || slug)}`);
   console.log(chalk.dim("\u2500".repeat(60)));
-  console.log(`  ${chalk.bold("Category:")}     ${config?.name || question.category}`);
+  console.log(`  ${chalk.bold("Category:")}     ${config?.name || category}`);
   console.log(`  ${chalk.bold("Difficulty:")}   ${scorecard.difficulty}`);
   console.log(`  ${chalk.bold("Suggested:")}    ~${scorecard.suggestedTime} minutes`);
   const statusColors = {
@@ -65,6 +43,43 @@ ${chalk.bold("  Last LLM Feedback:")}`);
   }
   console.log(chalk.dim("\n" + "\u2500".repeat(60)));
 }
+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 hasAll = args.includes("--all") || args.includes("all");
+  const slug = args.find((a) => !a.startsWith("--") && a !== "all");
+  if (hasAll) {
+    const questions = getAllQuestions();
+    if (questions.length === 0) {
+      console.log(chalk.yellow("No questions found. Create one first with `ace generate` or `ace add`."));
+      return;
+    }
+    for (const q of questions) {
+      displayScorecard(q.slug, q.category, q.scorecard);
+    }
+    return;
+  }
+  let selectedSlug = slug;
+  if (!selectedSlug) {
+    selectedSlug = await promptForSlug();
+    if (!selectedSlug) return;
+  }
+  const question = findQuestion(selectedSlug);
+  if (!question) {
+    console.error(chalk.red(`Question not found: ${selectedSlug}`));
+    return;
+  }
+  const scorecard = readScorecard(question.category, selectedSlug);
+  if (!scorecard) {
+    console.error(chalk.red("No scorecard found for this question."));
+    return;
+  }
+  displayScorecard(selectedSlug, question.category, scorecard);
+}
 export {
   run
 };

package/dist/commands/test.js

@@ -1,19 +1,22 @@
 import { execSync } from "node:child_process";
 import chalk from "chalk";
-import { findQuestion, readScorecard, updateTestResults, writeScorecard } from "../lib/scorecard.js";
+import { findQuestion, readScorecard, updateTestResults, writeScorecard, promptForSlug } from "../lib/scorecard.js";
 import { isDesignCategory } from "../lib/categories.js";
 import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
 function parseArgs(args) {
   let slug;
   let watch = false;
+  let all = false;
   for (const arg of args) {
     if (arg === "--watch") {
       watch = true;
+    } else if (arg === "--all" || arg === "all") {
+      all = true;
     } else if (!arg.startsWith("--")) {
       slug = arg;
     }
   }
-  return { slug, watch };
+  return { slug, watch, all };
 }
 function parseTestOutput(output) {
   const passMatch = output.match(/(\d+)\s+passed/);
@@ -31,8 +34,8 @@ async function run(args) {
     console.error(chalk.dim("Run `ace init` in this folder first.\n"));
     process.exit(1);
   }
-  const { slug, watch } = parseArgs(args);
-  if (!slug) {
+  const { slug, watch, all } = parseArgs(args);
+  if (all) {
     console.log(chalk.cyan("\nRunning all tests...\n"));
     try {
       const cmd = watch ? "npx vitest" : "npx vitest run";
@@ -41,19 +44,24 @@ async function run(args) {
     }
     return;
   }
-  const question = findQuestion(slug);
+  let selectedSlug = slug;
+  if (!selectedSlug) {
+    selectedSlug = await promptForSlug();
+    if (!selectedSlug) return;
+  }
+  const question = findQuestion(selectedSlug);
   if (!question) {
-    console.error(chalk.red(`Question not found: ${slug}`));
+    console.error(chalk.red(`Question not found: ${selectedSlug}`));
     console.error(chalk.dim("Run `npm run ace list` to see all questions."));
     return;
   }
   if (isDesignCategory(question.category)) {
-    console.log(chalk.yellow(`"${slug}" is a system design question \u2014 no tests to run.`));
-    console.log(chalk.dim("Use `npm run ace feedback " + slug + "` for LLM review."));
+    console.log(chalk.yellow(`"${selectedSlug}" is a system design question \u2014 no tests to run.`));
+    console.log(chalk.dim("Use `npm run ace feedback " + selectedSlug + "` for LLM review."));
     return;
   }
   console.log(chalk.cyan(`
-Running tests for: ${slug}
+Running tests for: ${selectedSlug}
 `));
   let output = "";
   try {
@@ -67,11 +75,11 @@ Running tests for: ${slug}
     }
   }
   if (!watch) {
-    const scorecard = readScorecard(question.category, slug);
+    const scorecard = readScorecard(question.category, selectedSlug);
     if (scorecard) {
       const { total, passed } = parseTestOutput(output);
       updateTestResults(scorecard, total, passed);
-      writeScorecard(question.category, slug, scorecard);
+      writeScorecard(question.category, selectedSlug, scorecard);
       if (total > 0) {
         const color = passed === total ? chalk.green : chalk.red;
         console.log(color(`

package/dist/index.js

@@ -35,15 +35,39 @@ ${chalk.bold("Examples:")}
 
   ace setup
   ace init
+  
+  ${chalk.dim("# Generate interactively (prompts for category, difficulty, topic)")}
+  ace generate
+  
+  ${chalk.dim("# Or pass flags to skip prompts")}
   ace generate --topic "debounce" --category js-ts --difficulty medium
+  
+  ${chalk.dim("# Brainstorm mode for design help")}
   ace generate --brainstorm
+  
+  ${chalk.dim("# List all questions")}
   ace list
   ace list --category js-ts --status solved
+  
+  ${chalk.dim("# Test interactively (shows question picker)")}
+  ace test
+  
+  ${chalk.dim("# Or test a specific question or all questions")}
   ace test debounce
-  ace test --watch
+  ace test --all
+  
+  ${chalk.dim("# Feedback, score, and reset also support interactive mode and --all")}
+  ace feedback
   ace feedback debounce
-  ace reset debounce
+  ace feedback --all
+  
+  ace score
   ace score debounce
+  ace score --all
+  
+  ace reset
+  ace reset debounce
+  ace reset --all
 `);
 }
 async function main() {

package/dist/lib/categories.js

@@ -3,6 +3,7 @@ const CATEGORIES = {
     slug: "js-ts",
     name: "JS/TS Puzzles",
     shortName: "JS/TS",
+    hint: "Closures, async patterns, type utilities",
     type: "coding",
     suggestedTimes: { easy: 15, medium: 30, hard: 45 },
     solutionFiles: ["solution.ts"],
@@ -11,18 +12,20 @@ const CATEGORIES = {
   },
   "web-components": {
     slug: "web-components",
-    name: "Web Components",
-    shortName: "WebComp",
+    name: "React Components",
+    shortName: "React",
+    hint: "Props, events, composition, reusable UI",
     type: "coding",
     suggestedTimes: { easy: 20, medium: 35, hard: 50 },
-    solutionFiles: ["component.ts", "index.html"],
-    testFiles: ["component.test.ts"],
+    solutionFiles: ["Component.tsx"],
+    testFiles: ["Component.test.tsx"],
     templateDir: "web-components"
   },
   "react-apps": {
     slug: "react-apps",
     name: "React Web Apps",
     shortName: "React",
+    hint: "Hooks, state, routing, full features",
     type: "coding",
     suggestedTimes: { easy: 25, medium: 45, hard: 60 },
     solutionFiles: ["App.tsx"],
@@ -33,6 +36,7 @@ const CATEGORIES = {
     slug: "leetcode-ds",
     name: "LeetCode Data Structures",
     shortName: "LC-DS",
+    hint: "Trees, graphs, heaps, hash maps",
     type: "coding",
     suggestedTimes: { easy: 15, medium: 30, hard: 45 },
     solutionFiles: ["solution.ts"],
@@ -43,6 +47,7 @@ const CATEGORIES = {
     slug: "leetcode-algo",
     name: "LeetCode Algorithms",
     shortName: "LC-Algo",
+    hint: "DP, greedy, two pointers, sorting",
     type: "coding",
     suggestedTimes: { easy: 15, medium: 30, hard: 45 },
     solutionFiles: ["solution.ts"],
@@ -53,6 +58,7 @@ const CATEGORIES = {
     slug: "design-fe",
     name: "System Design \u2014 Frontend",
     shortName: "Design-FE",
+    hint: "Component architecture, state, rendering",
     type: "design",
     suggestedTimes: { easy: 25, medium: 40, hard: 55 },
     solutionFiles: ["notes.md"],
@@ -63,6 +69,7 @@ const CATEGORIES = {
     slug: "design-be",
     name: "System Design \u2014 Backend",
     shortName: "Design-BE",
+    hint: "APIs, databases, caching, queues",
     type: "design",
     suggestedTimes: { easy: 25, medium: 40, hard: 55 },
     solutionFiles: ["notes.md"],
@@ -73,6 +80,7 @@ const CATEGORIES = {
     slug: "design-full",
     name: "System Design \u2014 Full Stack",
     shortName: "Design-Full",
+    hint: "End-to-end systems, trade-offs",
     type: "design",
     suggestedTimes: { easy: 30, medium: 45, hard: 60 },
     solutionFiles: ["notes.md"],

package/dist/lib/scaffold.js

@@ -37,8 +37,7 @@ function scaffoldQuestion(opts) {
     description: opts.description,
     signature: opts.signature || "",
     testCode: opts.testCode || "",
-    solutionCode: opts.solutionCode || "",
-    htmlCode: opts.htmlCode || ""
+    solutionCode: opts.solutionCode || ""
   };
   const readmeTemplate = loadTemplate(path.join(TEMPLATES_DIR, "readme.md.hbs"));
   fs.writeFileSync(path.join(questionDir, "README.md"), readmeTemplate(templateData));
@@ -67,15 +66,6 @@ function scaffoldQuestion(opts) {
         fs.writeFileSync(path.join(questionDir, testFile), opts.testCode);
       }
     }
-    if (config.solutionFiles.includes("index.html") && opts.htmlCode) {
-      fs.writeFileSync(path.join(questionDir, "index.html"), opts.htmlCode);
-    } else {
-      const htmlTemplatePath = path.join(templateDir, "index.html.hbs");
-      if (fs.existsSync(htmlTemplatePath) && config.solutionFiles.includes("index.html")) {
-        const tmpl = loadTemplate(htmlTemplatePath);
-        fs.writeFileSync(path.join(questionDir, "index.html"), tmpl(templateData));
-      }
-    }
   }
   const scorecard = createScorecard(opts.title, opts.category, opts.difficulty);
   writeScorecard(opts.category, opts.slug, scorecard);

package/dist/lib/scorecard.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { getSuggestedTime } from "./categories.js";
+import prompts from "prompts";
+import chalk from "chalk";
+import { getSuggestedTime, CATEGORIES } from "./categories.js";
 import { resolveWorkspaceRoot, getQuestionsDir } from "./paths.js";
 function getScorecardPath(category, slug) {
   const root = resolveWorkspaceRoot();
@@ -102,12 +104,41 @@ function findQuestion(slug) {
   }
   return null;
 }
+async function promptForSlug() {
+  const questions = getAllQuestions();
+  if (questions.length === 0) {
+    console.log(chalk.yellow("No questions found. Create one first with `ace generate` or `ace add`."));
+    return null;
+  }
+  const choices = questions.map((q) => {
+    const categoryName = CATEGORIES[q.category]?.shortName || q.category;
+    const statusColors = {
+      untouched: chalk.gray,
+      "in-progress": chalk.yellow,
+      attempted: chalk.red,
+      solved: chalk.green
+    };
+    const statusColor = statusColors[q.scorecard.status] || chalk.white;
+    return {
+      title: `${chalk.cyan(categoryName)} / ${q.slug} ${statusColor(`(${q.scorecard.status})`)}`,
+      value: q.slug
+    };
+  });
+  const result = await prompts({
+    type: "select",
+    name: "slug",
+    message: "Select a question:",
+    choices
+  });
+  return result.slug || null;
+}
 export {
   createScorecard,
   findQuestion,
   getAllQuestions,
   getCurrentAttempt,
   getScorecardPath,
+  promptForSlug,
   readScorecard,
   resetScorecard,
   startNewAttempt,

package/dist/prompts/question-brainstorm.md

@@ -5,8 +5,8 @@ You are a collaborative interview question designer helping the user explore and
 ## Supported Categories
 
 - **js-ts**: JavaScript/TypeScript puzzles (closures, async, types)
-- **web-components**: Custom elements, Shadow DOM, lifecycle
-- **react-apps**: React components, hooks, state, rendering
+- **web-components**: React components (props, events, composition, reusable UI)
+- **react-apps**: React applications (hooks, state, routing, full features)
 - **leetcode-ds**: Data structure problems (trees, graphs, heaps)
 - **leetcode-algo**: Algorithm problems (DP, greedy, two pointers)
 - **design-fe**: Frontend system design (component architecture, state, rendering)

package/dist/prompts/question-generate.md

@@ -22,26 +22,35 @@ Return a JSON object with:
   "title": "Human-readable question title",
   "slug": "kebab-case-slug",
   "description": "Markdown description with problem statement, examples, constraints",
-  "signature": "Function signature or component interface the candidate must implement",
-  "testCode": "Full Vitest test file content as a string",
-  "solutionCode": "Stub implementation with the signature only (empty body or minimal placeholder)"
+  "signature": "The exported function/class signature line ONLY (see rules below)",
+  "testCode": "Full Vitest test file content as a string"
 }
 ```
 
+**CRITICAL — Do NOT include `solutionCode` in your response. Do NOT implement the solution.**
+
+The `signature` field must contain ONLY the bare function or class declaration line that the candidate will implement. It must NOT contain any logic, algorithm, data structure manipulation, loops, conditionals, or meaningful code.
+
+Good `signature` examples:
+- `export function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): T`
+- `export function deepClone<T>(obj: T): T`
+- `export class LRUCache<K, V>`
+
+Bad `signature` examples (NEVER do this):
+- A full function body with implementation logic
+- Code that includes `if`, `for`, `while`, `map`, `reduce`, `setTimeout`, or any working logic
+- A complete class with method implementations
+
 **Test requirements:**
 - Generate 6–10 test cases covering: happy path, edge cases, and performance-sensitive scenarios
-- For **React** questions: use `@testing-library/react` with `render` and `screen`
+- For **React** questions (`react-apps`, `web-components`): use `@testing-library/react` with `render` and `screen`
 - Imports must reference the solution file correctly:
   - `js-ts`, `leetcode-ds`, `leetcode-algo`: `import { solution } from './solution'`
   - `react-apps`: `import App from './App'`
-  - `web-components`: import the component from the appropriate file (e.g., `'./component'`)
+  - `web-components`: `import { ComponentName } from './Component'` (named export)
 - Use `describe`, `it`, `expect` from Vitest
 - Tests must be self-contained and runnable
 
-**Solution stub:**
-- Include the exact function/component signature the candidate must implement
-- Leave the body empty or with a minimal placeholder (e.g., `throw new Error('Not implemented')` or `return null`)
-
 ### For Design Categories (design-fe, design-be, design-full)
 
 Return a JSON object with:
@@ -62,4 +71,4 @@ Return a JSON object with:
 - Questions should be achievable within the suggested time for the category and difficulty
 - Avoid ambiguous wording; constraints and expected behavior should be explicit
 - For LeetCode-style questions: include time/space complexity expectations in the description
-- For React/Web Components: focus on realistic UI behavior, not toy examples
+- For React questions (`react-apps`, `web-components`): focus on realistic UI behavior, not toy examples

package/dist/templates/web-components/Component.test.tsx.hbs

@@ -0,0 +1,16 @@
+{{#if testCode}}
+{{{testCode}}}
+{{else}}
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { Component } from './Component';
+
+describe('{{title}}', () => {
+  it('renders without crashing', () => {
+    render(<Component />);
+    expect(screen.getByText('{{title}}')).toBeDefined();
+  });
+
+  it.todo('add more test cases');
+});
+{{/if}}

package/dist/templates/web-components/Component.tsx.hbs

@@ -0,0 +1,29 @@
+{{#if solutionCode}}
+{{{solutionCode}}}
+{{else}}
+{{#if signature}}
+import React from 'react';
+
+{{{signature}}} {
+  return (
+    <div>
+      <h1>{{title}}</h1>
+      {/* TODO: implement */}
+    </div>
+  );
+}
+{{else}}
+import React from 'react';
+
+// TODO: implement your React component here
+
+export function Component() {
+  return (
+    <div>
+      <h1>{{title}}</h1>
+      {/* TODO: implement */}
+    </div>
+  );
+}
+{{/if}}
+{{/if}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ace-interview-prep",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "CLI tool for frontend interview preparation — scaffolds questions with tests, tracks progress, and provides LLM-powered feedback",
   "type": "module",
   "bin": {

package/dist/templates/web-components/component.test.ts.hbs

@@ -1,11 +0,0 @@
-{{#if testCode}}
-{{{testCode}}}
-{{else}}
-import { describe, it, expect } from 'vitest';
-// TODO: import your component
-// import './component';
-
-describe('{{title}}', () => {
-  it.todo('add test cases');
-});
-{{/if}}

package/dist/templates/web-components/component.ts.hbs

@@ -1,22 +0,0 @@
-{{#if solutionCode}}
-{{{solutionCode}}}
-{{else}}
-{{#if signature}}
-{{{signature}}}
-{{else}}
-// TODO: implement your web component here
-
-export class MyComponent extends HTMLElement {
-  constructor() {
-    super();
-    this.attachShadow({ mode: 'open' });
-  }
-
-  connectedCallback() {
-    // TODO: implement
-  }
-}
-
-// customElements.define('my-component', MyComponent);
-{{/if}}
-{{/if}}

package/dist/templates/web-components/index.html.hbs

@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>{{title}}</title>
-</head>
-<body>
-  <!-- TODO: use your web component here -->
-  <script type="module" src="./component.ts"></script>
-</body>
-</html>

package/questions/web-components/star-rating/README.md

@@ -1,45 +0,0 @@
-# Build a Star Rating Web Component
-
-**Category:** Web Components  
-**Difficulty:** Medium  
-**Suggested Time:** ~35 minutes
-
----
-
-## Problem
-
-Build a `<star-rating>` custom element that displays 5 stars, allows users to click to rate, has a `value` attribute/property, and dispatches a `change` event when the rating changes.
-
-## Requirements
-
-- **Display** — Render 5 star elements (you may use Unicode stars ★/☆, SVG, or styled spans).
-- **Click to rate** — Clicking a star sets the rating to that star's index (1–5).
-- **`value` attribute** — The component accepts a `value` attribute (e.g. `<star-rating value="3">`) to show the initial or current rating.
-- **`value` property** — The component exposes a `value` getter/setter that reflects and updates the rating.
-- **`change` event** — When the user clicks a star, dispatch a `change` event with the new value (e.g. `detail: { value: 3 }`).
-
-## Example Usage
-
-```html
-<star-rating value="3"></star-rating>
-```
-
-```js
-const el = document.querySelector('star-rating');
-el.value = 4;
-el.addEventListener('change', (e) => console.log('New rating:', e.detail.value));
-```
-
-## Constraints
-
-- Use the Custom Elements API (extend `HTMLElement`).
-- Use Shadow DOM for encapsulation.
-- Observe the `value` attribute and sync it with the internal state.
-- Clamp `value` to 0–5 (0 = no stars selected).
-
-## Hints
-
-- Use `attachShadow({ mode: 'open' })` in the constructor.
-- Use `static get observedAttributes()` to return `['value']`.
-- In `attributeChangedCallback`, parse the attribute and update the display.
-- Use `CustomEvent` with `detail: { value }` for the change event.

package/questions/web-components/star-rating/component.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import './component';
-
-describe('star-rating', () => {
-  let el: HTMLElement & { value: number };
-
-  beforeEach(() => {
-    el = document.createElement('star-rating') as HTMLElement & { value: number };
-    document.body.appendChild(el);
-  });
-
-  afterEach(() => {
-    el.remove();
-  });
-
-  it('renders 5 star elements', () => {
-    const stars = el.shadowRoot?.querySelectorAll('[data-star]') ?? [];
-    expect(stars.length).toBe(5);
-  });
-
-  it('default value is 0', () => {
-    expect(el.value).toBe(0);
-  });
-
-  it('setting value attribute updates display', () => {
-    el.setAttribute('value', '3');
-    expect(el.value).toBe(3);
-  });
-
-  it('clicking a star updates value', () => {
-    const stars = el.shadowRoot?.querySelectorAll('[data-star]') ?? [];
-    (stars[2] as HTMLElement).click();
-    expect(el.value).toBe(3);
-  });
-
-  it('dispatches change event on click', () => {
-    let receivedValue: number | undefined;
-    const handler = (e: Event) => {
-      receivedValue = (e as CustomEvent).detail?.value;
-    };
-    el.addEventListener('change', handler);
-
-    const stars = el.shadowRoot?.querySelectorAll('[data-star]') ?? [];
-    (stars[3] as HTMLElement).click();
-
-    expect(receivedValue).toBe(4);
-    el.removeEventListener('change', handler);
-  });
-
-  it('value property reflects attribute', () => {
-    el.setAttribute('value', '2');
-    expect(el.value).toBe(2);
-  });
-
-  it('setting value property updates attribute', () => {
-    el.value = 5;
-    expect(el.getAttribute('value')).toBe('5');
-  });
-
-  it('clamps value to 0-5', () => {
-    el.setAttribute('value', '10');
-    expect(el.value).toBeLessThanOrEqual(5);
-  });
-});

package/questions/web-components/star-rating/component.ts

@@ -1,28 +0,0 @@
-export class StarRating extends HTMLElement {
-  constructor() {
-    super();
-    this.attachShadow({ mode: 'open' });
-  }
-
-  connectedCallback() {
-    // TODO: implement - render 5 stars, handle click, support value attribute
-  }
-
-  static get observedAttributes() {
-    return ['value'];
-  }
-
-  attributeChangedCallback(_name: string, _oldValue: string | null, _newValue: string | null) {
-    // TODO: implement
-  }
-
-  get value(): number {
-    return 0; // TODO: implement
-  }
-
-  set value(_val: number) {
-    // TODO: implement
-  }
-}
-
-customElements.define('star-rating', StarRating);

package/questions/web-components/star-rating/index.html

@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Star Rating Component</title>
-</head>
-<body>
-  <h1>Star Rating</h1>
-  <star-rating value="3"></star-rating>
-
-  <script type="module" src="./component.ts"></script>
-</body>
-</html>

package/questions/web-components/star-rating/scorecard.json

@@ -1,9 +0,0 @@
-{
-  "title": "Build a Star Rating Component",
-  "category": "web-components",
-  "difficulty": "medium",
-  "suggestedTime": 35,
-  "status": "untouched",
-  "attempts": [],
-  "llmFeedback": null
-}