ace-interview-prep 0.1.0

package/dist/commands/list.js

@@ -0,0 +1,107 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import { CATEGORIES } from "../lib/categories.js";
+import { getAllQuestions } from "../lib/scorecard.js";
+import { resolveWorkspaceRoot, isWorkspaceInitialized } from "../lib/paths.js";
+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;
+}
+const STATUS_COLORS = {
+  untouched: chalk.gray,
+  "in-progress": chalk.yellow,
+  attempted: chalk.red,
+  solved: chalk.green
+};
+const DIFFICULTY_COLORS = {
+  easy: chalk.green,
+  medium: chalk.yellow,
+  hard: chalk.red
+};
+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 filterCategory = parsed.category;
+  const filterStatus = parsed.status;
+  const filterDifficulty = parsed.difficulty;
+  let questions = getAllQuestions();
+  if (filterCategory) {
+    questions = questions.filter((q) => q.category === filterCategory);
+  }
+  if (filterStatus) {
+    questions = questions.filter((q) => q.scorecard.status === filterStatus);
+  }
+  if (filterDifficulty) {
+    questions = questions.filter((q) => q.scorecard.difficulty === filterDifficulty);
+  }
+  if (questions.length === 0) {
+    console.log(chalk.yellow("\nNo questions found."));
+    console.log(chalk.dim("Use `npm run ace generate` or `npm run ace add` to create one."));
+    return;
+  }
+  const table = new Table({
+    head: [
+      chalk.bold("Category"),
+      chalk.bold("Question"),
+      chalk.bold("Difficulty"),
+      chalk.bold("Status"),
+      chalk.bold("~Time")
+    ],
+    style: { head: [], border: [] }
+  });
+  questions.sort((a, b) => {
+    if (a.category !== b.category) return a.category.localeCompare(b.category);
+    return a.slug.localeCompare(b.slug);
+  });
+  for (const q of questions) {
+    const config = CATEGORIES[q.category];
+    const sc = q.scorecard;
+    const diffColor = DIFFICULTY_COLORS[sc.difficulty] || chalk.white;
+    const statusColor = STATUS_COLORS[sc.status] || chalk.white;
+    table.push([
+      config?.shortName || q.category,
+      q.slug,
+      diffColor(sc.difficulty),
+      statusColor(sc.status),
+      `~${sc.suggestedTime}m`
+    ]);
+  }
+  console.log(`
+${chalk.bold.cyan("ace")} \u2014 Question Dashboard
+`);
+  console.log(table.toString());
+  console.log(chalk.dim(`
+  ${questions.length} question(s) total`));
+  const solved = questions.filter((q) => q.scorecard.status === "solved").length;
+  const attempted = questions.filter((q) => q.scorecard.status === "attempted").length;
+  const inProgress = questions.filter((q) => q.scorecard.status === "in-progress").length;
+  if (solved > 0 || attempted > 0 || inProgress > 0) {
+    console.log(
+      chalk.dim(
+        `  ${chalk.green(String(solved))} solved \xB7 ${chalk.yellow(String(inProgress))} in-progress \xB7 ${chalk.red(String(attempted))} attempted`
+      )
+    );
+  }
+  console.log(chalk.dim("\n  Filters: --category <slug> | --status <status> | --difficulty <level>\n"));
+}
+export {
+  run
+};

package/dist/commands/reset.js

@@ -0,0 +1,68 @@
+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 { 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;
+  }
+  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) {
+    const notesPath = path.join(question.dir, "notes.md");
+    const stubContent = getStubContent(question.category, "notes.md");
+    if (stubContent) {
+      fs.writeFileSync(notesPath, stubContent);
+    }
+  } 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) {
+        fs.writeFileSync(filePath, stubContent);
+      }
+    }
+  }
+  const scorecard = readScorecard(question.category, slug);
+  if (scorecard) {
+    resetScorecard(scorecard);
+    startNewAttempt(scorecard);
+    scorecard.status = "untouched";
+    writeScorecard(question.category, slug, scorecard);
+  }
+  console.log(chalk.green(`
+Reset: questions/${question.category}/${slug}/`));
+  console.log(chalk.dim("Solution files restored to stubs. Scorecard updated."));
+}
+export {
+  run
+};

package/dist/commands/score.js

@@ -0,0 +1,70 @@
+import chalk from "chalk";
+import { findQuestion, readScorecard } 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];
+  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("Difficulty:")}   ${scorecard.difficulty}`);
+  console.log(`  ${chalk.bold("Suggested:")}    ~${scorecard.suggestedTime} minutes`);
+  const statusColors = {
+    untouched: chalk.gray,
+    "in-progress": chalk.yellow,
+    attempted: chalk.red,
+    solved: chalk.green
+  };
+  const statusColor = statusColors[scorecard.status] || chalk.white;
+  console.log(`  ${chalk.bold("Status:")}       ${statusColor(scorecard.status)}`);
+  if (scorecard.attempts.length > 0) {
+    console.log(`
+${chalk.bold("  Attempts:")}`);
+    for (const attempt of scorecard.attempts) {
+      const testInfo = attempt.testsTotal > 0 ? `${attempt.testsPassed}/${attempt.testsTotal} tests` : "no tests run";
+      const scoreInfo = attempt.llmScore !== null ? ` \xB7 LLM: ${attempt.llmScore}/5` : "";
+      const color = attempt.testsPassed === attempt.testsTotal && attempt.testsTotal > 0 ? chalk.green : chalk.yellow;
+      console.log(`    #${attempt.attempt}: ${color(testInfo)}${scoreInfo}`);
+    }
+  } else {
+    console.log(chalk.dim("\n  No attempts yet."));
+  }
+  if (scorecard.llmFeedback) {
+    console.log(`
+${chalk.bold("  Last LLM Feedback:")}`);
+    const lines = scorecard.llmFeedback.split("\n").slice(0, 15);
+    for (const line of lines) {
+      console.log(`  ${chalk.dim(line)}`);
+    }
+    if (scorecard.llmFeedback.split("\n").length > 15) {
+      console.log(chalk.dim("  ... (run `ace feedback` for full review)"));
+    }
+  }
+  console.log(chalk.dim("\n" + "\u2500".repeat(60)));
+}
+export {
+  run
+};

package/dist/commands/setup.js

@@ -0,0 +1,84 @@
+import prompts from "prompts";
+import chalk from "chalk";
+import { saveGlobalAceConfig, maskApiKey, loadAceConfig } from "../lib/config.js";
+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;
+}
+async function run(args) {
+  const parsed = parseArgs(args);
+  console.log(chalk.cyan("\n--- Setup API Keys ---"));
+  console.log(chalk.dim("API keys will be stored in ~/.ace/config.json\n"));
+  let openaiKey = parsed["openai-key"];
+  let anthropicKey = parsed["anthropic-key"];
+  const existing = loadAceConfig();
+  if (!openaiKey && !anthropicKey) {
+    const { openai } = await prompts({
+      type: "text",
+      name: "openai",
+      message: "OpenAI API Key (leave blank to skip):",
+      initial: existing.OPENAI_API_KEY ? maskApiKey(existing.OPENAI_API_KEY) : ""
+    });
+    const { anthropic } = await prompts({
+      type: "text",
+      name: "anthropic",
+      message: "Anthropic API Key (leave blank to skip):",
+      initial: existing.ANTHROPIC_API_KEY ? maskApiKey(existing.ANTHROPIC_API_KEY) : ""
+    });
+    openaiKey = openai;
+    anthropicKey = anthropic;
+  }
+  if (openaiKey && openaiKey.startsWith("...")) {
+    openaiKey = void 0;
+  }
+  if (anthropicKey && anthropicKey.startsWith("...")) {
+    anthropicKey = void 0;
+  }
+  const hasNewOpenAI = openaiKey && openaiKey.trim().length > 0;
+  const hasNewAnthropic = anthropicKey && anthropicKey.trim().length > 0;
+  const hasExistingOpenAI = existing.OPENAI_API_KEY && !hasNewOpenAI;
+  const hasExistingAnthropic = existing.ANTHROPIC_API_KEY && !hasNewAnthropic;
+  if (!hasNewOpenAI && !hasNewAnthropic && !hasExistingOpenAI && !hasExistingAnthropic) {
+    console.error(chalk.red("\nError: At least one API key is required."));
+    console.error(chalk.dim("Provide --openai-key or --anthropic-key, or enter keys when prompted."));
+    process.exit(1);
+  }
+  const toSave = {};
+  if (hasNewOpenAI) {
+    toSave.OPENAI_API_KEY = openaiKey.trim();
+  }
+  if (hasNewAnthropic) {
+    toSave.ANTHROPIC_API_KEY = anthropicKey.trim();
+  }
+  if (Object.keys(toSave).length > 0) {
+    saveGlobalAceConfig(toSave);
+    console.log(chalk.green("\n\u2713 API keys saved to ~/.ace/config.json"));
+  } else {
+    console.log(chalk.yellow("\nNo new keys provided. Existing configuration unchanged."));
+  }
+  const final = loadAceConfig();
+  console.log(chalk.dim("\nConfigured providers:"));
+  if (final.OPENAI_API_KEY) {
+    console.log(chalk.dim(`  \u2022 OpenAI: ${maskApiKey(final.OPENAI_API_KEY)}`));
+  }
+  if (final.ANTHROPIC_API_KEY) {
+    console.log(chalk.dim(`  \u2022 Anthropic: ${maskApiKey(final.ANTHROPIC_API_KEY)}`));
+  }
+  console.log();
+}
+export {
+  run
+};

package/dist/commands/test.js

@@ -0,0 +1,85 @@
+import { execSync } from "node:child_process";
+import chalk from "chalk";
+import { findQuestion, readScorecard, updateTestResults, writeScorecard } 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;
+  for (const arg of args) {
+    if (arg === "--watch") {
+      watch = true;
+    } else if (!arg.startsWith("--")) {
+      slug = arg;
+    }
+  }
+  return { slug, watch };
+}
+function parseTestOutput(output) {
+  const passMatch = output.match(/(\d+)\s+passed/);
+  const failMatch = output.match(/(\d+)\s+failed/);
+  const totalMatch = output.match(/Tests\s+(\d+)/);
+  const passed = passMatch ? parseInt(passMatch[1], 10) : 0;
+  const failed = failMatch ? parseInt(failMatch[1], 10) : 0;
+  const total = totalMatch ? parseInt(totalMatch[1], 10) : passed + failed;
+  return { total, passed };
+}
+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 { slug, watch } = parseArgs(args);
+  if (!slug) {
+    console.log(chalk.cyan("\nRunning all tests...\n"));
+    try {
+      const cmd = watch ? "npx vitest" : "npx vitest run";
+      execSync(cmd, { cwd: projectRoot, stdio: "inherit" });
+    } catch {
+    }
+    return;
+  }
+  const question = findQuestion(slug);
+  if (!question) {
+    console.error(chalk.red(`Question not found: ${slug}`));
+    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."));
+    return;
+  }
+  console.log(chalk.cyan(`
+Running tests for: ${slug}
+`));
+  let output = "";
+  try {
+    const cmd = watch ? `npx vitest ${question.dir}` : `npx vitest run ${question.dir}`;
+    output = execSync(cmd, { cwd: projectRoot, encoding: "utf-8", stdio: ["inherit", "pipe", "pipe"] });
+    console.log(output);
+  } catch (err) {
+    if (err && typeof err === "object" && "stdout" in err) {
+      output = err.stdout || "";
+      console.log(output);
+    }
+  }
+  if (!watch) {
+    const scorecard = readScorecard(question.category, slug);
+    if (scorecard) {
+      const { total, passed } = parseTestOutput(output);
+      updateTestResults(scorecard, total, passed);
+      writeScorecard(question.category, slug, scorecard);
+      if (total > 0) {
+        const color = passed === total ? chalk.green : chalk.red;
+        console.log(color(`
+Scorecard updated: ${passed}/${total} tests passed`));
+      }
+    }
+  }
+}
+export {
+  run
+};

package/dist/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+const [, , command, ...args] = process.argv;
+const COMMANDS = {
+  setup: () => import("./commands/setup.js"),
+  init: () => import("./commands/init.js"),
+  generate: () => import("./commands/generate.js"),
+  add: () => import("./commands/add.js"),
+  list: () => import("./commands/list.js"),
+  test: () => import("./commands/test.js"),
+  feedback: () => import("./commands/feedback.js"),
+  reset: () => import("./commands/reset.js"),
+  score: () => import("./commands/score.js")
+};
+function printHelp() {
+  console.log(`
+${chalk.bold.cyan("ace")} \u2014 Frontend Interview Prep CLI
+
+${chalk.bold("Setup Commands:")}
+
+  ${chalk.green("setup")}      Configure API keys (stored in ~/.ace)
+  ${chalk.green("init")}       Initialize workspace with questions/ and test config
+
+${chalk.bold("Question Commands:")}
+
+  ${chalk.green("generate")}   Generate a question using LLM (--brainstorm for interactive mode)
+  ${chalk.green("add")}        Manually add a question with interactive prompts
+  ${chalk.green("list")}       List all questions with status and filters
+  ${chalk.green("test")}       Run tests for a question (or all questions)
+  ${chalk.green("feedback")}   Get LLM code review or design review
+  ${chalk.green("reset")}      Reset a question to unanswered state
+  ${chalk.green("score")}      View scorecard for a question
+
+${chalk.bold("Examples:")}
+
+  ace setup
+  ace init
+  ace generate --topic "debounce" --category js-ts --difficulty medium
+  ace generate --brainstorm
+  ace list
+  ace list --category js-ts --status solved
+  ace test debounce
+  ace test --watch
+  ace feedback debounce
+  ace reset debounce
+  ace score debounce
+`);
+}
+async function main() {
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  const loader = COMMANDS[command];
+  if (!loader) {
+    console.error(chalk.red(`Unknown command: ${command}`));
+    console.error(`Run ${chalk.cyan("npm run ace help")} for usage.`);
+    process.exit(1);
+  }
+  try {
+    const mod = await loader();
+    await mod.run(args);
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error(chalk.red(`Error: ${err.message}`));
+    } else {
+      console.error(chalk.red("An unexpected error occurred"));
+    }
+    process.exit(1);
+  }
+}
+main();

package/dist/lib/categories.js

@@ -0,0 +1,103 @@
+const CATEGORIES = {
+  "js-ts": {
+    slug: "js-ts",
+    name: "JS/TS Puzzles",
+    shortName: "JS/TS",
+    type: "coding",
+    suggestedTimes: { easy: 15, medium: 30, hard: 45 },
+    solutionFiles: ["solution.ts"],
+    testFiles: ["solution.test.ts"],
+    templateDir: "js-ts"
+  },
+  "web-components": {
+    slug: "web-components",
+    name: "Web Components",
+    shortName: "WebComp",
+    type: "coding",
+    suggestedTimes: { easy: 20, medium: 35, hard: 50 },
+    solutionFiles: ["component.ts", "index.html"],
+    testFiles: ["component.test.ts"],
+    templateDir: "web-components"
+  },
+  "react-apps": {
+    slug: "react-apps",
+    name: "React Web Apps",
+    shortName: "React",
+    type: "coding",
+    suggestedTimes: { easy: 25, medium: 45, hard: 60 },
+    solutionFiles: ["App.tsx"],
+    testFiles: ["App.test.tsx"],
+    templateDir: "react-apps"
+  },
+  "leetcode-ds": {
+    slug: "leetcode-ds",
+    name: "LeetCode Data Structures",
+    shortName: "LC-DS",
+    type: "coding",
+    suggestedTimes: { easy: 15, medium: 30, hard: 45 },
+    solutionFiles: ["solution.ts"],
+    testFiles: ["solution.test.ts"],
+    templateDir: "leetcode-ds"
+  },
+  "leetcode-algo": {
+    slug: "leetcode-algo",
+    name: "LeetCode Algorithms",
+    shortName: "LC-Algo",
+    type: "coding",
+    suggestedTimes: { easy: 15, medium: 30, hard: 45 },
+    solutionFiles: ["solution.ts"],
+    testFiles: ["solution.test.ts"],
+    templateDir: "leetcode-algo"
+  },
+  "design-fe": {
+    slug: "design-fe",
+    name: "System Design \u2014 Frontend",
+    shortName: "Design-FE",
+    type: "design",
+    suggestedTimes: { easy: 25, medium: 40, hard: 55 },
+    solutionFiles: ["notes.md"],
+    testFiles: [],
+    templateDir: "design"
+  },
+  "design-be": {
+    slug: "design-be",
+    name: "System Design \u2014 Backend",
+    shortName: "Design-BE",
+    type: "design",
+    suggestedTimes: { easy: 25, medium: 40, hard: 55 },
+    solutionFiles: ["notes.md"],
+    testFiles: [],
+    templateDir: "design"
+  },
+  "design-full": {
+    slug: "design-full",
+    name: "System Design \u2014 Full Stack",
+    shortName: "Design-Full",
+    type: "design",
+    suggestedTimes: { easy: 30, medium: 45, hard: 60 },
+    solutionFiles: ["notes.md"],
+    testFiles: [],
+    templateDir: "design"
+  }
+};
+const CATEGORY_SLUGS = Object.keys(CATEGORIES);
+function getCategoryConfig(slug) {
+  return CATEGORIES[slug];
+}
+function getSuggestedTime(slug, difficulty) {
+  return CATEGORIES[slug].suggestedTimes[difficulty];
+}
+function isDesignCategory(slug) {
+  return CATEGORIES[slug].type === "design";
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+export {
+  CATEGORIES,
+  CATEGORY_SLUGS,
+  getCategoryConfig,
+  getSuggestedTime,
+  isDesignCategory,
+  slugify
+};

package/dist/lib/config.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import dotenv from "dotenv";
+import { getGlobalAceDir } from "./paths.js";
+function loadAceConfig() {
+  const config = {};
+  const globalAceDir = getGlobalAceDir();
+  const configPath = path.join(globalAceDir, "config.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const parsed = JSON.parse(content);
+      Object.assign(config, parsed);
+    } catch (err) {
+    }
+  }
+  const envPath = path.join(globalAceDir, ".env");
+  if (fs.existsSync(envPath)) {
+    const envConfig = dotenv.parse(fs.readFileSync(envPath));
+    for (const [key, value] of Object.entries(envConfig)) {
+      if (!config[key]) {
+        config[key] = value;
+      }
+    }
+  }
+  if (!config.OPENAI_API_KEY && process.env.OPENAI_API_KEY) {
+    config.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+  }
+  if (!config.ANTHROPIC_API_KEY && process.env.ANTHROPIC_API_KEY) {
+    config.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+  }
+  return config;
+}
+function saveGlobalAceConfig(partial) {
+  const globalAceDir = getGlobalAceDir();
+  if (!fs.existsSync(globalAceDir)) {
+    fs.mkdirSync(globalAceDir, { recursive: true, mode: 448 });
+  }
+  const configPath = path.join(globalAceDir, "config.json");
+  let existing = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  const merged = { ...existing, ...partial };
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function maskApiKey(key) {
+  if (!key || key.length < 8) return "***";
+  return "..." + key.slice(-4);
+}
+export {
+  loadAceConfig,
+  maskApiKey,
+  saveGlobalAceConfig
+};