ace-interview-prep 0.1.2 → 0.1.4

package/README.md

@@ -1,10 +1,9 @@
 # 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.
+A CLI tool for interview prep focusing on frontend. Scaffolds questions with test cases, tracks progress with scorecards, and provides LLM-powered feedback.
 
 ## Install
 
@@ -12,12 +11,6 @@ A CLI tool for staff-engineer-level frontend interview preparation. Scaffolds qu
 npm install -g ace-interview-prep
 ```
 
-Or run directly with npx:
-
-```bash
-npx ace-interview-prep help
-```
-
 ## Quick Start
 
 ### 1. Configure API Keys
@@ -27,30 +20,50 @@ ace setup
 ```
 
 Stores your OpenAI / Anthropic API keys in `~/.ace/config.json` (one-time, works across all workspaces).
+If both keys are valid, `ace setup` prompts you to choose a default provider (`openai` or `anthropic`).
 
 ```bash
 # Non-interactive
 ace setup --openai-key sk-... --anthropic-key sk-ant-...
+
+# Set default provider explicitly when both keys are configured
+ace setup --openai-key sk-... --anthropic-key sk-ant-... --default-provider anthropic
 ```
 
 ### 2. Initialize a Workspace
 
-Navigate to any folder where you want to practice:
+Navigate to any folder where you want to practice, then run:
 
 ```bash
 ace init
 ```
 
-Creates a `questions/` directory and vitest config files. Then install the test dependencies:
+`ace init` bootstraps the workspace and installs dependencies for you. It:
+
+```bash
+# Creates/updates workspace files
+# - questions/
+# - package.json (adds test scripts + devDependencies if missing)
+# - tsconfig.json
+# - vitest.config.ts
+# - vitest.setup.ts
+#
+# Installs dependencies automatically via npm install
+```
+
+If you need to regenerate workspace files:
 
 ```bash
-npm install vitest happy-dom @testing-library/jest-dom
+ace init --force
 ```
 
 ### 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 +74,77 @@ 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
+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)
+```
+
+### 5. Dispute Potentially Incorrect Tests
+
+Use this when your implementation appears correct but a generated test assertion might be wrong.
 
-# Reset a question
-ace reset debounce
+```bash
+# Dispute interactively (pick a question)
+ace dispute
+
+# Dispute a specific question
+ace dispute debounce
+
+# Optional: force a provider for dispute analysis
+ace dispute debounce --provider anthropic
 ```
 
+If the verdict says the test is incorrect (or ambiguous), ace can apply a corrected test file and re-run tests.
+
 ## 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
 
@@ -107,11 +154,13 @@ ace reset debounce
 - `~/.ace/.env` — fallback (dotenv format)
 - Environment variables — final fallback
 
-**Workspace** — each workspace gets its own `questions/` directory and test config.
+Typical `~/.ace/config.json` keys:
 
-## Seed Questions
+- `OPENAI_API_KEY`
+- `ANTHROPIC_API_KEY`
+- `default_provider` (set automatically or via `ace setup --default-provider ...`)
 
-Ships with 8 starter questions (one per category) so you can begin practicing immediately after install.
+**Workspace** — each workspace gets its own `questions/` directory and test config.
 
 ## Development
 

package/dist/commands/dispute.js

@@ -0,0 +1,226 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import prompts from "prompts";
+import chalk from "chalk";
+import { findQuestion, readScorecard, writeScorecard, promptForSlug } from "../lib/scorecard.js";
+import { CATEGORIES, isDesignCategory } from "../lib/categories.js";
+import { chat, 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 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;
+}
+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 };
+}
+function runTestsAndCapture(projectRoot, questionDir) {
+  const result = spawnSync("npx", ["vitest", "run", questionDir], {
+    cwd: projectRoot,
+    encoding: "utf-8"
+  });
+  const stdout = result.stdout || "";
+  const stderr = result.stderr || "";
+  const output = [stdout, stderr].filter(Boolean).join("\n");
+  const exitCode = typeof result.status === "number" ? result.status : 1;
+  return { output, exitCode };
+}
+async function run(args) {
+  const projectRoot = resolveWorkspaceRoot();
+  if (!isWorkspaceInitialized(projectRoot)) {
+    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);
+  let selectedSlug = parsed.slug;
+  if (!selectedSlug) {
+    selectedSlug = await promptForSlug();
+    if (!selectedSlug) return;
+  }
+  const question = findQuestion(selectedSlug);
+  if (!question) {
+    console.error(chalk.red(`Question not found: ${selectedSlug}`));
+    return;
+  }
+  if (isDesignCategory(question.category)) {
+    console.log(chalk.yellow(`"${selectedSlug}" is a system design question \u2014 no tests to dispute.`));
+    return;
+  }
+  const config = CATEGORIES[question.category];
+  const readmePath = path.join(question.dir, "README.md");
+  const readme = fs.existsSync(readmePath) ? fs.readFileSync(readmePath, "utf-8") : "";
+  if (!readme.trim()) {
+    console.error(chalk.red("No README.md found for this question."));
+    return;
+  }
+  let solutionContent = "";
+  for (const f of config.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 = "";
+  let testFilePath = "";
+  for (const f of config.testFiles) {
+    const fp = path.join(question.dir, f);
+    if (fs.existsSync(fp)) {
+      testContent += fs.readFileSync(fp, "utf-8");
+      testFilePath = fp;
+    }
+  }
+  if (!testContent.trim()) {
+    console.error(chalk.red("No test file found for this question."));
+    return;
+  }
+  console.log(chalk.cyan(`
+Running tests for "${selectedSlug}" to capture failures...
+`));
+  const initialRun = runTestsAndCapture(projectRoot, question.dir);
+  const testOutput = initialRun.output;
+  if (initialRun.exitCode === 0) {
+    console.log(chalk.green("All tests are passing \u2014 nothing to dispute."));
+    return;
+  }
+  const provider = requireProvider(parsed.provider);
+  console.log(chalk.yellow("\nFailing tests detected. Sending to LLM for analysis...\n"));
+  const systemPrompt = loadPrompt("test-dispute.md");
+  const userContent = `## Problem Statement
+${readme}
+
+## Solution Code
+${solutionContent}
+
+## Test File
+${testContent}
+
+## Test Failure Output
+\`\`\`
+${testOutput}
+\`\`\``;
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userContent }
+  ];
+  const spinner = ["|", "/", "-", "\\"];
+  let spinIdx = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${chalk.cyan(spinner[spinIdx++ % spinner.length])} Analyzing...`);
+  }, 120);
+  let response;
+  try {
+    response = await chat(provider, messages, true);
+  } finally {
+    clearInterval(interval);
+    process.stdout.write("\r" + " ".repeat(30) + "\r");
+  }
+  let result;
+  try {
+    result = JSON.parse(extractJSON(response));
+  } catch {
+    console.error(chalk.red("Failed to parse LLM response."));
+    console.log(chalk.dim(response));
+    return;
+  }
+  const verdictColors = {
+    test_incorrect: chalk.green,
+    solution_incorrect: chalk.red,
+    ambiguous: chalk.yellow
+  };
+  const verdictLabels = {
+    test_incorrect: "Test is incorrect",
+    solution_incorrect: "Solution has a bug",
+    ambiguous: "Ambiguous specification"
+  };
+  const color = verdictColors[result.verdict] || chalk.white;
+  const label = verdictLabels[result.verdict] || result.verdict;
+  console.log(chalk.bold(`
+Verdict: ${color(label)}
+`));
+  console.log(result.summary);
+  console.log(chalk.dim("\n--- Details ---\n"));
+  console.log(result.details);
+  if (result.failingTests?.length) {
+    console.log(chalk.dim("\n--- Per-Test Breakdown ---\n"));
+    for (const t of result.failingTests) {
+      const tColor = verdictColors[t.verdict] || chalk.white;
+      console.log(`  ${tColor("\u25CF")} ${chalk.bold(t.testName)}: ${tColor(verdictLabels[t.verdict] || t.verdict)}`);
+      console.log(`    ${t.explanation}`);
+      if (t.fixedAssertion) {
+        console.log(chalk.dim(`    Fix: ${t.fixedAssertion}`));
+      }
+    }
+  }
+  if ((result.verdict === "test_incorrect" || result.verdict === "ambiguous") && result.fixedTestCode) {
+    console.log("");
+    const { confirm } = await prompts({
+      type: "confirm",
+      name: "confirm",
+      message: "Apply the corrected test file?",
+      initial: true
+    });
+    if (confirm) {
+      fs.writeFileSync(testFilePath, result.fixedTestCode, "utf-8");
+      console.log(chalk.green(`
+Test file updated: ${path.relative(projectRoot, testFilePath)}`));
+      console.log(chalk.cyan("\nRe-running tests to verify...\n"));
+      const verifyRun = runTestsAndCapture(projectRoot, question.dir);
+      const verifyOutput = verifyRun.output;
+      console.log(verifyOutput);
+      const scorecard = readScorecard(question.category, selectedSlug);
+      if (scorecard) {
+        const passMatch = verifyOutput.match(/(\d+)\s+passed/);
+        const failMatch = verifyOutput.match(/(\d+)\s+failed/);
+        const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
+        const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
+        const total = passed + failed;
+        if (total > 0) {
+          if (scorecard.attempts.length === 0) {
+            scorecard.attempts.push({ attempt: 1, testsTotal: 0, testsPassed: 0, llmScore: null });
+          }
+          const current = scorecard.attempts[scorecard.attempts.length - 1];
+          current.testsTotal = total;
+          current.testsPassed = passed;
+          scorecard.status = passed === total ? "solved" : "attempted";
+          writeScorecard(question.category, selectedSlug, scorecard);
+          const resultColor = passed === total ? chalk.green : chalk.yellow;
+          console.log(resultColor(`Scorecard updated: ${passed}/${total} tests passed`));
+        }
+      }
+    } else {
+      console.log(chalk.dim("No changes made."));
+    }
+  } else if (result.verdict === "solution_incorrect" && result.hint) {
+    console.log(chalk.dim("\n--- Hint ---\n"));
+    console.log(chalk.yellow(result.hint));
+  }
+}
+export {
+  run
+};

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