coding-friend-cli 1.7.0 → 1.9.0

package/dist/index.js

@@ -14,33 +14,56 @@ program.name("cf").description(
   "coding-friend CLI \u2014 host learning docs, setup MCP, init projects"
 ).version(pkg.version, "-v, --version");
 program.command("install").description("Install the Coding Friend plugin into Claude Code").action(async () => {
-  const { installCommand } = await import("./install-ORIDNWRW.js");
+  const { installCommand } = await import("./install-D4NW3OAA.js");
   await installCommand();
 });
 program.command("uninstall").description("Uninstall the Coding Friend plugin from Claude Code").action(async () => {
-  const { uninstallCommand } = await import("./uninstall-KOAJFPD6.js");
+  const { uninstallCommand } = await import("./uninstall-SOHU5WGK.js");
   await uninstallCommand();
 });
 program.command("init").description("Initialize coding-friend in current project").action(async () => {
-  const { initCommand } = await import("./init-5BJVESH7.js");
+  const { initCommand } = await import("./init-CIEDOFNC.js");
   await initCommand();
 });
+program.command("config").description("Manage Coding Friend configuration").action(async () => {
+  const { configCommand } = await import("./config-VAML7F7K.js");
+  await configCommand();
+});
 program.command("host").description("Build and serve learning docs as a static website").argument("[path]", "path to docs folder").option("-p, --port <port>", "port number", "3333").action(async (path, opts) => {
-  const { hostCommand } = await import("./host-EERZVOHY.js");
+  const { hostCommand } = await import("./host-LOG5RPZ7.js");
   await hostCommand(path, opts);
 });
 program.command("mcp").description("Setup MCP server for learning docs").argument("[path]", "path to docs folder").action(async (path) => {
-  const { mcpCommand } = await import("./mcp-3MUUQZQD.js");
+  const { mcpCommand } = await import("./mcp-ORMYETXQ.js");
   await mcpCommand(path);
 });
 program.command("statusline").description("Setup coding-friend statusline in Claude Code").action(async () => {
-  const { statuslineCommand } = await import("./statusline-BWGI5PQ5.js");
+  const { statuslineCommand } = await import("./statusline-5HWRTSVL.js");
   await statuslineCommand();
 });
 program.command("update").description("Update coding-friend plugin, CLI, and statusline").option("--cli", "Update only the CLI (npm package)").option("--plugin", "Update only the Claude Code plugin").option("--statusline", "Update only the statusline").action(async (opts) => {
-  const { updateCommand } = await import("./update-GW37S23M.js");
+  const { updateCommand } = await import("./update-LA4B3LN4.js");
   await updateCommand(opts);
 });
+var session = program.command("session").description("Save and load Claude Code sessions across machines");
+program.addHelpText(
+  "after",
+  `
+Session subcommands:
+  session save        Save current session to sync folder (use /cf-session inside a conversation)
+  session load        Load a saved session from sync folder and print resume command`
+);
+session.command("save").description("Save current Claude Code session to sync folder").option(
+  "-s, --session-id <id>",
+  "session UUID to save (default: auto-detect newest)"
+).option("-l, --label <label>", "label for this session").action(async (opts) => {
+  const { sessionSaveCommand } = await import("./session-NCQQJRSH.js");
+  await sessionSaveCommand(opts);
+});
+session.command("load").description("Load a saved session from sync folder").action(async () => {
+  const { sessionLoadCommand } = await import("./session-NCQQJRSH.js");
+  await sessionLoadCommand();
+});
 var dev = program.command("dev").description("Development mode commands");
 program.addHelpText(
   "after",
@@ -54,35 +77,35 @@ Dev subcommands:
   dev update [path]   Update local dev plugin to latest version`
 );
 dev.command("on").description("Switch to local plugin source").argument("[path]", "path to local coding-friend repo (default: cwd)").action(async (path) => {
-  const { devOnCommand } = await import("./dev-QW6VPG4G.js");
+  const { devOnCommand } = await import("./dev-2GBY3GKC.js");
   await devOnCommand(path);
 });
 dev.command("off").description("Switch back to remote marketplace").action(async () => {
-  const { devOffCommand } = await import("./dev-QW6VPG4G.js");
+  const { devOffCommand } = await import("./dev-2GBY3GKC.js");
   await devOffCommand();
 });
 dev.command("status").description("Show current dev mode").action(async () => {
-  const { devStatusCommand } = await import("./dev-QW6VPG4G.js");
+  const { devStatusCommand } = await import("./dev-2GBY3GKC.js");
   await devStatusCommand();
 });
 dev.command("sync").description(
   "Copy local source files to plugin cache (no version bump needed)"
 ).action(async () => {
-  const { devSyncCommand } = await import("./dev-QW6VPG4G.js");
+  const { devSyncCommand } = await import("./dev-2GBY3GKC.js");
   await devSyncCommand();
 });
 dev.command("restart").description("Reinstall local dev plugin (off + on)").argument(
   "[path]",
   "path to local coding-friend repo (default: saved path or cwd)"
 ).action(async (path) => {
-  const { devRestartCommand } = await import("./dev-QW6VPG4G.js");
+  const { devRestartCommand } = await import("./dev-2GBY3GKC.js");
   await devRestartCommand(path);
 });
 dev.command("update").description("Update local dev plugin to latest version (off + on)").argument(
   "[path]",
   "path to local coding-friend repo (default: saved path or cwd)"
 ).action(async (path) => {
-  const { devUpdateCommand } = await import("./dev-QW6VPG4G.js");
+  const { devUpdateCommand } = await import("./dev-2GBY3GKC.js");
   await devUpdateCommand(path);
 });
 program.parse();

package/dist/init-CIEDOFNC.js

@@ -0,0 +1,512 @@
+import {
+  BACK,
+  applyDocsDirChange,
+  askScope,
+  formatScopeLabel,
+  getMergedValue,
+  getScopeLabel,
+  injectBackChoice,
+  showConfigHint
+} from "./chunk-QQ5SVZET.js";
+import {
+  findStatuslineHookPath,
+  isStatuslineConfigured,
+  saveStatuslineConfig,
+  selectStatuslineComponents,
+  writeStatuslineSettings
+} from "./chunk-BPLN4LDL.js";
+import {
+  ensureShellCompletion,
+  hasShellCompletion
+} from "./chunk-7N64TDZ6.js";
+import {
+  DEFAULT_CONFIG
+} from "./chunk-PGLUEN7D.js";
+import {
+  run
+} from "./chunk-UFGNO6CW.js";
+import {
+  claudeSettingsPath,
+  globalConfigPath,
+  localConfigPath,
+  mergeJson,
+  readJson,
+  resolvePath,
+  writeJson
+} from "./chunk-TPRZHSFS.js";
+import {
+  log
+} from "./chunk-W5CD7WTX.js";
+
+// src/commands/init.ts
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import chalk from "chalk";
+var GITIGNORE_START = "# >>> coding-friend managed";
+var GITIGNORE_END = "# <<< coding-friend managed";
+var em = chalk.hex("#10b981");
+var dk = chalk.hex("#064e3b");
+function printBanner() {
+  console.log();
+  console.log(em("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
+  console.log(
+    em("  \u2502  ") + "\u2726" + em(" ") + chalk.bold.white("Coding Friend") + em("  \u2726   \u2502")
+  );
+  console.log(em("  \u2502    ") + chalk.dim("Setup Wizard") + em("       \u2502"));
+  console.log(em("  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F"));
+  console.log(em("               \u2570\u2500\u25B8"));
+  console.log();
+}
+var _stepIndex = 0;
+function printStepHeader(label, description) {
+  _stepIndex++;
+  const line = chalk.hex("#10b981")("\u2500".repeat(44));
+  console.log();
+  console.log(`${line}`);
+  console.log(
+    `${em("\u{1F536}")} ${chalk.bold.hex("#f59e0b")(`Step ${_stepIndex}`)}  ${chalk.dim(label)}`
+  );
+  if (description) {
+    console.log(`     ${chalk.dim(description)}`);
+  }
+  console.log(`${line}`);
+}
+function isGitRepo() {
+  return run("git", ["rev-parse", "--is-inside-work-tree"]) === "true";
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function writeToScope(scope, data) {
+  const targetPath = scope === "global" ? globalConfigPath() : localConfigPath();
+  mergeJson(targetPath, data);
+  log.success(`Saved to ${targetPath}`);
+}
+function handleBack(value) {
+  if (value === BACK) {
+    console.log();
+    log.dim("Init cancelled. Remaining steps skipped \u2014 nothing further saved.");
+    process.exit(0);
+  }
+}
+function getDocsDir(globalCfg, localCfg) {
+  return localCfg?.docsDir ?? globalCfg?.docsDir ?? DEFAULT_CONFIG.docsDir;
+}
+async function stepDocsDir(globalCfg, localCfg) {
+  const currentValue = getMergedValue("docsDir", globalCfg, localCfg);
+  const scopeLabel = getScopeLabel("docsDir", globalCfg, localCfg);
+  printStepHeader(
+    `Docs folder name ${formatScopeLabel(scopeLabel)}${currentValue ? ` (${chalk.dim(currentValue)})` : ""}`,
+    "Where plans, memory, research, and session docs are stored in your project."
+  );
+  const value = await input({
+    message: "Docs folder name:",
+    default: currentValue ?? DEFAULT_CONFIG.docsDir,
+    validate: (val) => {
+      if (!val) return "Folder name cannot be empty";
+      if (val.includes("/") || val.includes("\\"))
+        return "Must be a folder name, not a path (no slashes)";
+      return true;
+    }
+  });
+  const scope = await askScope();
+  if (scope === "back") {
+    log.dim("Skipped docsDir.");
+    return;
+  }
+  const DOCS_SUBFOLDERS = ["plans", "memory", "research", "learn", "sessions"];
+  applyDocsDirChange(value, currentValue, scope, DOCS_SUBFOLDERS);
+  writeToScope(scope, { docsDir: value });
+}
+async function stepGitignore(docsDir) {
+  const hasBlock = (() => {
+    if (!existsSync(".gitignore")) return false;
+    const content = readFileSync(".gitignore", "utf-8");
+    return content.includes(GITIGNORE_START) || content.includes("# coding-friend");
+  })();
+  if (hasBlock) {
+    printStepHeader(
+      `Configure .gitignore ${chalk.green("[done]")}`,
+      "Keeps AI-generated docs and config out of your git history."
+    );
+    log.dim(".gitignore already configured.");
+    return;
+  }
+  printStepHeader(
+    "Configure .gitignore",
+    "Keeps Coding Friend's AI-generated docs and config out of your git history. You can edit it later in .gitignore."
+  );
+  const choice = await select({
+    message: "Add coding-friend artifacts to .gitignore?",
+    choices: injectBackChoice(
+      [
+        { name: "Yes, ignore all", value: "all" },
+        { name: "Partial -- pick which to ignore", value: "partial" },
+        { name: "No -- keep everything tracked", value: "none" }
+      ],
+      "Cancel init"
+    )
+  });
+  handleBack(choice);
+  if (choice === "none") {
+    log.dim("Skipped .gitignore config.");
+    return;
+  }
+  const allEntries = [
+    `${docsDir}/plans/`,
+    `${docsDir}/memory/`,
+    `${docsDir}/research/`,
+    `${docsDir}/learn/`,
+    `${docsDir}/sessions/`,
+    ".coding-friend/"
+  ];
+  let entries = allEntries;
+  if (choice === "partial") {
+    entries = await checkbox({
+      message: "Which folders to ignore?",
+      choices: allEntries.map((e) => ({ name: e, value: e }))
+    });
+    if (entries.length === 0) {
+      log.dim("Nothing selected.");
+      return;
+    }
+  }
+  const existing = existsSync(".gitignore") ? readFileSync(".gitignore", "utf-8") : "";
+  const block = `${GITIGNORE_START}
+${entries.join("\n")}
+${GITIGNORE_END}`;
+  const managedBlockRe = new RegExp(
+    `${escapeRegExp(GITIGNORE_START)}[\\s\\S]*?${escapeRegExp(GITIGNORE_END)}`
+  );
+  const legacyBlockRe = /# coding-friend\n([\w/.]+\n)*/;
+  let updated;
+  if (managedBlockRe.test(existing)) {
+    updated = existing.replace(managedBlockRe, block);
+    log.success(`Updated .gitignore: ${entries.join(", ")}`);
+  } else if (legacyBlockRe.test(existing)) {
+    updated = existing.replace(legacyBlockRe, block);
+    log.success(`Migrated .gitignore block: ${entries.join(", ")}`);
+  } else {
+    updated = existing.trimEnd() + "\n\n" + block + "\n";
+    log.success(`Added to .gitignore: ${entries.join(", ")}`);
+  }
+  writeFileSync(".gitignore", updated);
+}
+async function stepDocsLanguage(globalCfg, localCfg) {
+  const currentValue = getMergedValue("language", globalCfg, localCfg);
+  const scopeLabel = getScopeLabel("language", globalCfg, localCfg);
+  printStepHeader(
+    `Docs language ${formatScopeLabel(scopeLabel)}${currentValue ? ` (${chalk.dim(currentValue)})` : ""}`,
+    "Skills like /cf-plan, /cf-ask, /cf-remember will write docs in this language."
+  );
+  const lang = await selectLanguage(
+    "What language should generated docs be written in?"
+  );
+  const scope = await askScope();
+  if (scope === "back") {
+    log.dim("Skipped docs language.");
+    return;
+  }
+  writeToScope(scope, { language: lang });
+}
+async function selectLanguage(message) {
+  const choice = await select({
+    message,
+    choices: injectBackChoice(
+      [
+        { name: "English", value: "en" },
+        { name: "Vietnamese", value: "vi" },
+        { name: "Other", value: "_other" }
+      ],
+      "Cancel init"
+    )
+  });
+  handleBack(choice);
+  if (choice === "_other") {
+    const lang = await input({ message: "Enter language name:" });
+    return lang || "en";
+  }
+  return choice;
+}
+async function stepLearnConfig(globalCfg, localCfg, gitAvailable) {
+  const currentLearn = localCfg?.learn ?? globalCfg?.learn;
+  const scopeLabel = getScopeLabel("learn", globalCfg, localCfg);
+  const docsDir = getDocsDir(globalCfg, localCfg);
+  printStepHeader(
+    `/cf-learn config ${formatScopeLabel(scopeLabel)}`,
+    "Controls where and how /cf-learn saves your learning notes."
+  );
+  const language = await selectLanguage(
+    "What language should /cf-learn notes be written in?"
+  );
+  const locationChoice = await select({
+    message: "Where to store learning docs?",
+    choices: injectBackChoice(
+      [
+        { name: `In this project (${docsDir}/learn/)`, value: "local" },
+        { name: "A separate folder", value: "external" }
+      ],
+      "Cancel init"
+    )
+  });
+  handleBack(locationChoice);
+  let outputDir = `${docsDir}/learn`;
+  let isExternal = false;
+  if (locationChoice === "external") {
+    outputDir = await input({
+      message: "Enter path (absolute or ~/...):",
+      default: currentLearn?.outputDir ?? void 0,
+      validate: (val) => val.length > 0 ? true : "Path cannot be empty"
+    });
+    isExternal = true;
+    const resolved = resolvePath(outputDir);
+    if (!existsSync(resolved)) {
+      const create = await confirm({
+        message: `Folder ${resolved} doesn't exist. Create it?`,
+        default: true
+      });
+      if (create) {
+        run("mkdir", ["-p", resolved]);
+        log.success(`Created ${resolved}`);
+      }
+    }
+  }
+  const existingCats = currentLearn?.categories;
+  const defaultNames = DEFAULT_CONFIG.learn.categories.map((c) => c.name).join(", ");
+  const catChoices = [
+    { name: `Use defaults (${defaultNames})`, value: "defaults" }
+  ];
+  if (existingCats && existingCats.length > 0) {
+    const existingNames = existingCats.map((c) => c.name).join(", ");
+    catChoices.push({
+      name: `Keep current (${existingNames})`,
+      value: "existing"
+    });
+  }
+  catChoices.push({ name: "Customize", value: "custom" });
+  const catChoice = await select({
+    message: "Categories for organizing learning docs?",
+    choices: injectBackChoice(catChoices, "Cancel init")
+  });
+  handleBack(catChoice);
+  let categories = DEFAULT_CONFIG.learn.categories;
+  if (catChoice === "existing" && existingCats) {
+    categories = existingCats;
+  } else if (catChoice === "custom") {
+    console.log();
+    if (existingCats && existingCats.length > 0) {
+      console.log("Current categories in config.json:");
+      for (const c of existingCats) {
+        log.dim(`  ${c.name}: ${c.description}`);
+      }
+      console.log();
+    }
+    console.log(
+      'Enter categories (format: "name: description"). Empty line to finish.'
+    );
+    log.dim(
+      "Tip: you can also edit config.json later -- see https://cf.dinhanhthi.com/docs/configuration/config-json/#learning-extraction"
+    );
+    console.log();
+    const customCats = [];
+    let keepGoing = true;
+    while (keepGoing) {
+      const line = await input({
+        message: `Category ${customCats.length + 1}:`
+      });
+      if (!line) {
+        keepGoing = false;
+      } else {
+        const [name, ...descParts] = line.split(":");
+        customCats.push({
+          name: name.trim(),
+          description: descParts.join(":").trim() || name.trim()
+        });
+      }
+    }
+    if (customCats.length > 0) categories = customCats;
+  }
+  let autoCommit = false;
+  if (isExternal && gitAvailable) {
+    autoCommit = await confirm({
+      message: "Auto-commit learning docs to git after each /cf-learn?",
+      default: currentLearn?.autoCommit ?? false
+    });
+  }
+  const indexChoice = await select({
+    message: "How should learning docs be indexed?",
+    choices: injectBackChoice(
+      [
+        { name: "No index", value: "none" },
+        { name: "Single README at root", value: "single" },
+        { name: "Per-category READMEs", value: "per-category" }
+      ],
+      "Cancel init"
+    )
+  });
+  handleBack(indexChoice);
+  let readmeIndex = false;
+  if (indexChoice === "single") readmeIndex = true;
+  else if (indexChoice === "per-category") readmeIndex = "per-category";
+  const learnObj = {
+    language,
+    outputDir,
+    categories,
+    autoCommit,
+    readmeIndex
+  };
+  const scope = await askScope();
+  if (scope === "back") {
+    log.dim("Skipped /cf-learn config.");
+    return { outputDir, autoCommit, isExternal };
+  }
+  const targetPath = scope === "global" ? globalConfigPath() : localConfigPath();
+  const existingConfig = readJson(targetPath);
+  const existingLearn = existingConfig?.learn ?? {};
+  mergeJson(targetPath, { learn: { ...existingLearn, ...learnObj } });
+  log.success(`Saved to ${targetPath}`);
+  return { outputDir, autoCommit, isExternal };
+}
+async function stepShellCompletion() {
+  if (hasShellCompletion()) {
+    printStepHeader(
+      `Shell tab completion ${chalk.green("[done]")}`,
+      "Enables tab-complete for cf commands in your shell."
+    );
+    ensureShellCompletion({ silent: false });
+    return;
+  }
+  printStepHeader(
+    "Shell tab completion",
+    "Enables tab-complete for cf commands in your shell."
+  );
+  ensureShellCompletion();
+}
+async function stepStatusline() {
+  if (isStatuslineConfigured()) {
+    printStepHeader(
+      `Configure statusline ${chalk.green("[done]")}`,
+      "Shows token count, model, and session info in your terminal prompt."
+    );
+    log.dim("Statusline already configured.");
+    return;
+  }
+  printStepHeader(
+    "Configure statusline",
+    "Shows token count, model, and session info in your terminal prompt."
+  );
+  const hookResult = findStatuslineHookPath();
+  if (!hookResult) {
+    log.warn(
+      "coding-friend plugin not found. Install it via Claude Code first, then re-run."
+    );
+    return;
+  }
+  const components = await selectStatuslineComponents();
+  saveStatuslineConfig(components);
+  writeStatuslineSettings(hookResult.hookPath);
+  log.success("Statusline configured!");
+}
+async function stepClaudePermissions(outputDir, autoCommit) {
+  const resolved = resolvePath(outputDir);
+  const homePath = resolved.startsWith(homedir()) ? resolved.replace(homedir(), "~") : resolved;
+  const rules = [
+    `Read(${homePath}/**)`,
+    `Edit(${homePath}/**)`,
+    `Write(${homePath}/**)`
+  ];
+  if (autoCommit) {
+    rules.push(`Bash(cd ${homePath} && git add:*)`);
+    rules.push(`Bash(cd ${homePath} && git commit:*)`);
+  }
+  const settingsPath = claudeSettingsPath();
+  const settings = readJson(settingsPath);
+  if (!settings) {
+    log.warn(
+      "~/.claude/settings.json not found. Create it via Claude Code settings first."
+    );
+    return;
+  }
+  const permissions = settings.permissions ?? {};
+  const existing = permissions.allow ?? [];
+  const missing = rules.filter(
+    (r) => !existing.some((e) => e === r || e.includes(homePath))
+  );
+  if (missing.length === 0) {
+    log.dim("All permission rules already configured.");
+    return;
+  }
+  console.log("\nTo avoid repeated permission prompts, add these rules:");
+  for (const r of missing) {
+    console.log(`  ${r}`);
+  }
+  const ok = await confirm({
+    message: "Add these to ~/.claude/settings.json?",
+    default: true
+  });
+  if (!ok) {
+    log.dim("Skipped. You'll get prompted each time.");
+    return;
+  }
+  permissions.allow = [...existing, ...missing];
+  settings.permissions = permissions;
+  writeJson(settingsPath, settings);
+  log.success(`Added ${missing.length} permission rules.`);
+}
+async function initCommand() {
+  _stepIndex = 0;
+  printBanner();
+  showConfigHint();
+  const gitAvailable = isGitRepo();
+  if (!gitAvailable) {
+    log.warn("Not inside a git repo -- git-related steps will be skipped.");
+    console.log();
+  }
+  const globalCfg = readJson(globalConfigPath());
+  const localCfg = readJson(localConfigPath());
+  console.log("Current configuration:");
+  const docsDirScope = getScopeLabel("docsDir", globalCfg, localCfg);
+  const docsDirVal = getMergedValue("docsDir", globalCfg, localCfg);
+  console.log(
+    `  ${formatScopeLabel(docsDirScope)}  docsDir${docsDirVal ? ` (${chalk.dim(docsDirVal)})` : ""}`
+  );
+  const langScope = getScopeLabel("language", globalCfg, localCfg);
+  const langVal = getMergedValue("language", globalCfg, localCfg);
+  console.log(
+    `  ${formatScopeLabel(langScope)}  Docs language${langVal ? ` (${chalk.dim(langVal)})` : ""}`
+  );
+  const learnScope = getScopeLabel("learn", globalCfg, localCfg);
+  console.log(`  ${formatScopeLabel(learnScope)}  /cf-learn config`);
+  console.log();
+  await stepDocsDir(globalCfg, localCfg);
+  const updatedGlobal = readJson(globalConfigPath());
+  const updatedLocal = readJson(localConfigPath());
+  const docsDir = getDocsDir(updatedGlobal, updatedLocal);
+  if (gitAvailable) {
+    await stepGitignore(docsDir);
+  }
+  await stepDocsLanguage(globalCfg, localCfg);
+  const { outputDir, autoCommit, isExternal } = await stepLearnConfig(
+    updatedGlobal,
+    updatedLocal,
+    gitAvailable
+  );
+  await stepShellCompletion();
+  await stepStatusline();
+  if (isExternal) {
+    printStepHeader(
+      "Configure Claude permissions",
+      "Grants Claude read/write access to your external learn folder without repeated prompts."
+    );
+    await stepClaudePermissions(outputDir, autoCommit);
+  }
+  console.log();
+  log.congrats("Setup complete!");
+  log.dim(
+    "Available commands: /cf-ask, /cf-plan, /cf-fix, /cf-commit, /cf-review, /cf-ship, /cf-optimize, /cf-remember, /cf-learn, /cf-research, /cf-session, /cf-help"
+  );
+}
+export {
+  initCommand
+};

package/dist/{install-ORIDNWRW.js → install-D4NW3OAA.js}

@@ -1,24 +1,23 @@
 import {
   getLatestVersion,
   semverCompare
-} from "./chunk-DHPWBSF5.js";
+} from "./chunk-VYMXERKM.js";
 import {
   isMarketplaceRegistered
-} from "./chunk-MRTR7TJ4.js";
+} from "./chunk-HFLBFX6J.js";
 import {
   getInstalledVersion
-} from "./chunk-HSQX3PKW.js";
-import "./chunk-4PLV2ENL.js";
-import "./chunk-WXBI2HUL.js";
+} from "./chunk-BPLN4LDL.js";
+import "./chunk-7N64TDZ6.js";
+import "./chunk-PGLUEN7D.js";
 import {
   commandExists,
   run
 } from "./chunk-UFGNO6CW.js";
-import "./chunk-WHCJT7E2.js";
+import "./chunk-TPRZHSFS.js";
 import {
   log
-} from "./chunk-6DUFTBTO.js";
-import "./chunk-IUTXHCP7.js";
+} from "./chunk-W5CD7WTX.js";
 
 // src/commands/install.ts
 import chalk from "chalk";

package/dist/{mcp-3MUUQZQD.js → mcp-ORMYETXQ.js}

@@ -1,16 +1,17 @@
 import {
-  getLibPath,
+  getLibPath
+} from "./chunk-RZRT7NGT.js";
+import {
   resolveDocsDir
-} from "./chunk-WK5YYHXM.js";
-import "./chunk-WXBI2HUL.js";
+} from "./chunk-FYHHNX7K.js";
+import "./chunk-PGLUEN7D.js";
 import {
   run
 } from "./chunk-UFGNO6CW.js";
-import "./chunk-WHCJT7E2.js";
+import "./chunk-TPRZHSFS.js";
 import {
   log
-} from "./chunk-6DUFTBTO.js";
-import "./chunk-IUTXHCP7.js";
+} from "./chunk-W5CD7WTX.js";
 
 // src/commands/mcp.ts
 import { existsSync, readdirSync } from "fs";

package/dist/postinstall.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   ensureShellCompletion
-} from "./chunk-4PLV2ENL.js";
-import "./chunk-6DUFTBTO.js";
+} from "./chunk-7N64TDZ6.js";
+import "./chunk-W5CD7WTX.js";
 
 // src/postinstall.ts
 ensureShellCompletion();