ace-interview-prep 0.1.0

package/dist/lib/llm.js

@@ -0,0 +1,134 @@
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+import chalk from "chalk";
+import { loadAceConfig } from "./config.js";
+let cachedConfig = null;
+function getConfig() {
+  if (!cachedConfig) {
+    cachedConfig = loadAceConfig();
+  }
+  return cachedConfig;
+}
+function getAvailableProviders() {
+  const config = getConfig();
+  const providers = [];
+  if (config.OPENAI_API_KEY) providers.push("openai");
+  if (config.ANTHROPIC_API_KEY) providers.push("anthropic");
+  return providers;
+}
+function getDefaultProvider() {
+  const providers = getAvailableProviders();
+  if (providers.length === 0) return null;
+  return providers[0];
+}
+function requireProvider(preferred) {
+  const config = getConfig();
+  if (preferred === "openai" || preferred === "anthropic") {
+    const key = preferred === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY";
+    if (!config[key]) {
+      console.error(chalk.red(`Error: ${key} is not configured.`));
+      console.error(chalk.dim("Run `ace setup` to configure API keys."));
+      process.exit(1);
+    }
+    return preferred;
+  }
+  const provider = getDefaultProvider();
+  if (!provider) {
+    console.error(chalk.red("Error: No LLM API key found."));
+    console.error(chalk.dim("Run `ace setup` to configure API keys."));
+    process.exit(1);
+  }
+  return provider;
+}
+async function callOpenAI(messages, jsonMode = false) {
+  const config = getConfig();
+  const client = new OpenAI({ apiKey: config.OPENAI_API_KEY });
+  const response = await client.chat.completions.create({
+    model: "gpt-4o",
+    messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    temperature: 0.7,
+    max_tokens: 4096,
+    ...jsonMode ? { response_format: { type: "json_object" } } : {}
+  });
+  return response.choices[0]?.message?.content ?? "";
+}
+async function callAnthropic(messages, _jsonMode = false) {
+  const config = getConfig();
+  const client = new Anthropic({ apiKey: config.ANTHROPIC_API_KEY });
+  const systemMsg = messages.find((m) => m.role === "system");
+  const nonSystemMessages = messages.filter((m) => m.role !== "system");
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    ...systemMsg ? { system: systemMsg.content } : {},
+    messages: nonSystemMessages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }))
+  });
+  const block = response.content[0];
+  if (block.type === "text") return block.text;
+  return "";
+}
+async function chat(provider, messages, jsonMode = false) {
+  if (provider === "openai") {
+    return callOpenAI(messages, jsonMode);
+  }
+  return callAnthropic(messages, jsonMode);
+}
+async function streamOpenAI(messages) {
+  const config = getConfig();
+  const client = new OpenAI({ apiKey: config.OPENAI_API_KEY });
+  const stream = await client.chat.completions.create({
+    model: "gpt-4o",
+    messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    temperature: 0.7,
+    max_tokens: 4096,
+    stream: true
+  });
+  return {
+    async *[Symbol.asyncIterator]() {
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content;
+        if (delta) yield delta;
+      }
+    }
+  };
+}
+async function streamAnthropic(messages) {
+  const config = getConfig();
+  const client = new Anthropic({ apiKey: config.ANTHROPIC_API_KEY });
+  const systemMsg = messages.find((m) => m.role === "system");
+  const nonSystemMessages = messages.filter((m) => m.role !== "system");
+  const stream = client.messages.stream({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    ...systemMsg ? { system: systemMsg.content } : {},
+    messages: nonSystemMessages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }))
+  });
+  return {
+    async *[Symbol.asyncIterator]() {
+      for await (const event of stream) {
+        if (event.type === "content_block_delta") {
+          const delta = event.delta;
+          if ("text" in delta) yield delta.text;
+        }
+      }
+    }
+  };
+}
+async function chatStream(provider, messages) {
+  if (provider === "openai") {
+    return streamOpenAI(messages);
+  }
+  return streamAnthropic(messages);
+}
+export {
+  chat,
+  chatStream,
+  getDefaultProvider,
+  requireProvider
+};

package/dist/lib/paths.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+function resolveWorkspaceRoot(startCwd = process.cwd()) {
+  let current = path.resolve(startCwd);
+  const root = path.parse(current).root;
+  while (current !== root) {
+    const questionsPath2 = path.join(current, "questions");
+    if (fs.existsSync(questionsPath2) && fs.statSync(questionsPath2).isDirectory()) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  const questionsPath = path.join(current, "questions");
+  if (fs.existsSync(questionsPath) && fs.statSync(questionsPath).isDirectory()) {
+    return current;
+  }
+  return path.resolve(startCwd);
+}
+function getQuestionsDir(root) {
+  return path.join(root, "questions");
+}
+function isWorkspaceInitialized(root) {
+  const questionsPath = getQuestionsDir(root);
+  return fs.existsSync(questionsPath) && fs.statSync(questionsPath).isDirectory();
+}
+function getHomeDir() {
+  return process.env.HOME || process.env.USERPROFILE || "~";
+}
+function getGlobalAceDir() {
+  return path.join(getHomeDir(), ".ace");
+}
+export {
+  getGlobalAceDir,
+  getHomeDir,
+  getQuestionsDir,
+  isWorkspaceInitialized,
+  resolveWorkspaceRoot
+};

package/dist/lib/scaffold.js

@@ -0,0 +1,110 @@
+import fs from "node:fs";
+import path from "node:path";
+import Handlebars from "handlebars";
+import { getCategoryConfig, getSuggestedTime, isDesignCategory } from "./categories.js";
+import { createScorecard, writeScorecard } from "./scorecard.js";
+import { resolveWorkspaceRoot, getQuestionsDir as getQuestionsDirPath } from "./paths.js";
+const TEMPLATES_DIR = path.resolve(import.meta.dirname, "../templates");
+function loadTemplate(templatePath) {
+  const raw = fs.readFileSync(templatePath, "utf-8");
+  return Handlebars.compile(raw);
+}
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function getQuestionDir(category, slug) {
+  const root = resolveWorkspaceRoot();
+  const questionsDir = getQuestionsDirPath(root);
+  return path.join(questionsDir, category, slug);
+}
+function scaffoldQuestion(opts) {
+  const config = getCategoryConfig(opts.category);
+  const questionDir = getQuestionDir(opts.category, opts.slug);
+  const suggestedTime = getSuggestedTime(opts.category, opts.difficulty);
+  if (fs.existsSync(questionDir)) {
+    throw new Error(`Question already exists: ${questionDir}`);
+  }
+  ensureDir(questionDir);
+  const templateData = {
+    title: opts.title,
+    slug: opts.slug,
+    category: config.name,
+    categorySlug: opts.category,
+    difficulty: opts.difficulty,
+    suggestedTime,
+    description: opts.description,
+    signature: opts.signature || "",
+    testCode: opts.testCode || "",
+    solutionCode: opts.solutionCode || "",
+    htmlCode: opts.htmlCode || ""
+  };
+  const readmeTemplate = loadTemplate(path.join(TEMPLATES_DIR, "readme.md.hbs"));
+  fs.writeFileSync(path.join(questionDir, "README.md"), readmeTemplate(templateData));
+  if (isDesignCategory(opts.category)) {
+    const notesTemplate = loadTemplate(path.join(TEMPLATES_DIR, "design", "notes.md.hbs"));
+    fs.writeFileSync(path.join(questionDir, "notes.md"), notesTemplate(templateData));
+  } else {
+    const templateDir = path.join(TEMPLATES_DIR, config.templateDir);
+    for (const solutionFile of config.solutionFiles) {
+      const templateFile = solutionFile + ".hbs";
+      const templatePath = path.join(templateDir, templateFile);
+      if (fs.existsSync(templatePath)) {
+        const tmpl = loadTemplate(templatePath);
+        fs.writeFileSync(path.join(questionDir, solutionFile), tmpl(templateData));
+      } else if (opts.solutionCode) {
+        fs.writeFileSync(path.join(questionDir, solutionFile), opts.solutionCode);
+      }
+    }
+    for (const testFile of config.testFiles) {
+      const templateFile = testFile + ".hbs";
+      const templatePath = path.join(templateDir, templateFile);
+      if (fs.existsSync(templatePath)) {
+        const tmpl = loadTemplate(templatePath);
+        fs.writeFileSync(path.join(questionDir, testFile), tmpl(templateData));
+      } else if (opts.testCode) {
+        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);
+  return questionDir;
+}
+function getStubContent(category, file) {
+  const config = getCategoryConfig(category);
+  const templateDir = path.join(TEMPLATES_DIR, config.templateDir);
+  const templateFile = file + ".hbs";
+  const templatePath = path.join(templateDir, templateFile);
+  if (fs.existsSync(templatePath)) {
+    const tmpl = loadTemplate(templatePath);
+    return tmpl({
+      title: "",
+      slug: "",
+      category: "",
+      categorySlug: category,
+      difficulty: "",
+      suggestedTime: 0,
+      description: "",
+      signature: "",
+      testCode: "",
+      solutionCode: ""
+    });
+  }
+  return "";
+}
+export {
+  getQuestionDir,
+  getStubContent,
+  scaffoldQuestion
+};

package/dist/lib/scorecard.js

@@ -0,0 +1,116 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getSuggestedTime } from "./categories.js";
+import { resolveWorkspaceRoot, getQuestionsDir } from "./paths.js";
+function getScorecardPath(category, slug) {
+  const root = resolveWorkspaceRoot();
+  const questionsDir = getQuestionsDir(root);
+  return path.join(questionsDir, category, slug, "scorecard.json");
+}
+function readScorecard(category, slug) {
+  const filepath = getScorecardPath(category, slug);
+  if (!fs.existsSync(filepath)) return null;
+  return JSON.parse(fs.readFileSync(filepath, "utf-8"));
+}
+function writeScorecard(category, slug, scorecard) {
+  const filepath = getScorecardPath(category, slug);
+  fs.writeFileSync(filepath, JSON.stringify(scorecard, null, 2) + "\n", "utf-8");
+}
+function createScorecard(title, category, difficulty) {
+  return {
+    title,
+    category,
+    difficulty,
+    suggestedTime: getSuggestedTime(category, difficulty),
+    status: "untouched",
+    attempts: [],
+    llmFeedback: null
+  };
+}
+function getCurrentAttempt(scorecard) {
+  if (scorecard.attempts.length === 0) return null;
+  return scorecard.attempts[scorecard.attempts.length - 1];
+}
+function startNewAttempt(scorecard) {
+  const attemptNum = scorecard.attempts.length + 1;
+  scorecard.attempts.push({
+    attempt: attemptNum,
+    testsTotal: 0,
+    testsPassed: 0,
+    llmScore: null
+  });
+  scorecard.status = "in-progress";
+  return scorecard;
+}
+function updateTestResults(scorecard, testsTotal, testsPassed) {
+  if (scorecard.attempts.length === 0) {
+    startNewAttempt(scorecard);
+  }
+  const current = scorecard.attempts[scorecard.attempts.length - 1];
+  current.testsTotal = testsTotal;
+  current.testsPassed = testsPassed;
+  if (testsTotal > 0 && testsPassed === testsTotal) {
+    scorecard.status = "solved";
+  } else if (testsTotal > 0) {
+    scorecard.status = "attempted";
+  }
+  return scorecard;
+}
+function resetScorecard(scorecard) {
+  scorecard.status = "untouched";
+  scorecard.llmFeedback = null;
+  return scorecard;
+}
+function getAllQuestions() {
+  const results = [];
+  const root = resolveWorkspaceRoot();
+  const questionsRoot = getQuestionsDir(root);
+  if (!fs.existsSync(questionsRoot)) return results;
+  for (const categoryDir of fs.readdirSync(questionsRoot)) {
+    const categoryPath = path.join(questionsRoot, categoryDir);
+    if (!fs.statSync(categoryPath).isDirectory()) continue;
+    for (const questionDir of fs.readdirSync(categoryPath)) {
+      const questionPath = path.join(categoryPath, questionDir);
+      if (!fs.statSync(questionPath).isDirectory()) continue;
+      const scorecardPath = path.join(questionPath, "scorecard.json");
+      if (!fs.existsSync(scorecardPath)) continue;
+      const scorecard = JSON.parse(fs.readFileSync(scorecardPath, "utf-8"));
+      results.push({
+        category: categoryDir,
+        slug: questionDir,
+        scorecard
+      });
+    }
+  }
+  return results;
+}
+function findQuestion(slug) {
+  const root = resolveWorkspaceRoot();
+  const questionsRoot = getQuestionsDir(root);
+  if (!fs.existsSync(questionsRoot)) return null;
+  for (const categoryDir of fs.readdirSync(questionsRoot)) {
+    const categoryPath = path.join(questionsRoot, categoryDir);
+    if (!fs.statSync(categoryPath).isDirectory()) continue;
+    const questionPath = path.join(categoryPath, slug);
+    if (fs.existsSync(questionPath) && fs.statSync(questionPath).isDirectory()) {
+      return {
+        category: categoryDir,
+        slug,
+        dir: questionPath
+      };
+    }
+  }
+  return null;
+}
+export {
+  createScorecard,
+  findQuestion,
+  getAllQuestions,
+  getCurrentAttempt,
+  getScorecardPath,
+  readScorecard,
+  resetScorecard,
+  startNewAttempt,
+  updateTestResults,
+  writeScorecard
+};

package/dist/prompts/code-review.md

@@ -0,0 +1,59 @@
+# Staff/Principal Engineer Code Review
+
+You are a staff or principal engineer conducting a code review of an interview candidate's solution. Evaluate the submission as you would in a real interview setting.
+
+## Context
+
+You will receive:
+- The **question** (title, description, category)
+- The **candidate's code** (solution implementation)
+
+## Evaluation Dimensions
+
+Score each dimension from **1 to 5** (1 = poor, 5 = excellent):
+
+1. **Correctness**: Does the solution produce the right output for the given inputs? Are there logical errors?
+2. **Edge Case Handling**: Does it handle empty inputs, null/undefined, boundary values, and unusual cases?
+3. **Time/Space Complexity**: Is the approach efficient? Does the candidate demonstrate awareness of Big O?
+4. **Code Quality**: Is the code clean, well-structured, and maintainable?
+5. **Readability**: Is it easy to follow? Naming, formatting, and organization.
+6. **Idiomatic Patterns**: Does it use language/framework conventions appropriately (e.g., React hooks, TypeScript types, standard algorithms)?
+
+## Output Format
+
+Provide your review in the following structure:
+
+### Scores (1–5 each)
+
+- Correctness: X
+- Edge Case Handling: X
+- Time/Space Complexity: X
+- Code Quality: X
+- Readability: X
+- Idiomatic Patterns: X
+
+### Overall Assessment
+
+One of: **Strong Hire** | **Hire** | **Lean Hire** | **No Hire**
+
+### 3 Things Done Well
+
+- [Specific reference to code with line/function names when possible]
+- [Specific reference]
+- [Specific reference]
+
+### 3 Areas to Improve
+
+- [Concrete suggestion with reference to code]
+- [Concrete suggestion]
+- [Concrete suggestion]
+
+### Critical Issues (if any)
+
+List any bugs, security concerns, or fundamental flaws that would block a hire. Omit this section if none.
+
+## Guidelines
+
+- Be **specific**: Reference actual code (function names, variable names, logic) rather than generic feedback
+- Be **fair**: Interview code is written under time pressure; focus on what matters
+- Be **constructive**: Frame improvements as learning opportunities, not criticism

package/dist/prompts/design-review.md

@@ -0,0 +1,67 @@
+# Staff/Principal Engineer System Design Review
+
+You are a staff or principal engineer conducting a system design interview review. Evaluate the candidate's design as you would in a real interview.
+
+## Context
+
+You will receive:
+- The **design question** (title, description, category)
+- The **candidate's notes** (their design document or outline)
+
+## Evaluation Dimensions
+
+Score each dimension from **1 to 5** (1 = poor, 5 = excellent):
+
+1. **Requirements Gathering**: Did they clarify scope, constraints, and success criteria before diving in?
+2. **High-Level Architecture**: Is the overall system structure clear and appropriate for the problem?
+3. **API Design**: Are endpoints, contracts, and data flows well-defined?
+4. **Data Model**: Are schemas, storage choices, and data flow sensible?
+5. **Deep Dive / Trade-offs**: Did they go deep on 1–2 areas and discuss alternatives?
+6. **Communication Clarity**: Was the design easy to follow? Logical flow, diagrams, structure.
+
+## Sub-Type Focus
+
+Adapt your emphasis based on the design category:
+
+- **design-fe (Frontend)**: Component architecture, state management, rendering strategy, client-side caching, accessibility
+- **design-be (Backend)**: Scalability, database choices, API design, consistency, fault tolerance
+- **design-full (Full Stack)**: End-to-end flow, client-server boundaries, data synchronization, deployment
+
+## Output Format
+
+Provide your review in the following structure:
+
+### Scores (1–5 each)
+
+- Requirements Gathering: X
+- High-Level Architecture: X
+- API Design: X
+- Data Model: X
+- Deep Dive / Trade-offs: X
+- Communication Clarity: X
+
+### Overall Assessment
+
+One of: **Strong Hire** | **Hire** | **Lean Hire** | **No Hire**
+
+### 3 Strengths
+
+- [Specific reference to their design with concrete examples]
+- [Specific reference]
+- [Specific reference]
+
+### 3 Areas to Improve (with concrete suggestions)
+
+- [What to add or change, with a concrete suggestion]
+- [What to add or change]
+- [What to add or change]
+
+### Critical Gaps (if any)
+
+List any major omissions (e.g., missing scalability plan, no error handling, unclear requirements). Omit this section if none.
+
+## Guidelines
+
+- Be **specific**: Reference sections of their design, not generic advice
+- Be **fair**: Interview designs are exploratory; focus on reasoning and trade-off thinking
+- Be **constructive**: Suggest what they could add or refine, not just what's wrong

package/dist/prompts/question-brainstorm.md

@@ -0,0 +1,31 @@
+# Collaborative Interview Question Designer
+
+You are a collaborative interview question designer helping the user explore and refine question ideas for the "ace" interview prep CLI.
+
+## Supported Categories
+
+- **js-ts**: JavaScript/TypeScript puzzles (closures, async, types)
+- **web-components**: Custom elements, Shadow DOM, lifecycle
+- **react-apps**: React components, hooks, state, rendering
+- **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)
+- **design-be**: Backend system design (APIs, databases, scalability)
+- **design-full**: Full-stack system design (end-to-end flows)
+
+## Your Role
+
+1. **Explore**: When the user shares an interest area (e.g., "React performance", "rate limiting", "virtual scrolling"), suggest 3–5 specific question directions that would work well for interview prep.
+2. **Refine**: Based on user feedback, adjust constraints, difficulty, or scope. Add or remove requirements as requested.
+3. **Finalize**: When the user confirms a direction, output a clear, concise question description that can be fed directly into the question generation prompt. Include:
+   - Category
+   - Difficulty
+   - Topic/focus area
+   - 1–2 sentences of what the question should cover
+
+## Style
+
+- Keep responses **concise** and **conversational**
+- Avoid long paragraphs; use bullets when listing options
+- Ask clarifying questions when the user's intent is ambiguous
+- Don't over-explain; match the user's level of detail

package/dist/prompts/question-generate.md

@@ -0,0 +1,65 @@
+# Senior Interview Question Author
+
+You are a senior frontend interview question author targeting staff-engineer level candidates. Your questions are rigorous, realistic, and well-scoped.
+
+## Input
+
+You will receive:
+- **category**: One of `js-ts`, `web-components`, `react-apps`, `leetcode-ds`, `leetcode-algo`, `design-fe`, `design-be`, `design-full`
+- **difficulty**: `easy`, `medium`, or `hard`
+- **topic**: A specific area to focus on (e.g., "closures", "virtual DOM", "LRU cache", "rate limiting")
+
+## Output Format
+
+**IMPORTANT**: Your response MUST be valid JSON wrapped in ```json code fences. No other text before or after.
+
+### For Coding Categories (js-ts, web-components, react-apps, leetcode-ds, leetcode-algo)
+
+Return a JSON object with:
+
+```json
+{
+  "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)"
+}
+```
+
+**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`
+- 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'`)
+- 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:
+
+```json
+{
+  "title": "Human-readable design question title",
+  "slug": "kebab-case-slug",
+  "description": "Markdown description including a **Requirements** section (functional and non-functional)"
+}
+```
+
+- No `signature`, `testCode`, or `solutionCode`
+- The description must include a clear **Requirements** section that candidates can use to structure their design
+
+## Quality Guidelines
+
+- 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

package/dist/templates/design/notes.md.hbs

@@ -0,0 +1,27 @@
+# {{title}} — Design Notes
+
+## Requirements
+
+### Functional Requirements
+<!-- List the core features and user-facing requirements -->
+
+### Non-Functional Requirements
+<!-- Performance, scalability, availability, security, etc. -->
+
+## High-Level Architecture
+<!-- Describe the overall system architecture. Include component hierarchy, services, data flow. -->
+
+## Data Model
+<!-- Define key data structures, schemas, client-side state shape, caching strategy -->
+
+## API Design
+<!-- Endpoint design, data contracts, request/response formats, error handling -->
+
+## Deep Dive
+<!-- Pick 1-2 areas to go deep on: rendering, state management, real-time, etc. -->
+
+## Scaling Considerations
+<!-- How does this scale? CDN, lazy loading, pagination, sharding, etc. -->
+
+## Trade-offs
+<!-- What trade-offs did you make? What alternatives did you consider? -->

package/dist/templates/js-ts/solution.test.ts.hbs

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

package/dist/templates/js-ts/solution.ts.hbs

@@ -0,0 +1,11 @@
+{{#if solutionCode}}
+{{{solutionCode}}}
+{{else}}
+{{#if signature}}
+{{{signature}}} {
+  // TODO: implement
+}
+{{else}}
+// TODO: implement your solution here
+{{/if}}
+{{/if}}

package/dist/templates/leetcode-algo/solution.test.ts.hbs

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