lcclaude 1.0.0

package/dist/src/utils/diff.js

@@ -0,0 +1,92 @@
+import { structuredPatch } from "diff";
+import { logEvent } from "../services/analytics/index.js";
+import { getLocCounter } from "../bootstrap/state.js";
+import { addToTotalLinesChanged } from "../cost-tracker.js";
+import { count } from "./array.js";
+import { convertLeadingTabsToSpaces } from "./file.js";
+export const CONTEXT_LINES = 3;
+export const DIFF_TIMEOUT_MS = 5000;
+export function adjustHunkLineNumbers(hunks, offset) {
+  if (offset === 0)
+    return hunks;
+  return hunks.map((h) => ({
+    ...h,
+    oldStart: h.oldStart + offset,
+    newStart: h.newStart + offset
+  }));
+}
+const AMPERSAND_TOKEN = "<<:AMPERSAND_TOKEN:>>";
+const DOLLAR_TOKEN = "<<:DOLLAR_TOKEN:>>";
+function escapeForDiff(s) {
+  return s.replaceAll("&", AMPERSAND_TOKEN).replaceAll("$", DOLLAR_TOKEN);
+}
+function unescapeFromDiff(s) {
+  return s.replaceAll(AMPERSAND_TOKEN, "&").replaceAll(DOLLAR_TOKEN, "$");
+}
+export function countLinesChanged(patch, newFileContent) {
+  let numAdditions = 0;
+  let numRemovals = 0;
+  if (patch.length === 0 && newFileContent) {
+    numAdditions = newFileContent.split(/\r?\n/).length;
+  } else {
+    numAdditions = patch.reduce((acc, hunk) => acc + count(hunk.lines, (_) => _.startsWith("+")), 0);
+    numRemovals = patch.reduce((acc, hunk) => acc + count(hunk.lines, (_) => _.startsWith("-")), 0);
+  }
+  addToTotalLinesChanged(numAdditions, numRemovals);
+  getLocCounter()?.add(numAdditions, { type: "added" });
+  getLocCounter()?.add(numRemovals, { type: "removed" });
+  logEvent("tengu_file_changed", {
+    lines_added: numAdditions,
+    lines_removed: numRemovals
+  });
+}
+export function getPatchFromContents({
+  filePath,
+  oldContent,
+  newContent,
+  ignoreWhitespace = false,
+  singleHunk = false
+}) {
+  const result = structuredPatch(filePath, filePath, escapeForDiff(oldContent), escapeForDiff(newContent), undefined, undefined, {
+    ignoreWhitespace,
+    context: singleHunk ? 1e5 : CONTEXT_LINES,
+    timeout: DIFF_TIMEOUT_MS
+  });
+  if (!result) {
+    return [];
+  }
+  return result.hunks.map((_) => ({
+    ..._,
+    lines: _.lines.map(unescapeFromDiff)
+  }));
+}
+export function getPatchForDisplay({
+  filePath,
+  fileContents,
+  edits,
+  ignoreWhitespace = false
+}) {
+  const preparedFileContents = escapeForDiff(convertLeadingTabsToSpaces(fileContents));
+  const result = structuredPatch(filePath, filePath, preparedFileContents, edits.reduce((p, edit) => {
+    const { old_string, new_string } = edit;
+    const replace_all = "replace_all" in edit ? edit.replace_all : false;
+    const escapedOldString = escapeForDiff(convertLeadingTabsToSpaces(old_string));
+    const escapedNewString = escapeForDiff(convertLeadingTabsToSpaces(new_string));
+    if (replace_all) {
+      return p.replaceAll(escapedOldString, () => escapedNewString);
+    } else {
+      return p.replace(escapedOldString, () => escapedNewString);
+    }
+  }, preparedFileContents), undefined, undefined, {
+    context: CONTEXT_LINES,
+    ignoreWhitespace,
+    timeout: DIFF_TIMEOUT_MS
+  });
+  if (!result) {
+    return [];
+  }
+  return result.hunks.map((_) => ({
+    ..._,
+    lines: _.lines.map(unescapeFromDiff)
+  }));
+}

package/dist/src/utils/directMemberMessage.js

@@ -0,0 +1,27 @@
+export function parseDirectMemberMessage(input) {
+  const match = input.match(/^@([\w-]+)\s+(.+)$/s);
+  if (!match)
+    return null;
+  const [, recipientName, message] = match;
+  if (!recipientName || !message)
+    return null;
+  const trimmedMessage = message.trim();
+  if (!trimmedMessage)
+    return null;
+  return { recipientName, message: trimmedMessage };
+}
+export async function sendDirectMemberMessage(recipientName, message, teamContext, writeToMailbox) {
+  if (!teamContext || !writeToMailbox) {
+    return { success: false, error: "no_team_context" };
+  }
+  const member = Object.values(teamContext.teammates ?? {}).find((t) => t.name === recipientName);
+  if (!member) {
+    return { success: false, error: "unknown_recipient", recipientName };
+  }
+  await writeToMailbox(recipientName, {
+    from: "user",
+    text: message,
+    timestamp: new Date().toISOString()
+  }, teamContext.teamName);
+  return { success: true, recipientName };
+}

package/dist/src/utils/displayTags.js

@@ -0,0 +1,12 @@
+const XML_TAG_BLOCK_PATTERN = /<([a-z][\w-]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>\n?/g;
+export function stripDisplayTags(text) {
+  const result = text.replace(XML_TAG_BLOCK_PATTERN, "").trim();
+  return result || text;
+}
+export function stripDisplayTagsAllowEmpty(text) {
+  return text.replace(XML_TAG_BLOCK_PATTERN, "").trim();
+}
+const IDE_CONTEXT_TAGS_PATTERN = /<(ide_opened_file|ide_selection)(?:\s[^>]*)?>[\s\S]*?<\/\1>\n?/g;
+export function stripIdeContextTags(text) {
+  return text.replace(IDE_CONTEXT_TAGS_PATTERN, "").trim();
+}

package/dist/src/utils/doctorContextWarnings.js

@@ -0,0 +1,151 @@
+import { roughTokenCountEstimation } from "../services/tokenEstimation.js";
+import { countMcpToolTokens } from "./analyzeContext.js";
+import {
+  getLargeMemoryFiles,
+  getMemoryFiles,
+  MAX_MEMORY_CHARACTER_COUNT
+} from "./claudemd.js";
+import { getMainLoopModel } from "./model/model.js";
+import { permissionRuleValueToString } from "./permissions/permissionRuleParser.js";
+import { detectUnreachableRules } from "./permissions/shadowedRuleDetection.js";
+import { SandboxManager } from "./sandbox/sandbox-adapter.js";
+import {
+  AGENT_DESCRIPTIONS_THRESHOLD,
+  getAgentDescriptionsTotalTokens
+} from "./statusNoticeHelpers.js";
+import { plural } from "./stringUtils.js";
+const MCP_TOOLS_THRESHOLD = 25000;
+async function checkClaudeMdFiles() {
+  const largeFiles = getLargeMemoryFiles(await getMemoryFiles());
+  if (largeFiles.length === 0) {
+    return null;
+  }
+  const details = largeFiles.sort((a, b) => b.content.length - a.content.length).map((file) => `${file.path}: ${file.content.length.toLocaleString()} chars`);
+  const message = largeFiles.length === 1 ? `Large CLAUDE.md file detected (${largeFiles[0].content.length.toLocaleString()} chars > ${MAX_MEMORY_CHARACTER_COUNT.toLocaleString()})` : `${largeFiles.length} large CLAUDE.md files detected (each > ${MAX_MEMORY_CHARACTER_COUNT.toLocaleString()} chars)`;
+  return {
+    type: "claudemd_files",
+    severity: "warning",
+    message,
+    details,
+    currentValue: largeFiles.length,
+    threshold: MAX_MEMORY_CHARACTER_COUNT
+  };
+}
+async function checkAgentDescriptions(agentInfo) {
+  if (!agentInfo) {
+    return null;
+  }
+  const totalTokens = getAgentDescriptionsTotalTokens(agentInfo);
+  if (totalTokens <= AGENT_DESCRIPTIONS_THRESHOLD) {
+    return null;
+  }
+  const agentTokens = agentInfo.activeAgents.filter((a) => a.source !== "built-in").map((agent) => {
+    const description = `${agent.agentType}: ${agent.whenToUse}`;
+    return {
+      name: agent.agentType,
+      tokens: roughTokenCountEstimation(description)
+    };
+  }).sort((a, b) => b.tokens - a.tokens);
+  const details = agentTokens.slice(0, 5).map((agent) => `${agent.name}: ~${agent.tokens.toLocaleString()} tokens`);
+  if (agentTokens.length > 5) {
+    details.push(`(${agentTokens.length - 5} more custom agents)`);
+  }
+  return {
+    type: "agent_descriptions",
+    severity: "warning",
+    message: `Large agent descriptions (~${totalTokens.toLocaleString()} tokens > ${AGENT_DESCRIPTIONS_THRESHOLD.toLocaleString()})`,
+    details,
+    currentValue: totalTokens,
+    threshold: AGENT_DESCRIPTIONS_THRESHOLD
+  };
+}
+async function checkMcpTools(tools, getToolPermissionContext, agentInfo) {
+  const mcpTools = tools.filter((tool) => tool.isMcp);
+  if (mcpTools.length === 0) {
+    return null;
+  }
+  try {
+    const model = getMainLoopModel();
+    const { mcpToolTokens, mcpToolDetails } = await countMcpToolTokens(tools, getToolPermissionContext, agentInfo, model);
+    if (mcpToolTokens <= MCP_TOOLS_THRESHOLD) {
+      return null;
+    }
+    const toolsByServer = new Map;
+    for (const tool of mcpToolDetails) {
+      const parts = tool.name.split("__");
+      const serverName = parts[1] || "unknown";
+      const current = toolsByServer.get(serverName) || { count: 0, tokens: 0 };
+      toolsByServer.set(serverName, {
+        count: current.count + 1,
+        tokens: current.tokens + tool.tokens
+      });
+    }
+    const sortedServers = Array.from(toolsByServer.entries()).sort((a, b) => b[1].tokens - a[1].tokens);
+    const details = sortedServers.slice(0, 5).map(([name, info]) => `${name}: ${info.count} tools (~${info.tokens.toLocaleString()} tokens)`);
+    if (sortedServers.length > 5) {
+      details.push(`(${sortedServers.length - 5} more servers)`);
+    }
+    return {
+      type: "mcp_tools",
+      severity: "warning",
+      message: `Large MCP tools context (~${mcpToolTokens.toLocaleString()} tokens > ${MCP_TOOLS_THRESHOLD.toLocaleString()})`,
+      details,
+      currentValue: mcpToolTokens,
+      threshold: MCP_TOOLS_THRESHOLD
+    };
+  } catch (_error) {
+    const estimatedTokens = mcpTools.reduce((total, tool) => {
+      const chars = (tool.name?.length || 0) + tool.description.length;
+      return total + roughTokenCountEstimation(chars.toString());
+    }, 0);
+    if (estimatedTokens <= MCP_TOOLS_THRESHOLD) {
+      return null;
+    }
+    return {
+      type: "mcp_tools",
+      severity: "warning",
+      message: `Large MCP tools context (~${estimatedTokens.toLocaleString()} tokens estimated > ${MCP_TOOLS_THRESHOLD.toLocaleString()})`,
+      details: [
+        `${mcpTools.length} MCP tools detected (token count estimated)`
+      ],
+      currentValue: estimatedTokens,
+      threshold: MCP_TOOLS_THRESHOLD
+    };
+  }
+}
+async function checkUnreachableRules(getToolPermissionContext) {
+  const context = await getToolPermissionContext();
+  const sandboxAutoAllowEnabled = SandboxManager.isSandboxingEnabled() && SandboxManager.isAutoAllowBashIfSandboxedEnabled();
+  const unreachable = detectUnreachableRules(context, {
+    sandboxAutoAllowEnabled
+  });
+  if (unreachable.length === 0) {
+    return null;
+  }
+  const details = unreachable.flatMap((r) => [
+    `${permissionRuleValueToString(r.rule.ruleValue)}: ${r.reason}`,
+    `  Fix: ${r.fix}`
+  ]);
+  return {
+    type: "unreachable_rules",
+    severity: "warning",
+    message: `${unreachable.length} ${plural(unreachable.length, "unreachable permission rule")} detected`,
+    details,
+    currentValue: unreachable.length,
+    threshold: 0
+  };
+}
+export async function checkContextWarnings(tools, agentInfo, getToolPermissionContext) {
+  const [claudeMdWarning, agentWarning, mcpWarning, unreachableRulesWarning] = await Promise.all([
+    checkClaudeMdFiles(),
+    checkAgentDescriptions(agentInfo),
+    checkMcpTools(tools, getToolPermissionContext, agentInfo),
+    checkUnreachableRules(getToolPermissionContext)
+  ]);
+  return {
+    claudeMdWarning,
+    agentWarning,
+    mcpWarning,
+    unreachableRulesWarning
+  };
+}

package/dist/src/utils/doctorDiagnostic.js

@@ -0,0 +1,388 @@
+import { execa } from "execa";
+import { readFile, realpath } from "fs/promises";
+import { homedir } from "os";
+import { delimiter, join, posix, win32 } from "path";
+import { checkGlobalInstallPermissions } from "./autoUpdater.js";
+import { isInBundledMode } from "./bundledMode.js";
+import {
+  formatAutoUpdaterDisabledReason,
+  getAutoUpdaterDisabledReason,
+  getGlobalConfig
+} from "./config.js";
+import { getCwd } from "./cwd.js";
+import { isEnvTruthy } from "./envUtils.js";
+import { execFileNoThrow } from "./execFileNoThrow.js";
+import { getFsImplementation } from "./fsOperations.js";
+import {
+  getShellType,
+  isRunningFromLocalInstallation,
+  localInstallationExists
+} from "./localInstaller.js";
+import {
+  detectApk,
+  detectAsdf,
+  detectDeb,
+  detectHomebrew,
+  detectMise,
+  detectPacman,
+  detectRpm,
+  detectWinget,
+  getPackageManager
+} from "./nativeInstaller/packageManagers.js";
+import { getPlatform } from "./platform.js";
+import { getRipgrepStatus } from "./ripgrep.js";
+import { SandboxManager } from "./sandbox/sandbox-adapter.js";
+import { getManagedFilePath } from "./settings/managedPath.js";
+import { CUSTOMIZATION_SURFACES } from "./settings/types.js";
+import {
+  findClaudeAlias,
+  findValidClaudeAlias,
+  getShellConfigPaths
+} from "./shellConfig.js";
+import { jsonParse } from "./slowOperations.js";
+import { which } from "./which.js";
+function getNormalizedPaths() {
+  let invokedPath = process.argv[1] || "";
+  let execPath = process.execPath || process.argv[0] || "";
+  if (getPlatform() === "windows") {
+    invokedPath = invokedPath.split(win32.sep).join(posix.sep);
+    execPath = execPath.split(win32.sep).join(posix.sep);
+  }
+  return [invokedPath, execPath];
+}
+export async function getCurrentInstallationType() {
+  if (true) {
+    return "development";
+  }
+  const [invokedPath] = getNormalizedPaths();
+  if (isInBundledMode()) {
+    if (detectHomebrew() || detectWinget() || detectMise() || detectAsdf() || await detectPacman() || await detectDeb() || await detectRpm() || await detectApk()) {
+      return "package-manager";
+    }
+    return "native";
+  }
+  if (isRunningFromLocalInstallation()) {
+    return "npm-local";
+  }
+  const npmGlobalPaths = [
+    "/usr/local/lib/node_modules",
+    "/usr/lib/node_modules",
+    "/opt/homebrew/lib/node_modules",
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/.nvm/versions/node/"
+  ];
+  if (npmGlobalPaths.some((path) => invokedPath.includes(path))) {
+    return "npm-global";
+  }
+  if (invokedPath.includes("/npm/") || invokedPath.includes("/nvm/")) {
+    return "npm-global";
+  }
+  const npmConfigResult = await execa("npm config get prefix", {
+    shell: true,
+    reject: false
+  });
+  const globalPrefix = npmConfigResult.exitCode === 0 ? npmConfigResult.stdout.trim() : null;
+  if (globalPrefix && invokedPath.startsWith(globalPrefix)) {
+    return "npm-global";
+  }
+  return "unknown";
+}
+async function getInstallationPath() {
+  if (true) {
+    return getCwd();
+  }
+  if (isInBundledMode()) {
+    try {
+      return await realpath(process.execPath);
+    } catch {}
+    try {
+      const path = await which("claude");
+      if (path) {
+        return path;
+      }
+    } catch {}
+    try {
+      await getFsImplementation().stat(join(homedir(), ".local/bin/claude"));
+      return join(homedir(), ".local/bin/claude");
+    } catch {}
+    return "native";
+  }
+  try {
+    return process.argv[0] || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+export function getInvokedBinary() {
+  try {
+    if (isInBundledMode()) {
+      return process.execPath || "unknown";
+    }
+    return process.argv[1] || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function detectMultipleInstallations() {
+  const fs = getFsImplementation();
+  const installations = [];
+  const localPath = join(homedir(), ".claude", "local");
+  if (await localInstallationExists()) {
+    installations.push({ type: "npm-local", path: localPath });
+  }
+  const packagesToCheck = ["@anthropic-ai/claude-code"];
+  if (MACRO.PACKAGE_URL && MACRO.PACKAGE_URL !== "@anthropic-ai/claude-code") {
+    packagesToCheck.push(MACRO.PACKAGE_URL);
+  }
+  const npmResult = await execFileNoThrow("npm", [
+    "-g",
+    "config",
+    "get",
+    "prefix"
+  ]);
+  if (npmResult.code === 0 && npmResult.stdout) {
+    const npmPrefix = npmResult.stdout.trim();
+    const isWindows = getPlatform() === "windows";
+    const globalBinPath = isWindows ? join(npmPrefix, "claude") : join(npmPrefix, "bin", "claude");
+    let globalBinExists = false;
+    try {
+      await fs.stat(globalBinPath);
+      globalBinExists = true;
+    } catch {}
+    if (globalBinExists) {
+      let isCurrentHomebrewInstallation = false;
+      try {
+        const realPath = await realpath(globalBinPath);
+        if (realPath.includes("/Caskroom/")) {
+          isCurrentHomebrewInstallation = detectHomebrew();
+        }
+      } catch {}
+      if (!isCurrentHomebrewInstallation) {
+        installations.push({ type: "npm-global", path: globalBinPath });
+      }
+    } else {
+      for (const packageName of packagesToCheck) {
+        const globalPackagePath = isWindows ? join(npmPrefix, "node_modules", packageName) : join(npmPrefix, "lib", "node_modules", packageName);
+        try {
+          await fs.stat(globalPackagePath);
+          installations.push({
+            type: "npm-global-orphan",
+            path: globalPackagePath
+          });
+        } catch {}
+      }
+    }
+  }
+  const nativeBinPath = join(homedir(), ".local", "bin", "claude");
+  try {
+    await fs.stat(nativeBinPath);
+    installations.push({ type: "native", path: nativeBinPath });
+  } catch {}
+  const config = getGlobalConfig();
+  if (config.installMethod === "native") {
+    const nativeDataPath = join(homedir(), ".local", "share", "claude");
+    try {
+      await fs.stat(nativeDataPath);
+      if (!installations.some((i) => i.type === "native")) {
+        installations.push({ type: "native", path: nativeDataPath });
+      }
+    } catch {}
+  }
+  return installations;
+}
+async function detectConfigurationIssues(type) {
+  const warnings = [];
+  try {
+    const raw = await readFile(join(getManagedFilePath(), "managed-settings.json"), "utf-8");
+    const parsed = jsonParse(raw);
+    const field = parsed && typeof parsed === "object" ? parsed.strictPluginOnlyCustomization : undefined;
+    if (field !== undefined && typeof field !== "boolean") {
+      if (!Array.isArray(field)) {
+        warnings.push({
+          issue: `managed-settings.json: strictPluginOnlyCustomization has an invalid value (expected true or an array, got ${typeof field})`,
+          fix: `The field is silently ignored (schema .catch rescues it). Set it to true, or an array of: ${CUSTOMIZATION_SURFACES.join(", ")}.`
+        });
+      } else {
+        const unknown = field.filter((x) => typeof x === "string" && !CUSTOMIZATION_SURFACES.includes(x));
+        if (unknown.length > 0) {
+          warnings.push({
+            issue: `managed-settings.json: strictPluginOnlyCustomization has ${unknown.length} value(s) this client doesn't recognize: ${unknown.map(String).join(", ")}`,
+            fix: `These are silently ignored (forwards-compat). Known surfaces for this version: ${CUSTOMIZATION_SURFACES.join(", ")}. Either remove them, or this client is older than the managed-settings intended.`
+          });
+        }
+      }
+    }
+  } catch {}
+  const config = getGlobalConfig();
+  if (type === "development") {
+    return warnings;
+  }
+  if (type === "native") {
+    const path = process.env.PATH || "";
+    const pathDirectories = path.split(delimiter);
+    const homeDir = homedir();
+    const localBinPath = join(homeDir, ".local", "bin");
+    let normalizedLocalBinPath = localBinPath;
+    if (getPlatform() === "windows") {
+      normalizedLocalBinPath = localBinPath.split(win32.sep).join(posix.sep);
+    }
+    const localBinInPath = pathDirectories.some((dir) => {
+      let normalizedDir = dir;
+      if (getPlatform() === "windows") {
+        normalizedDir = dir.split(win32.sep).join(posix.sep);
+      }
+      const trimmedDir = normalizedDir.replace(/\/+$/, "");
+      const trimmedRawDir = dir.replace(/[/\\]+$/, "");
+      return trimmedDir === normalizedLocalBinPath || trimmedRawDir === "~/.local/bin" || trimmedRawDir === "$HOME/.local/bin";
+    });
+    if (!localBinInPath) {
+      const isWindows = getPlatform() === "windows";
+      if (isWindows) {
+        const windowsLocalBinPath = localBinPath.split(posix.sep).join(win32.sep);
+        warnings.push({
+          issue: `Native installation exists but ${windowsLocalBinPath} is not in your PATH`,
+          fix: `Add it by opening: System Properties → Environment Variables → Edit User PATH → New → Add the path above. Then restart your terminal.`
+        });
+      } else {
+        const shellType = getShellType();
+        const configPaths = getShellConfigPaths();
+        const configFile = configPaths[shellType];
+        const displayPath = configFile ? configFile.replace(homedir(), "~") : "your shell config file";
+        warnings.push({
+          issue: "Native installation exists but ~/.local/bin is not in your PATH",
+          fix: `Run: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ${displayPath} then open a new terminal or run: source ${displayPath}`
+        });
+      }
+    }
+  }
+  if (!isEnvTruthy(process.env.DISABLE_INSTALLATION_CHECKS)) {
+    if (type === "npm-local" && config.installMethod !== "local") {
+      warnings.push({
+        issue: `Running from local installation but config install method is '${config.installMethod}'`,
+        fix: "Consider using native installation: claude install"
+      });
+    }
+    if (type === "native" && config.installMethod !== "native") {
+      warnings.push({
+        issue: `Running native installation but config install method is '${config.installMethod}'`,
+        fix: "Run claude install to update configuration"
+      });
+    }
+  }
+  if (type === "npm-global" && await localInstallationExists()) {
+    warnings.push({
+      issue: "Local installation exists but not being used",
+      fix: "Consider using native installation: claude install"
+    });
+  }
+  const existingAlias = await findClaudeAlias();
+  const validAlias = await findValidClaudeAlias();
+  if (type === "npm-local") {
+    const whichResult = await which("claude");
+    const claudeInPath = !!whichResult;
+    if (!claudeInPath && !validAlias) {
+      if (existingAlias) {
+        warnings.push({
+          issue: "Local installation not accessible",
+          fix: `Alias exists but points to invalid target: ${existingAlias}. Update alias: alias claude="~/.claude/local/claude"`
+        });
+      } else {
+        warnings.push({
+          issue: "Local installation not accessible",
+          fix: 'Create alias: alias claude="~/.claude/local/claude"'
+        });
+      }
+    }
+  }
+  return warnings;
+}
+export function detectLinuxGlobPatternWarnings() {
+  if (getPlatform() !== "linux") {
+    return [];
+  }
+  const warnings = [];
+  const globPatterns = SandboxManager.getLinuxGlobPatternWarnings();
+  if (globPatterns.length > 0) {
+    const displayPatterns = globPatterns.slice(0, 3).join(", ");
+    const remaining = globPatterns.length - 3;
+    const patternList = remaining > 0 ? `${displayPatterns} (${remaining} more)` : displayPatterns;
+    warnings.push({
+      issue: `Glob patterns in sandbox permission rules are not fully supported on Linux`,
+      fix: `Found ${globPatterns.length} pattern(s): ${patternList}. On Linux, glob patterns in Edit/Read rules will be ignored.`
+    });
+  }
+  return warnings;
+}
+export async function getDoctorDiagnostic() {
+  const installationType = await getCurrentInstallationType();
+  const version = typeof MACRO !== "undefined" && MACRO.VERSION ? MACRO.VERSION : "unknown";
+  const installationPath = await getInstallationPath();
+  const invokedBinary = getInvokedBinary();
+  const multipleInstallations = await detectMultipleInstallations();
+  const warnings = await detectConfigurationIssues(installationType);
+  warnings.push(...detectLinuxGlobPatternWarnings());
+  if (installationType === "native") {
+    const npmInstalls = multipleInstallations.filter((i) => i.type === "npm-global" || i.type === "npm-global-orphan" || i.type === "npm-local");
+    const isWindows = getPlatform() === "windows";
+    for (const install of npmInstalls) {
+      if (install.type === "npm-global") {
+        let uninstallCmd = "npm -g uninstall @anthropic-ai/claude-code";
+        if (MACRO.PACKAGE_URL && MACRO.PACKAGE_URL !== "@anthropic-ai/claude-code") {
+          uninstallCmd += ` && npm -g uninstall ${MACRO.PACKAGE_URL}`;
+        }
+        warnings.push({
+          issue: `Leftover npm global installation at ${install.path}`,
+          fix: `Run: ${uninstallCmd}`
+        });
+      } else if (install.type === "npm-global-orphan") {
+        warnings.push({
+          issue: `Orphaned npm global package at ${install.path}`,
+          fix: isWindows ? `Run: rmdir /s /q "${install.path}"` : `Run: rm -rf ${install.path}`
+        });
+      } else if (install.type === "npm-local") {
+        warnings.push({
+          issue: `Leftover npm local installation at ${install.path}`,
+          fix: isWindows ? `Run: rmdir /s /q "${install.path}"` : `Run: rm -rf ${install.path}`
+        });
+      }
+    }
+  }
+  const config = getGlobalConfig();
+  const configInstallMethod = config.installMethod || "not set";
+  let hasUpdatePermissions = null;
+  if (installationType === "npm-global") {
+    const permCheck = await checkGlobalInstallPermissions();
+    hasUpdatePermissions = permCheck.hasPermissions;
+    if (!hasUpdatePermissions && !getAutoUpdaterDisabledReason()) {
+      warnings.push({
+        issue: "Insufficient permissions for auto-updates",
+        fix: "Do one of: (1) Re-install node without sudo, or (2) Use `claude install` for native installation"
+      });
+    }
+  }
+  const ripgrepStatusRaw = getRipgrepStatus();
+  const ripgrepStatus = {
+    working: ripgrepStatusRaw.working ?? true,
+    mode: ripgrepStatusRaw.mode,
+    systemPath: ripgrepStatusRaw.mode === "system" ? ripgrepStatusRaw.path : null
+  };
+  const packageManager = installationType === "package-manager" ? await getPackageManager() : undefined;
+  const diagnostic = {
+    installationType,
+    version,
+    installationPath,
+    invokedBinary,
+    configInstallMethod,
+    autoUpdates: (() => {
+      const reason = getAutoUpdaterDisabledReason();
+      return reason ? `disabled (${formatAutoUpdaterDisabledReason(reason)})` : "enabled";
+    })(),
+    hasUpdatePermissions,
+    multipleInstallations,
+    warnings,
+    packageManager,
+    ripgrepStatus
+  };
+  return diagnostic;
+}