docdex 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.2.3
+## 0.2.5
 - Added glama support
 
 ## 0.1.10

package/README.md

@@ -12,6 +12,7 @@ Docdex is a local-first docs + code indexer/search daemon. It runs per repo, kee
 - If you publish from a fork, set `DOCDEX_DOWNLOAD_REPO=<owner/repo>` before installing so the downloader fetches your release assets.
 - If you mirror release assets locally, set `DOCDEX_DOWNLOAD_BASE=http://host/path` to point the installer at the mirror.
 - Distribution: binaries stay in GitHub Releases (small npm package); postinstall fetches `docdexd-<platform>.tar.gz` matching the npm version.
+- Local dev install: if the release manifest/checksums are missing and a local `target/release/docdexd` (or `target/debug/docdexd`) exists, the installer falls back to that binary. Set `DOCDEX_LOCAL_FALLBACK=0` to disable or `DOCDEX_LOCAL_BINARY=/path/to/docdexd` to override.
 - Platform diagnostics (no download): `docdex doctor` (or `docdex diagnostics`) prints detected OS/arch(/libc), whether supported, and the expected Rust target triple + release asset naming pattern.
 - Publishing uses npm Trusted Publishing (OIDC) — no NPM token needed; see `.github/workflows/release.yml`.
 - Postinstall prompts: if Ollama is missing, the installer asks to install Ollama and `nomic-embed-text`. If Ollama is available, it prompts to pick a default chat model and can install `phi3.5:3.8b` (~2.2 GB) while showing free disk space. Skip with `DOCDEX_OLLAMA_INSTALL=0` or `DOCDEX_OLLAMA_MODEL_PROMPT=0`; force with `DOCDEX_OLLAMA_INSTALL=1` or `DOCDEX_OLLAMA_MODEL=<model>`; preselect with `DOCDEX_OLLAMA_DEFAULT_MODEL`.

package/lib/install.js

@@ -37,6 +37,8 @@ const DEFAULT_INTEGRITY_CONFIG = Object.freeze({
   metadataSources: ["manifest", "checksums", "sidecar"],
   missingPolicy: "fallback"
 });
+const LOCAL_FALLBACK_ENV = "DOCDEX_LOCAL_FALLBACK";
+const LOCAL_BINARY_ENV = "DOCDEX_LOCAL_BINARY";
 
 const EXIT_CODE_BY_ERROR_CODE = Object.freeze({
   DOCDEX_INSTALLER_CONFIG: 2,
@@ -361,6 +363,141 @@ function normalizeSha256Hex(value) {
   return trimmed;
 }
 
+function parseEnvBool(value) {
+  if (value == null) return null;
+  const normalized = String(value).trim().toLowerCase();
+  if (["1", "true", "yes", "y", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "n", "off"].includes(normalized)) return false;
+  return null;
+}
+
+function detectLocalRepoRoot({ pathModule, fsModule } = {}) {
+  const pathImpl = pathModule || path;
+  const fsImpl = fsModule || fs;
+  const candidate = pathImpl.resolve(__dirname, "..", "..");
+  const hasCargo = fsImpl.existsSync(pathImpl.join(candidate, "Cargo.toml"));
+  const hasGit = fsImpl.existsSync(pathImpl.join(candidate, ".git"));
+  if (hasCargo || hasGit) {
+    return candidate;
+  }
+  return null;
+}
+
+function resolveLocalBinaryCandidate({
+  env = process.env,
+  platform = process.platform,
+  pathModule = path,
+  fsModule = fs,
+  repoRoot
+} = {}) {
+  const explicit = env[LOCAL_BINARY_ENV];
+  if (explicit) {
+    const resolved = pathModule.resolve(explicit);
+    if (fsModule.existsSync(resolved)) return resolved;
+  }
+  const root = repoRoot || detectLocalRepoRoot({ pathModule, fsModule });
+  if (!root) return null;
+  const binaryName = platform === "win32" ? "docdexd.exe" : "docdexd";
+  const releasePath = pathModule.join(root, "target", "release", binaryName);
+  if (fsModule.existsSync(releasePath)) return releasePath;
+  const debugPath = pathModule.join(root, "target", "debug", binaryName);
+  if (fsModule.existsSync(debugPath)) return debugPath;
+  return null;
+}
+
+async function installFromLocalBinary({
+  fsModule,
+  pathModule,
+  distDir,
+  binaryPath,
+  isWin32,
+  version,
+  platformKey,
+  targetTriple,
+  repoSlug,
+  sha256FileFn,
+  writeJsonFileAtomicFn,
+  logger
+}) {
+  await fsModule.promises.rm(distDir, { recursive: true, force: true });
+  await fsModule.promises.mkdir(distDir, { recursive: true });
+  const filename = isWin32 ? "docdexd.exe" : "docdexd";
+  const destPath = pathModule.join(distDir, filename);
+  await fsModule.promises.copyFile(binaryPath, destPath);
+  if (!isWin32) {
+    await fsModule.promises.chmod(destPath, 0o755).catch(() => {});
+  }
+  const binarySha256 = await sha256FileFn(destPath);
+  const metadata = {
+    schemaVersion: INSTALL_METADATA_SCHEMA_VERSION,
+    installedAt: nowIso(),
+    version,
+    repoSlug: repoSlug || "local",
+    platformKey,
+    targetTriple,
+    binary: {
+      filename,
+      sha256: binarySha256
+    },
+    archive: {
+      name: null,
+      sha256: null,
+      source: "local",
+      downloadUrl: null
+    }
+  };
+  await writeJsonFileAtomicFn({
+    fsModule,
+    pathModule,
+    filePath: installMetadataPath(distDir, pathModule),
+    value: metadata
+  });
+  logger?.warn?.(`[docdex] Installed local binary from ${binaryPath}`);
+  return { binaryPath: destPath, outcome: "local", outcomeCode: "local" };
+}
+
+async function maybeInstallLocalFallback({
+  err,
+  env,
+  fsModule,
+  pathModule,
+  distDir,
+  isWin32,
+  version,
+  platformKey,
+  targetTriple,
+  repoSlug,
+  sha256FileFn,
+  writeJsonFileAtomicFn,
+  logger,
+  localRepoRoot,
+  localBinaryPath
+}) {
+  if (!err || err.code !== "DOCDEX_CHECKSUM_UNUSABLE") return null;
+  const allowFallback = parseEnvBool(env[LOCAL_FALLBACK_ENV]);
+  if (allowFallback === false) return null;
+
+  const candidate =
+    localBinaryPath ||
+    resolveLocalBinaryCandidate({ env, platform: process.platform, pathModule, fsModule, repoRoot: localRepoRoot });
+  if (!candidate) return null;
+
+  return installFromLocalBinary({
+    fsModule,
+    pathModule,
+    distDir,
+    binaryPath: candidate,
+    isWin32,
+    version,
+    platformKey,
+    targetTriple,
+    repoSlug,
+    sha256FileFn,
+    writeJsonFileAtomicFn,
+    logger
+  });
+}
+
 function emitInstallerEvent(logger, payload) {
   if (!logger || typeof logger.log !== "function") return;
   try {
@@ -1348,6 +1485,8 @@ async function runInstaller(options) {
   const sha256FileFn = opts.sha256FileFn || sha256File;
   const writeJsonFileAtomicFn = opts.writeJsonFileAtomicFn || writeJsonFileAtomic;
   const restartFn = opts.restartFn;
+  const localRepoRoot = opts.localRepoRoot;
+  const localBinaryPath = opts.localBinaryPath;
 
   const detectedPlatform = opts.platform || process.platform;
   const detectedArch = opts.arch || process.arch;
@@ -1431,16 +1570,48 @@ async function runInstaller(options) {
     };
   }
 
-  const repoSlug = parseRepoSlugFn();
-
-  const { archive, expectedSha256, source, manifestAttempt } = await resolveInstallerDownloadPlanFn({
-    repoSlug,
-    version,
-    platformKey,
-    targetTriple,
-    logger,
-    integrityConfigFn: opts.integrityConfigFn
-  });
+  let repoSlug = null;
+  let archive;
+  let expectedSha256;
+  let source;
+  let manifestAttempt;
+  try {
+    repoSlug = parseRepoSlugFn();
+    const resolved = await resolveInstallerDownloadPlanFn({
+      repoSlug,
+      version,
+      platformKey,
+      targetTriple,
+      logger,
+      integrityConfigFn: opts.integrityConfigFn
+    });
+    archive = resolved.archive;
+    expectedSha256 = resolved.expectedSha256;
+    source = resolved.source;
+    manifestAttempt = resolved.manifestAttempt;
+  } catch (err) {
+    const fallback = await maybeInstallLocalFallback({
+      err,
+      env: process.env,
+      fsModule,
+      pathModule,
+      distDir,
+      isWin32,
+      version,
+      platformKey,
+      targetTriple,
+      repoSlug,
+      sha256FileFn,
+      writeJsonFileAtomicFn,
+      logger,
+      localRepoRoot,
+      localBinaryPath
+    });
+    if (fallback) {
+      return fallback;
+    }
+    throw err;
+  }
 
   const downloadUrl = `${getDownloadBaseFn(repoSlug)}/v${version}/${archive}`;
   const nonce = buildInstallNonce();

package/lib/postinstall_setup.js

@@ -158,22 +158,166 @@ function upsertMcpServerJson(pathname, url) {
 }
 
 function upsertCodexConfig(pathname, url) {
+  const hasSection = (contents, section) =>
+    new RegExp(`^\\s*\\[${section}\\]\\s*$`, "m").test(contents);
+  const hasNestedMcpServers = (contents) =>
+    /^\s*\[mcp_servers\.[^\]]+\]\s*$/m.test(contents);
+  const parseTomlString = (value) => {
+    const trimmed = value.trim();
+    const quoted = trimmed.match(/^"(.*)"$/) || trimmed.match(/^'(.*)'$/);
+    return quoted ? quoted[1] : trimmed;
+  };
+  const migrateLegacyMcpServers = (contents) => {
+    if (!/\[\[mcp_servers\]\]/m.test(contents)) {
+      return { contents, migrated: false };
+    }
+    const lines = contents.split(/\r?\n/);
+    const output = [];
+    const entries = [];
+    let inBlock = false;
+    let current = null;
+
+    for (const line of lines) {
+      if (/^\s*\[\[mcp_servers\]\]\s*$/.test(line)) {
+        if (current) entries.push(current);
+        current = {};
+        inBlock = true;
+        continue;
+      }
+      if (inBlock) {
+        if (/^\s*\[.+\]\s*$/.test(line)) {
+          if (current) entries.push(current);
+          current = null;
+          inBlock = false;
+          output.push(line);
+          continue;
+        }
+        const match = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=\s*(.+?)\s*$/);
+        if (match) {
+          current[match[1]] = match[2].trim();
+        }
+        continue;
+      }
+      output.push(line);
+    }
+    if (current) entries.push(current);
+
+    const mapLines = [];
+    for (const entry of entries) {
+      if (!entry.name) continue;
+      const name = parseTomlString(entry.name);
+      if (!name) continue;
+      mapLines.push(`[mcp_servers.${name}]`);
+      for (const [key, value] of Object.entries(entry)) {
+        if (key === "name") continue;
+        mapLines.push(`${key} = ${value}`);
+      }
+      mapLines.push("");
+    }
+
+    if (mapLines.length === 0) {
+      return { contents: output.join("\n"), migrated: true };
+    }
+    if (output.length && output[output.length - 1].trim()) output.push("");
+    while (mapLines.length && !mapLines[mapLines.length - 1].trim()) mapLines.pop();
+    output.push(...mapLines);
+    return { contents: output.join("\n"), migrated: true };
+  };
+
+  const upsertDocdexNested = (contents, urlValue) => {
+    const lines = contents.split(/\r?\n/);
+    const headerRe = /^\s*\[mcp_servers\.docdex\]\s*$/;
+    let start = lines.findIndex((line) => headerRe.test(line));
+    if (start === -1) {
+      if (lines.length && lines[lines.length - 1].trim()) lines.push("");
+      lines.push("[mcp_servers.docdex]");
+      lines.push(`url = "${urlValue}"`);
+      return { contents: lines.join("\n"), updated: true };
+    }
+    let end = start + 1;
+    while (end < lines.length && !/^\s*\[.+\]\s*$/.test(lines[end])) {
+      end += 1;
+    }
+    let updated = false;
+    let urlIndex = -1;
+    for (let i = start + 1; i < end; i += 1) {
+      if (/^\s*url\s*=/.test(lines[i])) {
+        urlIndex = i;
+        break;
+      }
+    }
+    if (urlIndex === -1) {
+      lines.splice(start + 1, 0, `url = "${urlValue}"`);
+      updated = true;
+    } else if (!lines[urlIndex].includes(`"${urlValue}"`)) {
+      lines[urlIndex] = `url = "${urlValue}"`;
+      updated = true;
+    }
+    return { contents: lines.join("\n"), updated };
+  };
+
+  const upsertDocdexRoot = (contents, urlValue) => {
+    const lines = contents.split(/\r?\n/);
+    const headerRe = /^\s*\[mcp_servers\]\s*$/;
+    const start = lines.findIndex((line) => headerRe.test(line));
+    if (start === -1) {
+      if (lines.length && lines[lines.length - 1].trim()) lines.push("");
+      lines.push("[mcp_servers]");
+      lines.push(`docdex = { url = "${urlValue}" }`);
+      return { contents: lines.join("\n"), updated: true };
+    }
+    let end = start + 1;
+    while (end < lines.length && !/^\s*\[.+\]\s*$/.test(lines[end])) {
+      end += 1;
+    }
+    let updated = false;
+    let docdexLine = -1;
+    for (let i = start + 1; i < end; i += 1) {
+      if (/^\s*docdex\s*=/.test(lines[i])) {
+        docdexLine = i;
+        break;
+      }
+    }
+    if (docdexLine === -1) {
+      lines.splice(end, 0, `docdex = { url = "${urlValue}" }`);
+      updated = true;
+    } else if (!lines[docdexLine].includes(`"${urlValue}"`)) {
+      lines[docdexLine] = `docdex = { url = "${urlValue}" }`;
+      updated = true;
+    }
+    return { contents: lines.join("\n"), updated };
+  };
+
   let contents = "";
   if (fs.existsSync(pathname)) {
     contents = fs.readFileSync(pathname, "utf8");
   }
-  if (/name\s*=\s*\"docdex\"/.test(contents) || /docdex/.test(contents) && /mcp_servers/.test(contents)) {
+  let updated = false;
+  if (/\[\[mcp_servers\]\]/m.test(contents)) {
+    const migrated = migrateLegacyMcpServers(contents);
+    contents = migrated.contents;
+    updated = updated || migrated.migrated;
+  }
+
+  if (hasNestedMcpServers(contents)) {
+    const nested = upsertDocdexNested(contents, url);
+    contents = nested.contents;
+    updated = updated || nested.updated;
+  } else if (hasSection(contents, "mcp_servers")) {
+    const root = upsertDocdexRoot(contents, url);
+    contents = root.contents;
+    updated = updated || root.updated;
+  } else {
+    const root = upsertDocdexRoot(contents, url);
+    contents = root.contents;
+    updated = updated || root.updated;
+  }
+
+  if (!updated) {
     return false;
   }
-  const block = [
-    "",
-    "[[mcp_servers]]",
-    'name = "docdex"',
-    `url = "${url}"`,
-    "",
-  ].join("\n");
   fs.mkdirSync(path.dirname(pathname), { recursive: true });
-  fs.writeFileSync(pathname, contents + block);
+  fs.writeFileSync(pathname, contents.endsWith("\n") ? contents : `${contents}\n`);
   return true;
 }
 
@@ -233,24 +377,52 @@ function parseEnvBool(value) {
   return null;
 }
 
-function resolveOllamaInstallMode({ env = process.env, stdin = process.stdin, stdout = process.stdout } = {}) {
+function hasInteractiveTty(stdin, stdout) {
+  return Boolean((stdin && stdin.isTTY) || (stdout && stdout.isTTY));
+}
+
+function canPromptWithTty(stdin, stdout) {
+  if (hasInteractiveTty(stdin, stdout)) return true;
+  const ttyPath = process.platform === "win32" ? "CONIN$" : "/dev/tty";
+  try {
+    const fd = fs.openSync(ttyPath, "r");
+    fs.closeSync(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveOllamaInstallMode({
+  env = process.env,
+  stdin = process.stdin,
+  stdout = process.stdout,
+  canPrompt = canPromptWithTty
+} = {}) {
   const override = parseEnvBool(env.DOCDEX_OLLAMA_INSTALL);
   if (override === true) return { mode: "install", reason: "env", interactive: false };
   if (override === false) return { mode: "skip", reason: "env", interactive: false };
-  const hasTty = Boolean(stdin && stdout && stdin.isTTY && stdout.isTTY);
-  if (!hasTty) return { mode: "skip", reason: "non_interactive", interactive: false };
+  if (!canPrompt(stdin, stdout)) {
+    return { mode: "skip", reason: "non_interactive", interactive: false };
+  }
   if (env.CI) return { mode: "skip", reason: "ci", interactive: false };
   return { mode: "prompt", reason: "interactive", interactive: true };
 }
 
-function resolveOllamaModelPromptMode({ env = process.env, stdin = process.stdin, stdout = process.stdout } = {}) {
+function resolveOllamaModelPromptMode({
+  env = process.env,
+  stdin = process.stdin,
+  stdout = process.stdout,
+  canPrompt = canPromptWithTty
+} = {}) {
   const override = parseEnvBool(env.DOCDEX_OLLAMA_MODEL_PROMPT);
   if (override === true) return { mode: "prompt", reason: "env", interactive: true };
   if (override === false) return { mode: "skip", reason: "env", interactive: false };
   const assumeYes = parseEnvBool(env.DOCDEX_OLLAMA_MODEL_ASSUME_Y);
   if (assumeYes === true) return { mode: "auto", reason: "env", interactive: false };
-  const hasTty = Boolean(stdin && stdout && stdin.isTTY && stdout.isTTY);
-  if (!hasTty) return { mode: "skip", reason: "non_interactive", interactive: false };
+  if (!canPrompt(stdin, stdout)) {
+    return { mode: "skip", reason: "non_interactive", interactive: false };
+  }
   if (env.CI) return { mode: "skip", reason: "ci", interactive: false };
   return { mode: "prompt", reason: "interactive", interactive: true };
 }
@@ -408,11 +580,27 @@ function isOllamaAvailable() {
   return isCommandAvailable("ollama", ["--version"]);
 }
 
+function resolvePromptStreams(stdin, stdout) {
+  if (hasInteractiveTty(stdin, stdout)) {
+    return { input: stdin, output: stdout, close: null };
+  }
+  const isWindows = process.platform === "win32";
+  const ttyPath = isWindows ? "CONIN$" : "/dev/tty";
+  try {
+    const input = fs.createReadStream(ttyPath, { autoClose: true });
+    return { input, output: stdout, close: () => input.close() };
+  } catch {
+    return { input: stdin, output: stdout, close: null };
+  }
+}
+
 function promptYesNo(question, { defaultYes = true, stdin = process.stdin, stdout = process.stdout } = {}) {
   return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const { input, output, close } = resolvePromptStreams(stdin, stdout);
+    const rl = readline.createInterface({ input, output });
     rl.question(question, (answer) => {
       rl.close();
+      if (typeof close === "function") close();
       const normalized = String(answer || "").trim().toLowerCase();
       if (!normalized) return resolve(defaultYes);
       resolve(["y", "yes"].includes(normalized));
@@ -422,9 +610,11 @@ function promptYesNo(question, { defaultYes = true, stdin = process.stdin, stdou
 
 function promptInput(question, { stdin = process.stdin, stdout = process.stdout } = {}) {
   return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const { input, output, close } = resolvePromptStreams(stdin, stdout);
+    const rl = readline.createInterface({ input, output });
     rl.question(question, (answer) => {
       rl.close();
+      if (typeof close === "function") close();
       resolve(String(answer || "").trim());
     });
   });
@@ -881,5 +1071,7 @@ module.exports = {
   readLlmDefaultModel,
   upsertLlmDefaultModel,
   pullOllamaModel,
-  listOllamaModels
+  listOllamaModels,
+  hasInteractiveTty,
+  canPromptWithTty
 };

package/lib/uninstall.js

@@ -0,0 +1,420 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const DAEMON_TASK_NAME = "Docdex Daemon";
+const STARTUP_FAILURE_MARKER = "startup_registration_failed.json";
+
+function daemonRootPath() {
+  return path.join(os.homedir(), ".docdex", "daemon_root");
+}
+
+function stateDir() {
+  return path.join(os.homedir(), ".docdex", "state");
+}
+
+function daemonLockPath() {
+  const override = process.env.DOCDEX_DAEMON_LOCK_PATH;
+  if (override && override.trim()) return override.trim();
+  return path.join(os.homedir(), ".docdex", "daemon.lock");
+}
+
+function clientConfigPaths() {
+  const home = os.homedir();
+  const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+  const userProfile = process.env.USERPROFILE || home;
+  switch (process.platform) {
+    case "win32":
+      return {
+        json: [
+          path.join(appData, "Claude", "claude_desktop_config.json"),
+          path.join(userProfile, ".cursor", "mcp.json"),
+          path.join(userProfile, ".cursor", "settings.json"),
+          path.join(userProfile, ".codeium", "windsurf", "mcp_config.json"),
+          path.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+          path.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json"),
+          path.join(userProfile, ".continue", "config.json"),
+          path.join(userProfile, ".kiro", "settings", "mcp.json"),
+          path.join(appData, "Zed", "settings.json")
+        ],
+        toml: [path.join(userProfile, ".codex", "config.toml")],
+        yaml: [path.join(appData, "Aider", "config.yml")]
+      };
+    case "darwin":
+      return {
+        json: [
+          path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+          path.join(home, ".cursor", "mcp.json"),
+          path.join(home, ".cursor", "settings.json"),
+          path.join(home, ".codeium", "windsurf", "mcp_config.json"),
+          path.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+          path.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json"),
+          path.join(home, ".continue", "config.json"),
+          path.join(home, ".kiro", "settings", "mcp.json"),
+          path.join(home, ".config", "zed", "settings.json")
+        ],
+        toml: [path.join(home, ".codex", "config.toml")],
+        yaml: [path.join(home, ".config", "aider", "config.yml"), path.join(home, ".aider.conf.yml")]
+      };
+    default:
+      return {
+        json: [
+          path.join(home, ".config", "Claude", "claude_desktop_config.json"),
+          path.join(home, ".cursor", "mcp.json"),
+          path.join(home, ".cursor", "settings.json"),
+          path.join(home, ".codeium", "windsurf", "mcp_config.json"),
+          path.join(home, ".config", "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"),
+          path.join(home, ".config", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "mcp_settings.json"),
+          path.join(home, ".continue", "config.json"),
+          path.join(home, ".kiro", "settings", "mcp.json"),
+          path.join(home, ".config", "zed", "settings.json")
+        ],
+        toml: [path.join(home, ".codex", "config.toml")],
+        yaml: [path.join(home, ".config", "aider", "config.yml"), path.join(home, ".aider.conf.yml")]
+      };
+  }
+}
+
+function readJson(pathname) {
+  try {
+    if (!fs.existsSync(pathname)) return { value: {}, exists: false };
+    const raw = fs.readFileSync(pathname, "utf8");
+    if (!raw.trim()) return { value: {}, exists: true };
+    return { value: JSON.parse(raw), exists: true };
+  } catch {
+    return { value: {}, exists: true };
+  }
+}
+
+function writeJson(pathname, value) {
+  fs.mkdirSync(path.dirname(pathname), { recursive: true });
+  fs.writeFileSync(pathname, JSON.stringify(value, null, 2) + "\n");
+}
+
+function removeMcpServerJson(pathname, name = "docdex") {
+  const { value, exists } = readJson(pathname);
+  if (!exists || typeof value !== "object" || value == null || Array.isArray(value)) return false;
+  const root = value;
+  const keys = ["mcpServers", "mcp_servers"];
+  let changed = false;
+  for (const key of keys) {
+    const section = root[key];
+    if (!section || typeof section !== "object" || Array.isArray(section)) continue;
+    if (!Object.prototype.hasOwnProperty.call(section, name)) continue;
+    delete section[name];
+    changed = true;
+    if (Object.keys(section).length === 0) delete root[key];
+  }
+  if (!changed) return false;
+  writeJson(pathname, root);
+  return true;
+}
+
+function removeCodexConfig(pathname, name = "docdex") {
+  if (!fs.existsSync(pathname)) return false;
+  let contents = fs.readFileSync(pathname, "utf8");
+  const original = contents;
+
+  const parseTomlString = (value) => {
+    const trimmed = value.trim();
+    const quoted = trimmed.match(/^"(.*)"$/) || trimmed.match(/^'(.*)'$/);
+    return quoted ? quoted[1] : trimmed;
+  };
+
+  const removeArrayBlocks = (text) => {
+    const lines = text.split(/\r?\n/);
+    const output = [];
+    let inBlock = false;
+    let block = [];
+    let blockHasName = false;
+
+    const flush = () => {
+      if (!inBlock) return;
+      if (!blockHasName) output.push(...block);
+      inBlock = false;
+      block = [];
+      blockHasName = false;
+    };
+
+    for (const line of lines) {
+      if (/^\s*\[\[mcp_servers\]\]\s*$/.test(line)) {
+        flush();
+        inBlock = true;
+        block = [line];
+        continue;
+      }
+      if (inBlock) {
+        if (/^\s*\[.+\]\s*$/.test(line)) {
+          flush();
+          output.push(line);
+          continue;
+        }
+        const match = line.match(/^\s*name\s*=\s*(.+?)\s*$/);
+        if (match && parseTomlString(match[1]) === name) {
+          blockHasName = true;
+        }
+        block.push(line);
+        continue;
+      }
+      output.push(line);
+    }
+    flush();
+    return output.join("\n");
+  };
+
+  const removeNestedSection = (text) => {
+    const lines = text.split(/\r?\n/);
+    const output = [];
+    let skip = false;
+    for (const line of lines) {
+      if (/^\s*\[mcp_servers\.docdex\]\s*$/.test(line)) {
+        skip = true;
+        continue;
+      }
+      if (skip) {
+        if (/^\s*\[.+\]\s*$/.test(line)) {
+          skip = false;
+          output.push(line);
+        }
+        continue;
+      }
+      output.push(line);
+    }
+    return output.join("\n");
+  };
+
+  const removeTableEntry = (text) => {
+    const lines = text.split(/\r?\n/);
+    const output = [];
+    let inTable = false;
+    for (const line of lines) {
+      const section = line.match(/^\s*\[([^\]]+)\]\s*$/);
+      if (section) {
+        inTable = section[1].trim() === "mcp_servers";
+        output.push(line);
+        continue;
+      }
+      if (inTable && new RegExp(`^\\s*${name}\\s*=`).test(line)) {
+        continue;
+      }
+      output.push(line);
+    }
+    return output.join("\n");
+  };
+
+  contents = removeArrayBlocks(contents);
+  contents = removeNestedSection(contents);
+  contents = removeTableEntry(contents);
+
+  if (contents !== original) {
+    fs.writeFileSync(pathname, contents.endsWith("\n") ? contents : `${contents}\n`);
+    return true;
+  }
+  return false;
+}
+
+function removeMcpServerYaml(pathname, name = "docdex") {
+  if (!fs.existsSync(pathname)) return false;
+  const original = fs.readFileSync(pathname, "utf8");
+  const lines = original.split(/\r?\n/);
+  const output = [];
+  let inSection = false;
+  let sectionIndent = null;
+  let skipIndent = null;
+  let changed = false;
+
+  const indentSize = (line) => (line.match(/^\s*/)?.[0].length ?? 0);
+
+  for (const line of lines) {
+    if (skipIndent != null) {
+      if (line.trim() && indentSize(line) <= skipIndent) {
+        skipIndent = null;
+      } else {
+        changed = true;
+        continue;
+      }
+    }
+
+    if (!inSection) {
+      if (/^\s*mcp_servers\s*:\s*$/.test(line)) {
+        inSection = true;
+        sectionIndent = indentSize(line);
+      }
+      output.push(line);
+      continue;
+    }
+
+    if (line.trim() && indentSize(line) <= sectionIndent) {
+      inSection = false;
+      output.push(line);
+      continue;
+    }
+
+    if (new RegExp(`^\\s*${name}\\s*:`).test(line)) {
+      changed = true;
+      skipIndent = indentSize(line);
+      continue;
+    }
+
+    const listName = line.match(/^\s*-\s*name\s*:\s*(.+)\s*$/);
+    if (listName && listName[1].replace(/["']/g, "").trim() === name) {
+      changed = true;
+      skipIndent = indentSize(line);
+      continue;
+    }
+
+    const listValue = line.match(/^\s*-\s*([^\s#]+)\s*$/);
+    if (listValue && listValue[1].replace(/["']/g, "").trim() === name) {
+      changed = true;
+      continue;
+    }
+
+    output.push(line);
+  }
+
+  if (changed) {
+    fs.writeFileSync(pathname, output.join("\n"));
+  }
+  return changed;
+}
+
+function killPid(pid) {
+  if (!pid) return false;
+  try {
+    if (process.platform === "win32") {
+      spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"]);
+      return true;
+    }
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stopDaemonFromLock() {
+  const lockPath = daemonLockPath();
+  if (!fs.existsSync(lockPath)) return false;
+  try {
+    const raw = fs.readFileSync(lockPath, "utf8");
+    const payload = JSON.parse(raw);
+    const pid = payload && typeof payload.pid === "number" ? payload.pid : null;
+    const stopped = killPid(pid);
+    fs.unlinkSync(lockPath);
+    return stopped;
+  } catch {
+    return false;
+  }
+}
+
+function stopDaemonByName() {
+  if (process.platform === "win32") {
+    spawnSync("taskkill", ["/IM", "docdexd.exe", "/T", "/F"]);
+    return true;
+  }
+  spawnSync("pkill", ["-TERM", "-x", "docdexd"]);
+  spawnSync("pkill", ["-TERM", "-f", "docdexd daemon"]);
+  return true;
+}
+
+function unregisterStartup() {
+  if (process.platform === "darwin") {
+    const plistPath = path.join(os.homedir(), "Library", "LaunchAgents", "com.docdex.daemon.plist");
+    if (fs.existsSync(plistPath)) {
+      const uid = typeof process.getuid === "function" ? process.getuid() : null;
+      if (uid != null) {
+        spawnSync("launchctl", ["bootout", `gui/${uid}`, plistPath]);
+      }
+      spawnSync("launchctl", ["unload", "-w", plistPath]);
+      spawnSync("launchctl", ["remove", "com.docdex.daemon"]);
+      try {
+        fs.unlinkSync(plistPath);
+      } catch {}
+    }
+    return true;
+  }
+
+  if (process.platform === "linux") {
+    const systemdDir = path.join(os.homedir(), ".config", "systemd", "user");
+    const unitPath = path.join(systemdDir, "docdexd.service");
+    spawnSync("systemctl", ["--user", "disable", "--now", "docdexd.service"]);
+    if (fs.existsSync(unitPath)) {
+      try {
+        fs.unlinkSync(unitPath);
+      } catch {}
+      spawnSync("systemctl", ["--user", "daemon-reload"]);
+    }
+    return true;
+  }
+
+  if (process.platform === "win32") {
+    spawnSync("schtasks", ["/End", "/TN", DAEMON_TASK_NAME]);
+    spawnSync("schtasks", ["/Delete", "/TN", DAEMON_TASK_NAME, "/F"]);
+    return true;
+  }
+
+  return false;
+}
+
+function clearStartupFailure() {
+  const markerPath = path.join(stateDir(), STARTUP_FAILURE_MARKER);
+  if (fs.existsSync(markerPath)) {
+    try {
+      fs.unlinkSync(markerPath);
+    } catch {}
+  }
+}
+
+function removeDaemonRootNotice() {
+  const root = daemonRootPath();
+  const readmes = [path.join(root, "README.txt"), path.join(root, "README.md")];
+  for (const readme of readmes) {
+    if (fs.existsSync(readme)) {
+      try {
+        fs.unlinkSync(readme);
+      } catch {}
+    }
+  }
+}
+
+function removeClientConfigs() {
+  const paths = clientConfigPaths();
+  for (const pathname of paths.json || []) {
+    removeMcpServerJson(pathname);
+  }
+  for (const pathname of paths.toml || []) {
+    removeCodexConfig(pathname);
+  }
+  for (const pathname of paths.yaml || []) {
+    removeMcpServerYaml(pathname);
+  }
+}
+
+async function main() {
+  const stopped = stopDaemonFromLock();
+  if (!stopped) {
+    stopDaemonByName();
+  }
+  unregisterStartup();
+  removeClientConfigs();
+  clearStartupFailure();
+  removeDaemonRootNotice();
+}
+
+if (require.main === module) {
+  main().catch(() => process.exit(0));
+}
+
+module.exports = {
+  removeMcpServerJson,
+  removeCodexConfig,
+  removeMcpServerYaml,
+  stopDaemonFromLock,
+  stopDaemonByName,
+  unregisterStartup,
+  removeClientConfigs
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docdex",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Docdex CLI as an npm-installable binary wrapper.",
   "bin": {
     "docdex": "bin/docdex.js",
@@ -15,6 +15,7 @@
   ],
   "scripts": {
     "postinstall": "node ./lib/install.js",
+    "postuninstall": "node ./lib/uninstall.js",
     "test": "node --test",
     "pack:verify": "node --test test/packaging_guardrails.test.js"
   },