jinzd-ai-cli 0.4.218 → 0.4.219

package/dist/electron-server.js

@@ -38,7 +38,7 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-C2Z42DI5.js";
+} from "./chunk-EGMORH5W.js";
 import {
   hasSemanticIndex,
   semanticSearch
@@ -64,8 +64,8 @@ import {
 import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
-import { join as join23, dirname as dirname8, resolve as resolve11, relative as relative4, sep as sep3 } from "path";
-import { existsSync as existsSync28, readFileSync as readFileSync22, readdirSync as readdirSync14, statSync as statSync10, realpathSync } from "fs";
+import { join as join25, dirname as dirname8, resolve as resolve11, relative as relative4, sep as sep3 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync23, readdirSync as readdirSync15, statSync as statSync12, realpathSync } from "fs";
 import { networkInterfaces } from "os";
 
 // src/config/config-manager.ts
@@ -6629,6 +6629,21 @@ function flush() {
   } catch {
   }
 }
+function getStatsSnapshot() {
+  const s = ensureLoaded();
+  return Object.values(s.entries).map((e) => ({ ...e }));
+}
+function getTopFailingTools(limit = 5) {
+  return getStatsSnapshot().filter((e) => e.failures > 0).sort((a, b) => {
+    const rateA = a.failures / Math.max(1, a.calls);
+    const rateB = b.failures / Math.max(1, b.calls);
+    if (rateB !== rateA) return rateB - rateA;
+    return b.failures - a.failures;
+  }).slice(0, limit);
+}
+function getTopUsedTools(limit = 5) {
+  return getStatsSnapshot().sort((a, b) => b.calls - a.calls).slice(0, limit);
+}
 
 // src/tools/action-classifier.ts
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
@@ -13586,8 +13601,8 @@ function loadContextFiles(options) {
 }
 
 // src/web/session-handler.ts
-import { existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync2, mkdirSync as mkdirSync12, readdirSync as readdirSync12, statSync as statSync9, createWriteStream } from "fs";
-import { join as join21, resolve as resolve10, dirname as dirname7 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync21, writeFileSync as writeFileSync3, mkdirSync as mkdirSync13, readdirSync as readdirSync13, statSync as statSync11, createWriteStream } from "fs";
+import { join as join23, resolve as resolve10, dirname as dirname7 } from "path";
 
 // src/cli/review-prompts.ts
 function buildReviewPrompt(diff, gitContextStr, detailed) {
@@ -14232,6 +14247,334 @@ var DiscussionOrchestrator = class {
   }
 };
 
+// src/diagnostics/doctor-report.ts
+import { existsSync as existsSync27, statSync as statSync10 } from "fs";
+import { join as join21 } from "path";
+import { arch as arch2, platform as platform6, release as release2 } from "os";
+
+// src/diagnostics/crash-log.ts
+import {
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync12,
+  readdirSync as readdirSync12,
+  readFileSync as readFileSync20,
+  statSync as statSync9,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join20 } from "path";
+import { homedir as homedir8, platform as platform5, release, arch } from "os";
+var LOGS_DIR_NAME = "logs";
+var CRASH_LOG_PREFIX = "crash-";
+function getLogsDir(configDir) {
+  const base = configDir ?? join20(homedir8(), CONFIG_DIR_NAME);
+  return join20(base, LOGS_DIR_NAME);
+}
+function truncate(s, n) {
+  return s.length <= n ? s : s.slice(0, n) + "\u2026";
+}
+function listRecentCrashes(limit = 10, configDir) {
+  const dir = getLogsDir(configDir);
+  if (!existsSync26(dir)) return [];
+  const files = [];
+  let names;
+  try {
+    names = readdirSync12(dir);
+  } catch {
+    return [];
+  }
+  for (const name of names) {
+    if (!name.startsWith(CRASH_LOG_PREFIX) || !name.endsWith(".log")) continue;
+    const full = join20(dir, name);
+    try {
+      const st = statSync9(full);
+      const head = readFileSync20(full, "utf-8").split("\n").slice(0, 20);
+      const tsLine = head.find((l) => l.startsWith("timestamp:"));
+      const kindLine = head.find((l) => l.startsWith("kind:"));
+      const msgIdx = head.findIndex((l) => l.trim() === "## message");
+      const message = msgIdx >= 0 && head[msgIdx + 1] ? head[msgIdx + 1] : "";
+      files.push({
+        file: full,
+        timestamp: tsLine ? tsLine.replace("timestamp:", "").trim() : st.mtime.toISOString(),
+        kind: kindLine ? kindLine.replace("kind:", "").trim() : "unknown",
+        message: truncate(message, 200),
+        sizeBytes: st.size
+      });
+    } catch {
+    }
+  }
+  files.sort((a, b) => a.timestamp < b.timestamp ? 1 : -1);
+  return files.slice(0, limit);
+}
+function getConfigDirUsage(configDir) {
+  const base = configDir ?? join20(homedir8(), CONFIG_DIR_NAME);
+  if (!existsSync26(base)) return { totalBytes: 0, entries: [] };
+  const entries = [];
+  let total = 0;
+  let names;
+  try {
+    names = readdirSync12(base);
+  } catch {
+    return { totalBytes: 0, entries: [] };
+  }
+  for (const name of names) {
+    const full = join20(base, name);
+    const bytes = dirSize(full);
+    entries.push({ name, bytes });
+    total += bytes;
+  }
+  entries.sort((a, b) => b.bytes - a.bytes);
+  return { totalBytes: total, entries };
+}
+function dirSize(path3) {
+  try {
+    const st = statSync9(path3);
+    if (st.isFile()) return st.size;
+    if (!st.isDirectory()) return 0;
+    let sum = 0;
+    for (const name of readdirSync12(path3)) {
+      sum += dirSize(join20(path3, name));
+    }
+    return sum;
+  } catch {
+    return 0;
+  }
+}
+
+// src/diagnostics/doctor-report.ts
+function checkFile(label, path3) {
+  const exists = existsSync27(path3);
+  let sizeBytes = null;
+  if (exists) {
+    try {
+      sizeBytes = statSync10(path3).size;
+    } catch {
+    }
+  }
+  return { label, path: path3, exists, sizeBytes };
+}
+function buildDoctorReport(options) {
+  const config = options.config;
+  const cwd = options.cwd ?? process.cwd();
+  const configDir = config.getConfigDir();
+  const projectRoot = getGitRoot(cwd) ?? cwd;
+  const contextCfg = config.get("context");
+  const contextSetting = config.get("contextFile");
+  const context = loadContextFiles({
+    cwd,
+    configDir,
+    projectRoot,
+    setting: contextSetting,
+    maxBytes: contextCfg.projectDocMaxBytes,
+    fallbackFilenames: contextCfg.projectDocFallbackFilenames
+  });
+  const hooksConfig = config.get("hooks");
+  const hooks = listHooks(hooksConfig, configDir);
+  const pendingHooks = getPendingHookTrust(hooksConfig, configDir);
+  const plugins = listInstalledPlugins(configDir);
+  const activeAssets = getActivePluginAssets(configDir);
+  const network = config.get("networkPolicy");
+  const mcpServers = config.get("mcpServers");
+  const allStats = getStatsSnapshot();
+  return {
+    version: VERSION,
+    npmCheck: options.npmCheck,
+    node: process.version,
+    platform: `${platform6()} ${release2()} (${arch2()})`,
+    cwd,
+    projectRoot,
+    configDir,
+    providers: options.providers.listAll().map((p) => ({ id: p.id, displayName: p.displayName, configured: p.configured })),
+    files: [
+      checkFile("config.json", join21(configDir, "config.json")),
+      checkFile("memory.md", join21(configDir, MEMORY_FILE_NAME)),
+      checkFile("memory.jsonl", join21(configDir, "memory.jsonl")),
+      checkFile("dev-state.md", join21(configDir, DEV_STATE_FILE_NAME)),
+      checkFile("hooks-trust.json", join21(configDir, "hooks-trust.json")),
+      checkFile("plugin-state.json", join21(configDir, "plugins", "plugin-state.json"))
+    ],
+    context: {
+      enabled: contextSetting !== false,
+      setting: contextSetting,
+      candidates: context.candidates,
+      maxBytes: context.maxBytes,
+      layers: context.layers.map((l) => ({ level: l.level, fileName: l.fileName, displayPath: l.displayPath, bytes: l.byteCount, chars: l.charCount, truncated: l.truncated })),
+      skipped: context.skipped.map((s) => ({ level: s.level, fileName: s.fileName, displayPath: s.displayPath, reason: s.reason, message: s.message }))
+    },
+    permissions: {
+      defaultProfile: config.get("defaultPermissionProfile"),
+      allowedProfiles: config.get("allowedPermissionProfiles"),
+      customProfileCount: Object.keys(config.get("permissionProfiles")).length,
+      legacyDefaultAction: config.get("defaultPermission"),
+      ruleCount: config.get("permissionRules").length
+    },
+    networkPolicy: {
+      enabled: network.enabled,
+      defaultAction: network.defaultAction,
+      allowDomains: network.allowDomains.length,
+      denyDomains: network.denyDomains.length,
+      allowPorts: network.allowPorts.length,
+      denyPorts: network.denyPorts.length,
+      allowPrivateNetwork: network.allowPrivateNetwork,
+      toolOverrides: Object.fromEntries(Object.entries(network.tools).filter(([, v]) => v !== void 0))
+    },
+    hooks: {
+      enabled: hooksConfig?.enabled !== false,
+      total: hooks.length,
+      project: hooks.filter((h) => h.source === "project").length,
+      pendingTrust: pendingHooks.length,
+      disabled: hooks.filter((h) => h.disabled).length
+    },
+    plugins: {
+      root: join21(configDir, "plugins"),
+      installed: plugins.length,
+      active: activeAssets.plugins.length,
+      invalid: plugins.filter((p) => !p.valid).length,
+      untrusted: plugins.filter((p) => p.valid && !p.trusted).length,
+      disabled: plugins.filter((p) => p.valid && !p.enabled).length,
+      mcpServers: Object.keys(activeAssets.mcpServers).length,
+      skillDirs: activeAssets.skillDirs.length,
+      commandDirs: activeAssets.commandDirs.length,
+      agentDirs: activeAssets.agentDirs.length,
+      entries: plugins.map((p) => ({ name: p.name, version: p.manifest.version, enabled: p.enabled, trusted: p.trusted, valid: p.valid, error: p.error }))
+    },
+    mcp: {
+      enabled: config.get("mcpEnabled"),
+      configured: Object.keys(mcpServers).length,
+      projectConfigExists: existsSync27(join21(projectRoot, MCP_PROJECT_CONFIG_NAME)),
+      statuses: options.mcpStatuses ?? []
+    },
+    recentCrashes: listRecentCrashes(5, configDir),
+    diskUsage: getConfigDirUsage(configDir),
+    toolStats: {
+      totalCalls: allStats.reduce((a, b) => a + b.calls, 0),
+      totalFailures: allStats.reduce((a, b) => a + b.failures, 0),
+      topUsed: getTopUsedTools(5),
+      topFailing: getTopFailingTools(5)
+    }
+  };
+}
+
+// src/diagnostics/doctor-cli.ts
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+function formatDoctorReport(report, ansi = true) {
+  const wrap = (code, s) => ansi ? `${code}${s}\x1B[0m` : s;
+  const B = (s) => wrap("\x1B[1m", s);
+  const D = (s) => wrap("\x1B[2m", s);
+  const G = (s) => wrap("\x1B[32m", s);
+  const Y = (s) => wrap("\x1B[33m", s);
+  const R = (s) => wrap("\x1B[31m", s);
+  const out = [];
+  out.push("");
+  out.push(B("\u{1FA7A} AI-CLI Health Check"));
+  out.push("");
+  const nc = report.npmCheck;
+  let versionLine = `  version:  ${report.version}`;
+  if (nc?.status === "up-to-date") versionLine += `  ${D("(latest on npm)")}`;
+  else if (nc?.status === "outdated" && nc.latest) versionLine += `  ${Y(`\u2192 ${nc.latest} available`)}  ${D("(npm i -g jinzd-ai-cli@latest)")}`;
+  else if (nc?.status === "skipped") versionLine += `  ${D(`(npm check skipped: ${nc.reason ?? "unknown"})`)}`;
+  out.push(versionLine);
+  out.push(`  node:     ${report.node}`);
+  out.push(`  platform: ${report.platform}`);
+  out.push(`  cwd:      ${report.cwd}`);
+  out.push(`  project:  ${report.projectRoot}`);
+  out.push(`  config:   ${report.configDir}`);
+  out.push("");
+  out.push(B("API Keys:"));
+  for (const p of report.providers) {
+    out.push(`  ${p.configured ? G("\u2713") : D("\u25CB")}  ${p.id.padEnd(14)} ${p.configured ? G("configured") : D("not configured")}`);
+  }
+  out.push("");
+  out.push(B("Context Files:"));
+  out.push(`  status: ${report.context.enabled ? G("enabled") : D("disabled")} \xB7 max ${formatBytes(report.context.maxBytes)}`);
+  if (report.context.layers.length === 0) out.push(`  ${D("(no context files loaded)")}`);
+  for (const l of report.context.layers) {
+    out.push(`  ${G("\u2713")}  ${l.level.padEnd(7)} ${l.displayPath} ${D(`(${formatBytes(l.bytes)}${l.truncated ? ", truncated" : ""})`)}`);
+  }
+  if (report.context.skipped.length > 0) {
+    out.push(`  ${D("skipped:")}`);
+    for (const s of report.context.skipped.slice(0, 5)) {
+      out.push(`    ${Y("!")} ${s.level}:${s.fileName} ${s.reason}${s.message ? ` \xB7 ${s.message}` : ""}`);
+    }
+  }
+  out.push("");
+  out.push(B("Permissions / Network:"));
+  out.push(`  profile: ${report.permissions.defaultProfile} \xB7 allowed ${report.permissions.allowedProfiles.join(", ")} \xB7 rules ${report.permissions.ruleCount} \xB7 custom profiles ${report.permissions.customProfileCount}`);
+  const np = report.networkPolicy;
+  out.push(`  networkPolicy: ${np.enabled ? G("enabled") : D("disabled")} \xB7 default ${np.defaultAction} \xB7 allow ${np.allowDomains} domain(s)/${np.allowPorts} port(s) \xB7 deny ${np.denyDomains} domain(s)/${np.denyPorts} port(s) \xB7 private ${np.allowPrivateNetwork ? "allow" : "block/confirm"}`);
+  const overrides = Object.entries(np.toolOverrides).map(([k, v]) => `${k}=${v}`).join(", ");
+  if (overrides) out.push(`  tool overrides: ${overrides}`);
+  out.push("");
+  out.push(B("Hooks / Plugins:"));
+  out.push(`  hooks: ${report.hooks.enabled ? G("enabled") : D("disabled")} \xB7 total ${report.hooks.total} \xB7 project ${report.hooks.project} \xB7 pending trust ${report.hooks.pendingTrust} \xB7 disabled ${report.hooks.disabled}`);
+  out.push(`  plugins: installed ${report.plugins.installed} \xB7 active ${report.plugins.active} \xB7 disabled ${report.plugins.disabled} \xB7 untrusted ${report.plugins.untrusted} \xB7 invalid ${report.plugins.invalid}`);
+  out.push(`  plugin assets: ${report.plugins.skillDirs} skill dir(s), ${report.plugins.commandDirs} command dir(s), ${report.plugins.agentDirs} agent dir(s), ${report.plugins.mcpServers} MCP server(s)`);
+  if (report.plugins.entries.length > 0) {
+    for (const p of report.plugins.entries.slice(0, 5)) {
+      const state2 = p.valid ? `${p.enabled ? "enabled" : "disabled"} \xB7 ${p.trusted ? "trusted" : "untrusted"}` : `invalid \xB7 ${p.error ?? ""}`;
+      out.push(`    ${p.valid ? G("\u2713") : R("\u2717")} ${p.name}@${p.version} ${D(state2)}`);
+    }
+  }
+  out.push("");
+  out.push(B("MCP Servers:"));
+  out.push(`  global configured: ${report.mcp.configured} \xB7 project .mcp.json: ${report.mcp.projectConfigExists ? "yes" : "no"} \xB7 mcpEnabled: ${report.mcp.enabled ? "true" : "false"}`);
+  if (report.mcp.statuses.length === 0) out.push(`  ${D("(no connected manager status in this mode)")}`);
+  for (const s of report.mcp.statuses) {
+    const state2 = s.connected ? `${G("connected")} \xB7 ${s.serverName} \xB7 ${s.toolCount} tools` : `${R("disconnected")}${s.error ? D(` \xB7 ${s.error}`) : ""}`;
+    out.push(`  ${s.connected ? G("\u2713") : R("\u2717")}  ${s.serverId.padEnd(16)} ${state2}`);
+  }
+  out.push("");
+  out.push(B("Config Files:"));
+  for (const f of report.files) {
+    const extra = f.exists && f.sizeBytes !== null ? ` ${D(`(${formatBytes(f.sizeBytes)})`)}` : "";
+    out.push(`  ${f.exists ? G("\u2713") : D("\u2013")}  ${f.label.padEnd(16)} ${f.exists ? f.path : D("(not found)")}${extra}`);
+  }
+  out.push("");
+  out.push(B("Recent Crashes (last 5):"));
+  if (report.recentCrashes.length === 0) out.push(`  ${D("(none - clean!)")}`);
+  for (const c of report.recentCrashes) {
+    out.push(`  ${R("\u2717")}  ${c.timestamp}  ${Y(c.kind)}`);
+    out.push(`     ${D(c.message)}`);
+    out.push(`     ${D(c.file)}`);
+  }
+  out.push("");
+  const ts = report.toolStats;
+  out.push(B("Tool Usage:"));
+  out.push(`  total: ${ts.totalCalls} calls \xB7 ${ts.totalFailures} failures (${ts.totalCalls ? (ts.totalFailures * 100 / ts.totalCalls).toFixed(1) : "0.0"}%)`);
+  if (ts.topUsed.length > 0) {
+    out.push(`  ${D("top used:")}`);
+    for (const t of ts.topUsed) out.push(`    ${t.name.padEnd(20)} ${String(t.calls).padStart(6)} calls \xB7 avg ${t.calls ? (t.totalDurationMs / t.calls).toFixed(0) : "0"}ms`);
+  }
+  if (ts.topFailing.length > 0) {
+    out.push(`  ${D("top failing:")}`);
+    for (const t of ts.topFailing) out.push(`    ${R(t.name.padEnd(20))} ${t.failures}/${t.calls} (${(t.failures * 100 / Math.max(1, t.calls)).toFixed(1)}%)  ${D(t.lastFailureMessage ?? "")}`.slice(0, 200));
+  }
+  out.push("");
+  const dirAnnotations = {
+    models: "semantic search model -> /index semantic-clear",
+    index: "symbol index -> /index clear",
+    history: "conversation history",
+    logs: "crash logs",
+    "memory-index": "chat memory index -> /memory index-clear",
+    plugins: "installed package plugins"
+  };
+  out.push(B("Disk Usage (~/.aicli):"));
+  out.push(`  total: ${formatBytes(report.diskUsage.totalBytes)}`);
+  for (const e of report.diskUsage.entries.slice(0, 10)) {
+    const note = dirAnnotations[e.name];
+    out.push(`    ${e.name.padEnd(18)} ${formatBytes(e.bytes)}${note ? `  ${D(`\xB7 ${note}`)}` : ""}`);
+  }
+  out.push("");
+  out.push(G("\u2713 Health check complete"));
+  out.push("");
+  return out.join("\n");
+}
+
 // src/hub/presets.ts
 var PRESETS = [
   {
@@ -14419,7 +14762,7 @@ function resolveRoleProviders(roles, lookup, defaultProvider, defaultModel, avai
 }
 
 // src/hub/persist.ts
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 function discussionToMessages(state2) {
   const out = [];
   const t0 = state2.messages[0]?.timestamp ?? /* @__PURE__ */ new Date();
@@ -14457,7 +14800,7 @@ async function persistDiscussion(state2, config, defaultProvider, defaultModel)
   session.title = `[Hub] ${state2.topic.slice(0, 48)}`.replace(/\n/g, " ");
   session.titleAiGenerated = true;
   await sm.save();
-  return { id: session.id, path: join20(config.getHistoryDir(), `${session.id}.json`) };
+  return { id: session.id, path: join22(config.getHistoryDir(), `${session.id}.json`) };
 }
 
 // src/web/session-handler.ts
@@ -15174,7 +15517,7 @@ Try: /compact to reduce context, /clear to reset, or switch to a larger-context
           this.send({ type: "response_done", content, usage });
           if (pendingTeeSave && isCleanDocumentBody(content)) {
             try {
-              mkdirSync12(dirname7(pendingTeeSave), { recursive: true });
+              mkdirSync13(dirname7(pendingTeeSave), { recursive: true });
               const bodyToSave = stripOuterCodeFence(content);
               atomicWriteFileSync(pendingTeeSave, bodyToSave);
               undoStack.push(pendingTeeSave, `save_last_response (deferred): ${pendingTeeSave}`);
@@ -15350,7 +15693,7 @@ ${summaryContent}`,
     let isError = false;
     let summary;
     try {
-      mkdirSync12(dirname7(saveToFile), { recursive: true });
+      mkdirSync13(dirname7(saveToFile), { recursive: true });
       fileStream = createWriteStream(saveToFile);
       const teeSystemPrompt = stripToolCallReminder(systemPrompt ?? "") + CONTENT_ONLY_STREAM_REMINDER;
       const teeExtraMessages = extraMessages.length > 0 ? [...extraMessages, { role: "user", content: TEE_FINAL_USER_NUDGE }] : [{ role: "user", content: TEE_FINAL_USER_NUDGE }];
@@ -16039,9 +16382,9 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
         let modifiedFiles = 0;
         const diffLines2 = [];
         for (const [filePath, { earliest }] of fileMap) {
-          const currentContent = existsSync26(filePath) ? (() => {
+          const currentContent = existsSync28(filePath) ? (() => {
             try {
-              return readFileSync20(filePath, "utf-8");
+              return readFileSync21(filePath, "utf-8");
             } catch {
               return null;
             }
@@ -16557,7 +16900,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-NXVVKAK2.js");
+          const { executeTests } = await import("./run-tests-O76JIBCW.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -16574,9 +16917,9 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       // ── /init ───────────────────────────────────────────────────────
       case "init": {
         const cwd = process.cwd();
-        const targetPath = join21(cwd, "AICLI.md");
+        const targetPath = join23(cwd, "AICLI.md");
         const force = args.includes("--force");
-        if (existsSync26(targetPath) && !force) {
+        if (existsSync28(targetPath) && !force) {
           this.send({ type: "info", message: `AICLI.md already exists at ${targetPath}
 Use /init --force to overwrite.` });
           break;
@@ -16586,7 +16929,7 @@ Use /init --force to overwrite.` });
           const projectInfo = scanProject(cwd);
           const prompt = buildInitPrompt(projectInfo, cwd);
           const content = await this.chatOnce(prompt, { temperature: 0.3, maxTokens: 4096 });
-          writeFileSync2(targetPath, content, "utf-8");
+          writeFileSync3(targetPath, content, "utf-8");
           this.send({ type: "info", message: `\u2713 Generated: ${targetPath} (${content.length} chars)
 Use /context reload to load it.` });
         } catch (err) {
@@ -16596,53 +16939,13 @@ Use /context reload to load it.` });
       }
       // ── /doctor ─────────────────────────────────────────────────────
       case "doctor": {
-        const lines = ["\u{1FA7A} **AI-CLI Health Check**", ""];
-        lines.push("**API Keys:**");
-        const providersList = this.providers.listAll();
-        for (const p of providersList) {
-          const icon = p.configured ? "\u2713" : "\u25CB";
-          const status = p.configured ? "configured" : "not configured";
-          lines.push(`  ${icon}  ${p.id.padEnd(14)} ${status}`);
-        }
-        lines.push("");
-        const configDir = this.config.getConfigDir();
-        lines.push("**Config Files:**");
-        lines.push(`  Dir: ${configDir}`);
-        const checkFile = (label, filePath) => {
-          const exists = existsSync26(filePath);
-          let extra = "";
-          if (exists) {
-            try {
-              extra = ` (${statSync9(filePath).size} bytes)`;
-            } catch {
-            }
-          }
-          lines.push(`  ${exists ? "\u2713" : "\u2013"}  ${label.padEnd(14)} ${exists ? filePath + extra : "(not found)"}`);
-        };
-        checkFile("config.json", join21(configDir, "config.json"));
-        checkFile("memory.md", join21(configDir, MEMORY_FILE_NAME));
-        checkFile("dev-state.md", join21(configDir, "dev-state.md"));
-        lines.push("");
-        if (this.mcpManager) {
-          lines.push("**MCP Servers:**");
-          const statuses = this.mcpManager.getStatus();
-          if (statuses.length === 0) {
-            lines.push("  (no servers configured)");
-          } else {
-            for (const s of statuses) {
-              const state2 = s.connected ? `connected \xB7 ${s.serverName} \xB7 ${s.toolCount} tools` : `disconnected${s.error ? ` \xB7 ${s.error}` : ""}`;
-              lines.push(`  ${s.connected ? "\u2713" : "\u2717"}  ${s.serverId.padEnd(16)} ${state2}`);
-            }
-          }
-          lines.push("");
-        }
-        lines.push("**Current Session:**");
-        lines.push(`  Provider: ${this.currentProvider}`);
-        lines.push(`  Model:    ${this.currentModel}`);
-        lines.push(`  Version:  ${VERSION}`);
-        lines.push("");
-        lines.push("\u2713 Health check complete");
-        this.send({ type: "info", message: lines.join("\n") });
+        const report = buildDoctorReport({
+          config: this.config,
+          providers: this.providers,
+          cwd: process.cwd(),
+          mcpStatuses: this.mcpManager?.getStatus() ?? []
+        });
+        this.send({ type: "info", message: formatDoctorReport(report, false) });
         break;
       }
       // ── /about ──────────────────────────────────────────────────────
@@ -16809,11 +17112,11 @@ Use /add-dir remove to clear.` : "No directories added.\nUsage: /add-dir <path>
           break;
         }
         const dirPath = resolve10(sub);
-        if (!existsSync26(dirPath)) {
+        if (!existsSync28(dirPath)) {
           this.send({ type: "error", message: `Directory not found: ${dirPath}` });
           break;
         }
-        if (!statSync9(dirPath).isDirectory()) {
+        if (!statSync11(dirPath).isDirectory()) {
           this.send({ type: "error", message: `Not a directory: ${dirPath}` });
           break;
         }
@@ -16825,14 +17128,14 @@ It will be included in AI context for subsequent messages.` });
       // ── /commands ───────────────────────────────────────────────────
       case "commands": {
         const configDir = this.config.getConfigDir();
-        const commandsDir = join21(configDir, CUSTOM_COMMANDS_DIR_NAME);
-        if (!existsSync26(commandsDir)) {
+        const commandsDir = join23(configDir, CUSTOM_COMMANDS_DIR_NAME);
+        if (!existsSync28(commandsDir)) {
           this.send({ type: "info", message: `No custom commands directory.
 Create: ${commandsDir}/ with .md files.` });
           break;
         }
         try {
-          const files = readdirSync12(commandsDir).filter((f) => f.endsWith(".md"));
+          const files = readdirSync13(commandsDir).filter((f) => f.endsWith(".md"));
           if (files.length === 0) {
             this.send({ type: "info", message: `No custom commands found in ${commandsDir}
 Add .md files to create commands.` });
@@ -16852,7 +17155,7 @@ Add .md files to create commands.` });
       // ── /plugins / /plugin ──────────────────────────────────────────
       case "plugins": {
         const configDir = this.config.getConfigDir();
-        const pluginsDir = join21(configDir, PLUGINS_DIR_NAME);
+        const pluginsDir = join23(configDir, PLUGINS_DIR_NAME);
         const pluginTools = this.toolRegistry.listPluginTools();
         const pluginPackages = listInstalledPlugins(configDir);
         const lines = [`\u{1F50C} **Plugins:**`, `Dir: ${pluginsDir}`, ""];
@@ -17134,7 +17437,7 @@ ${entry.content}`;
     const configDir = this.config.getConfigDir();
     try {
       atomicWriteFileSync(memoryStorePath(configDir), "");
-      atomicWriteFileSync(join21(configDir, MEMORY_FILE_NAME), "");
+      atomicWriteFileSync(join23(configDir, MEMORY_FILE_NAME), "");
       this.send({ type: "info", message: "\u{1F5D1}\uFE0F Persistent memory cleared." });
       this.sendMemoryEntries();
     } catch (err) {
@@ -17416,8 +17719,8 @@ async function setupProxy(configProxy) {
 }
 
 // src/web/auth.ts
-import { existsSync as existsSync27, readFileSync as readFileSync21, writeFileSync as writeFileSync3, mkdirSync as mkdirSync13, readdirSync as readdirSync13, copyFileSync } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync22, writeFileSync as writeFileSync4, mkdirSync as mkdirSync14, readdirSync as readdirSync14, copyFileSync } from "fs";
+import { join as join24 } from "path";
 import { createHmac, randomBytes, timingSafeEqual, pbkdf2Sync } from "crypto";
 var USERS_FILE = "users.json";
 var TOKEN_EXPIRY_HOURS = 24;
@@ -17432,7 +17735,7 @@ var AuthManager = class {
   db;
   constructor(baseDir) {
     this.baseDir = baseDir;
-    this.usersFile = join22(baseDir, USERS_FILE);
+    this.usersFile = join24(baseDir, USERS_FILE);
     this.db = this.loadOrCreate();
   }
   // ── Public API ─────────────────────────────────────────────────
@@ -17461,9 +17764,9 @@ var AuthManager = class {
     }
     const salt = randomBytes(16).toString("hex");
     const passwordHash = this.hashPassword(password, salt);
-    const dataDir = join22(USERS_DIR, username);
-    const fullDataDir = join22(this.baseDir, dataDir);
-    mkdirSync13(join22(fullDataDir, "history"), { recursive: true });
+    const dataDir = join24(USERS_DIR, username);
+    const fullDataDir = join24(this.baseDir, dataDir);
+    mkdirSync14(join24(fullDataDir, "history"), { recursive: true });
     const user = {
       username,
       passwordHash,
@@ -17578,7 +17881,7 @@ var AuthManager = class {
   getUserDataDir(username) {
     const user = this.db.users.find((u) => u.username === username);
     if (!user) throw new Error(`User not found: ${username}`);
-    return join22(this.baseDir, user.dataDir);
+    return join24(this.baseDir, user.dataDir);
   }
   /** List all usernames */
   listUsers() {
@@ -17614,30 +17917,30 @@ var AuthManager = class {
     const err = this.register(username, password);
     if (err) return err;
     const userDir = this.getUserDataDir(username);
-    const globalConfig = join22(this.baseDir, "config.json");
-    if (existsSync27(globalConfig)) {
+    const globalConfig = join24(this.baseDir, "config.json");
+    if (existsSync29(globalConfig)) {
       try {
-        const content = readFileSync21(globalConfig, "utf-8");
-        writeFileSync3(join22(userDir, "config.json"), content, "utf-8");
+        const content = readFileSync22(globalConfig, "utf-8");
+        writeFileSync4(join24(userDir, "config.json"), content, "utf-8");
       } catch {
       }
     }
-    const globalMemory = join22(this.baseDir, "memory.md");
-    if (existsSync27(globalMemory)) {
+    const globalMemory = join24(this.baseDir, "memory.md");
+    if (existsSync29(globalMemory)) {
       try {
-        const content = readFileSync21(globalMemory, "utf-8");
-        writeFileSync3(join22(userDir, "memory.md"), content, "utf-8");
+        const content = readFileSync22(globalMemory, "utf-8");
+        writeFileSync4(join24(userDir, "memory.md"), content, "utf-8");
       } catch {
       }
     }
-    const globalHistory = join22(this.baseDir, "history");
-    if (existsSync27(globalHistory)) {
+    const globalHistory = join24(this.baseDir, "history");
+    if (existsSync29(globalHistory)) {
       try {
-        const files = readdirSync13(globalHistory).filter((f) => f.endsWith(".json"));
-        const userHistory = join22(userDir, "history");
+        const files = readdirSync14(globalHistory).filter((f) => f.endsWith(".json"));
+        const userHistory = join24(userDir, "history");
         for (const f of files) {
           try {
-            copyFileSync(join22(globalHistory, f), join22(userHistory, f));
+            copyFileSync(join24(globalHistory, f), join24(userHistory, f));
           } catch {
           }
         }
@@ -17648,9 +17951,9 @@ var AuthManager = class {
   }
   // ── Private methods ────────────────────────────────────────────
   loadOrCreate() {
-    if (existsSync27(this.usersFile)) {
+    if (existsSync29(this.usersFile)) {
       try {
-        return JSON.parse(readFileSync21(this.usersFile, "utf-8"));
+        return JSON.parse(readFileSync22(this.usersFile, "utf-8"));
       } catch {
       }
     }
@@ -17666,7 +17969,7 @@ var AuthManager = class {
     this.saveDB(this.db);
   }
   saveDB(db) {
-    mkdirSync13(this.baseDir, { recursive: true });
+    mkdirSync14(this.baseDir, { recursive: true });
     atomicWriteFileSync(this.usersFile, JSON.stringify(db, null, 2));
   }
   /** Legacy hash — kept only for migrating old users (v0.2.x) */
@@ -17769,8 +18072,8 @@ async function startWebServer(options = {}) {
     }
   }
   let skillManager = null;
-  const skillsDir = join23(config.getConfigDir(), SKILLS_DIR_NAME);
-  if (existsSync28(skillsDir)) {
+  const skillsDir = join25(config.getConfigDir(), SKILLS_DIR_NAME);
+  if (existsSync30(skillsDir)) {
     skillManager = new SkillManager(skillsDir, config.get("ui").skillSizeWarn);
     skillManager.loadSkills(pluginAssets.skillDirs);
     const count = skillManager.listSkills().length;
@@ -17841,18 +18144,18 @@ async function startWebServer(options = {}) {
     next();
   };
   const moduleDir = getModuleDir();
-  let clientDir = join23(moduleDir, "web", "client");
-  if (!existsSync28(clientDir)) {
-    clientDir = join23(moduleDir, "client");
+  let clientDir = join25(moduleDir, "web", "client");
+  if (!existsSync30(clientDir)) {
+    clientDir = join25(moduleDir, "client");
   }
-  if (!existsSync28(clientDir)) {
-    clientDir = join23(moduleDir, "..", "..", "src", "web", "client");
+  if (!existsSync30(clientDir)) {
+    clientDir = join25(moduleDir, "..", "..", "src", "web", "client");
   }
-  if (!existsSync28(clientDir)) {
-    clientDir = join23(process.cwd(), "src", "web", "client");
+  if (!existsSync30(clientDir)) {
+    clientDir = join25(process.cwd(), "src", "web", "client");
   }
   console.log(`   Static files: ${clientDir}`);
-  app.use("/vendor", express.static(join23(clientDir, "vendor"), { maxAge: "1y", immutable: true }));
+  app.use("/vendor", express.static(join25(clientDir, "vendor"), { maxAge: "1y", immutable: true }));
   app.use(express.static(clientDir));
   app.get("/api/status", (_req, res) => {
     res.json({
@@ -17919,7 +18222,7 @@ async function startWebServer(options = {}) {
   app.get("/api/files", requireAuth, (req, res) => {
     const cwd = process.cwd();
     const prefix = req.query.prefix || "";
-    const targetDir = join23(cwd, prefix);
+    const targetDir = join25(cwd, prefix);
     try {
       const canonicalTarget = realpathSync(resolve11(targetDir));
       const canonicalCwd = realpathSync(resolve11(cwd));
@@ -17933,10 +18236,10 @@ async function startWebServer(options = {}) {
     }
     try {
       const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-cjs", "release", "__pycache__", ".next", ".nuxt", "coverage", ".cache"]);
-      const entries = readdirSync14(targetDir, { withFileTypes: true });
+      const entries = readdirSync15(targetDir, { withFileTypes: true });
       const files = entries.filter((e) => !SKIP.has(e.name) && !e.name.startsWith(".")).slice(0, 50).map((e) => ({
         name: e.name,
-        path: relative4(cwd, join23(targetDir, e.name)).replace(/\\/g, "/"),
+        path: relative4(cwd, join25(targetDir, e.name)).replace(/\\/g, "/"),
         isDir: e.isDirectory()
       }));
       res.json({ files });
@@ -17972,8 +18275,8 @@ async function startWebServer(options = {}) {
     try {
       const authUser = req._authUser;
       const histDir = authUser ? getUserShared(authUser).config.getHistoryDir() : config.getHistoryDir();
-      const filePath = join23(histDir, `${id}.json`);
-      if (!existsSync28(filePath)) {
+      const filePath = join25(histDir, `${id}.json`);
+      if (!existsSync30(filePath)) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
@@ -17988,7 +18291,7 @@ async function startWebServer(options = {}) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      const data = JSON.parse(readFileSync22(filePath, "utf-8"));
+      const data = JSON.parse(readFileSync23(filePath, "utf-8"));
       res.json({ session: data });
     } catch (err) {
       res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
@@ -18001,7 +18304,7 @@ async function startWebServer(options = {}) {
       return;
     }
     const cwd = process.cwd();
-    const fullPath = resolve11(join23(cwd, filePath));
+    const fullPath = resolve11(join25(cwd, filePath));
     try {
       const canonicalFull = realpathSync(fullPath);
       const canonicalCwd = realpathSync(resolve11(cwd));
@@ -18014,12 +18317,12 @@ async function startWebServer(options = {}) {
       return;
     }
     try {
-      const stat = statSync10(fullPath);
+      const stat = statSync12(fullPath);
       if (stat.size > 512 * 1024) {
         res.json({ error: `File too large (${(stat.size / 1024).toFixed(0)} KB, max 512 KB)` });
         return;
       }
-      const content = readFileSync22(fullPath, "utf-8");
+      const content = readFileSync23(fullPath, "utf-8");
       res.json({ content, size: stat.size });
     } catch {
       res.json({ error: "Cannot read file" });
@@ -18274,17 +18577,17 @@ function resolveProjectMcpPath() {
   const cwd = process.cwd();
   const gitRoot = getGitRoot(cwd);
   const projectRoot = gitRoot ?? cwd;
-  const configPath = join23(projectRoot, MCP_PROJECT_CONFIG_NAME);
-  return existsSync28(configPath) ? configPath : null;
+  const configPath = join25(projectRoot, MCP_PROJECT_CONFIG_NAME);
+  return existsSync30(configPath) ? configPath : null;
 }
 function loadProjectMcpConfig() {
   const cwd = process.cwd();
   const gitRoot = getGitRoot(cwd);
   const projectRoot = gitRoot ?? cwd;
-  const configPath = join23(projectRoot, MCP_PROJECT_CONFIG_NAME);
-  if (!existsSync28(configPath)) return null;
+  const configPath = join25(projectRoot, MCP_PROJECT_CONFIG_NAME);
+  if (!existsSync30(configPath)) return null;
   try {
-    const raw = JSON.parse(readFileSync22(configPath, "utf-8"));
+    const raw = JSON.parse(readFileSync23(configPath, "utf-8"));
     return raw.mcpServers ?? raw;
   } catch {
     return null;