@proxysoul/soulforge 2.13.2 → 2.14.1

package/dist/workers/intelligence.worker.js

@@ -109,6 +109,9 @@ function createWorkerHandler(handlers, onInit, onDispose) {
   const allHandlers = {
     ...handlers,
     __memoryUsage: () => {
+      try {
+        Bun.gc(true);
+      } catch {}
       const usage = process.memoryUsage();
       return {
         heapUsed: usage.heapUsed,
@@ -26068,6 +26071,8 @@ class RepoMap {
     const language = INDEXABLE_EXTENSIONS[ext];
     if (!language)
       return;
+    if (language === "unknown")
+      return;
     this.pendingReindex.set(absPath, {
       relPath,
       language
@@ -28291,321 +28296,6 @@ var init_protocol = __esm(() => {
   FILE_URI_SAFE_RE = /[^A-Za-z0-9\-._~!$&'()*+,;=:@]/g;
 });
 
-// src/config/index.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join8 } from "path";
-function loadConfig() {
-  if (!existsSync6(CONFIG_DIR)) {
-    mkdirSync2(CONFIG_DIR, {
-      recursive: true,
-      mode: 448
-    });
-  }
-  if (!existsSync6(CONFIG_FILE)) {
-    writeFileSync3(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
-    return DEFAULT_CONFIG;
-  }
-  try {
-    const raw2 = readFileSync4(CONFIG_FILE, "utf-8");
-    return {
-      ...DEFAULT_CONFIG,
-      ...JSON.parse(raw2)
-    };
-  } catch (err2) {
-    process.stderr.write(`[soulforge] Failed to parse ${CONFIG_FILE}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 using defaults
-`);
-    return DEFAULT_CONFIG;
-  }
-}
-function loadProjectConfig(cwd) {
-  const projectFile = join8(cwd, ".soulforge", "config.json");
-  if (!existsSync6(projectFile))
-    return null;
-  try {
-    const raw2 = readFileSync4(projectFile, "utf-8");
-    return JSON.parse(raw2);
-  } catch (err2) {
-    process.stderr.write(`[soulforge] Failed to parse ${projectFile}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 ignoring project config
-`);
-    return null;
-  }
-}
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_CONFIG;
-var init_config = __esm(() => {
-  init_ensure_soulforge_dir();
-  CONFIG_DIR = join8(homedir4(), ".soulforge");
-  CONFIG_FILE = join8(CONFIG_DIR, "config.json");
-  DEFAULT_CONFIG = {
-    defaultModel: "none",
-    routerRules: [],
-    editor: {
-      command: "nvim",
-      args: []
-    },
-    theme: {
-      name: "dark",
-      transparent: true
-    },
-    nvimConfig: "default",
-    editorIntegration: {
-      diagnostics: true,
-      symbols: true,
-      hover: true,
-      references: true,
-      definition: true,
-      codeActions: true,
-      editorContext: true,
-      rename: true,
-      lspStatus: true,
-      format: true,
-      syncEditorOnEdit: false
-    },
-    codeExecution: true,
-    webSearch: true,
-    compaction: {
-      strategy: "v2",
-      triggerThreshold: 0.7,
-      resetThreshold: 0.4,
-      keepRecent: 4,
-      maxToolResults: 30,
-      llmExtraction: true
-    }
-  };
-});
-
-// src/core/intelligence/backends/lsp/server-registry.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join9 } from "path";
-function commandExists(cmd) {
-  try {
-    execSync3(`command -v ${cmd}`, {
-      stdio: "ignore"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function commandExistsInMason(cmd) {
-  const fullPath = join9(MASON_BIN_DIR, cmd);
-  return existsSync7(fullPath) ? fullPath : null;
-}
-function findInSoulforge(cmd) {
-  const npmBin = join9(SOULFORGE_BIN_DIR, "node_modules", ".bin", cmd);
-  if (existsSync7(npmBin))
-    return npmBin;
-  const directBin = join9(SOULFORGE_BIN_DIR, "bin", cmd);
-  if (existsSync7(directBin))
-    return directBin;
-  return null;
-}
-function resolveCommand(cmd) {
-  const cached = probeCache.get(cmd);
-  if (cached !== undefined)
-    return cached;
-  if (commandExists(cmd)) {
-    probeCache.set(cmd, cmd);
-    return cmd;
-  }
-  const sfPath = findInSoulforge(cmd);
-  if (sfPath) {
-    probeCache.set(cmd, sfPath);
-    return sfPath;
-  }
-  const masonPath = commandExistsInMason(cmd);
-  if (masonPath) {
-    probeCache.set(cmd, masonPath);
-    return masonPath;
-  }
-  probeCache.set(cmd, null);
-  return null;
-}
-function isServerDisabled(cmd) {
-  const cwd = process.cwd();
-  const global2 = loadConfig();
-  const project = loadProjectConfig(cwd);
-  const disabled = project?.disabledLspServers ?? global2.disabledLspServers ?? [];
-  return disabled.includes(cmd);
-}
-function findServersForLanguage(language) {
-  const candidates = SERVER_CANDIDATES[language];
-  if (!candidates)
-    return [];
-  const results = [];
-  for (const candidate of candidates) {
-    if (isServerDisabled(candidate.command))
-      continue;
-    const resolved = resolveCommand(candidate.command);
-    if (resolved) {
-      results.push({
-        command: resolved,
-        args: candidate.args,
-        language
-      });
-    }
-  }
-  return results;
-}
-var SERVER_CANDIDATES, MASON_BIN_DIR, SOULFORGE_BIN_DIR, probeCache;
-var init_server_registry = __esm(() => {
-  init_config();
-  SERVER_CANDIDATES = {
-    typescript: [{
-      command: "typescript-language-server",
-      args: ["--stdio"]
-    }, {
-      command: "biome",
-      args: ["lsp-proxy"]
-    }, {
-      command: "deno",
-      args: ["lsp"]
-    }, {
-      command: "vscode-eslint-language-server",
-      args: ["--stdio"]
-    }],
-    javascript: [{
-      command: "typescript-language-server",
-      args: ["--stdio"]
-    }, {
-      command: "biome",
-      args: ["lsp-proxy"]
-    }, {
-      command: "deno",
-      args: ["lsp"]
-    }, {
-      command: "vscode-eslint-language-server",
-      args: ["--stdio"]
-    }],
-    python: [{
-      command: "pyright-langserver",
-      args: ["--stdio"]
-    }, {
-      command: "pylsp",
-      args: []
-    }],
-    go: [{
-      command: "gopls",
-      args: ["serve"]
-    }],
-    rust: [{
-      command: "rust-analyzer",
-      args: []
-    }],
-    lua: [{
-      command: "lua-language-server",
-      args: []
-    }],
-    c: [{
-      command: "clangd",
-      args: []
-    }],
-    cpp: [{
-      command: "clangd",
-      args: []
-    }],
-    ruby: [{
-      command: "solargraph",
-      args: ["stdio"]
-    }],
-    php: [{
-      command: "intelephense",
-      args: ["--stdio"]
-    }],
-    zig: [{
-      command: "zls",
-      args: []
-    }],
-    bash: [{
-      command: "bash-language-server",
-      args: ["start"]
-    }],
-    css: [{
-      command: "vscode-css-language-server",
-      args: ["--stdio"]
-    }, {
-      command: "biome",
-      args: ["lsp-proxy"]
-    }, {
-      command: "tailwindcss-language-server",
-      args: ["--stdio"]
-    }],
-    html: [{
-      command: "vscode-html-language-server",
-      args: ["--stdio"]
-    }, {
-      command: "emmet-language-server",
-      args: ["--stdio"]
-    }],
-    json: [{
-      command: "vscode-json-language-server",
-      args: ["--stdio"]
-    }, {
-      command: "biome",
-      args: ["lsp-proxy"]
-    }],
-    yaml: [{
-      command: "yaml-language-server",
-      args: ["--stdio"]
-    }],
-    toml: [{
-      command: "taplo",
-      args: ["lsp", "stdio"]
-    }],
-    dockerfile: [{
-      command: "docker-langserver",
-      args: ["--stdio"]
-    }],
-    java: [{
-      command: "jdtls",
-      args: []
-    }],
-    kotlin: [{
-      command: "kotlin-language-server",
-      args: []
-    }],
-    scala: [{
-      command: "metals",
-      args: []
-    }],
-    csharp: [{
-      command: "csharp-ls",
-      args: []
-    }, {
-      command: "OmniSharp",
-      args: ["--languageserver"]
-    }],
-    swift: [{
-      command: "sourcekit-lsp",
-      args: []
-    }],
-    dart: [{
-      command: "dart",
-      args: ["language-server", "--protocol=lsp"]
-    }],
-    elixir: [{
-      command: "elixir-ls",
-      args: []
-    }, {
-      command: "expert",
-      args: []
-    }],
-    ocaml: [{
-      command: "ocamllsp",
-      args: []
-    }],
-    vue: [{
-      command: "vue-language-server",
-      args: ["--stdio"]
-    }]
-  };
-  MASON_BIN_DIR = join9(homedir5(), ".local", "share", "soulforge", "mason", "bin");
-  SOULFORGE_BIN_DIR = join9(homedir5(), ".soulforge", "lsp-servers");
-  probeCache = new Map;
-});
-
 // node_modules/zustand/esm/vanilla.mjs
 var createStoreImpl = (createState) => {
   let state;
@@ -29540,6 +29230,320 @@ var init_errors = __esm(() => {
   })));
 });
 
+// src/config/index.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
+function loadConfig() {
+  if (!existsSync6(CONFIG_DIR)) {
+    mkdirSync2(CONFIG_DIR, {
+      recursive: true,
+      mode: 448
+    });
+  }
+  if (!existsSync6(CONFIG_FILE)) {
+    writeFileSync3(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const raw2 = readFileSync4(CONFIG_FILE, "utf-8");
+    return {
+      ...DEFAULT_CONFIG,
+      ...JSON.parse(raw2)
+    };
+  } catch (err2) {
+    logBackgroundError("config", `Failed to parse ${CONFIG_FILE}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 using defaults`);
+    return DEFAULT_CONFIG;
+  }
+}
+function loadProjectConfig(cwd) {
+  const projectFile = join8(cwd, ".soulforge", "config.json");
+  if (!existsSync6(projectFile))
+    return null;
+  try {
+    const raw2 = readFileSync4(projectFile, "utf-8");
+    return JSON.parse(raw2);
+  } catch (err2) {
+    logBackgroundError("config", `Failed to parse ${projectFile}: ${err2 instanceof Error ? err2.message : String(err2)} \u2014 ignoring project config`);
+    return null;
+  }
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_CONFIG;
+var init_config = __esm(() => {
+  init_ensure_soulforge_dir();
+  init_errors();
+  CONFIG_DIR = join8(homedir4(), ".soulforge");
+  CONFIG_FILE = join8(CONFIG_DIR, "config.json");
+  DEFAULT_CONFIG = {
+    defaultModel: "none",
+    routerRules: [],
+    editor: {
+      command: "nvim",
+      args: []
+    },
+    theme: {
+      name: "dark",
+      transparent: true
+    },
+    nvimConfig: "default",
+    editorIntegration: {
+      diagnostics: true,
+      symbols: true,
+      hover: true,
+      references: true,
+      definition: true,
+      codeActions: true,
+      editorContext: true,
+      rename: true,
+      lspStatus: true,
+      format: true,
+      syncEditorOnEdit: false
+    },
+    codeExecution: true,
+    webSearch: true,
+    compaction: {
+      strategy: "v2",
+      triggerThreshold: 0.7,
+      resetThreshold: 0.4,
+      keepRecent: 4,
+      maxToolResults: 30,
+      llmExtraction: true
+    }
+  };
+});
+
+// src/core/intelligence/backends/lsp/server-registry.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join9 } from "path";
+function commandExists(cmd) {
+  try {
+    execSync3(`command -v ${cmd}`, {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function commandExistsInMason(cmd) {
+  const fullPath = join9(MASON_BIN_DIR, cmd);
+  return existsSync7(fullPath) ? fullPath : null;
+}
+function findInSoulforge(cmd) {
+  const npmBin = join9(SOULFORGE_BIN_DIR, "node_modules", ".bin", cmd);
+  if (existsSync7(npmBin))
+    return npmBin;
+  const directBin = join9(SOULFORGE_BIN_DIR, "bin", cmd);
+  if (existsSync7(directBin))
+    return directBin;
+  return null;
+}
+function resolveCommand(cmd) {
+  const cached = probeCache.get(cmd);
+  if (cached !== undefined)
+    return cached;
+  if (commandExists(cmd)) {
+    probeCache.set(cmd, cmd);
+    return cmd;
+  }
+  const sfPath = findInSoulforge(cmd);
+  if (sfPath) {
+    probeCache.set(cmd, sfPath);
+    return sfPath;
+  }
+  const masonPath = commandExistsInMason(cmd);
+  if (masonPath) {
+    probeCache.set(cmd, masonPath);
+    return masonPath;
+  }
+  probeCache.set(cmd, null);
+  return null;
+}
+function isServerDisabled(cmd) {
+  const cwd = process.cwd();
+  const global2 = loadConfig();
+  const project = loadProjectConfig(cwd);
+  const disabled = project?.disabledLspServers ?? global2.disabledLspServers ?? [];
+  return disabled.includes(cmd);
+}
+function findServersForLanguage(language) {
+  const candidates = SERVER_CANDIDATES[language];
+  if (!candidates)
+    return [];
+  const results = [];
+  for (const candidate of candidates) {
+    if (isServerDisabled(candidate.command))
+      continue;
+    const resolved = resolveCommand(candidate.command);
+    if (resolved) {
+      results.push({
+        command: resolved,
+        args: candidate.args,
+        language
+      });
+    }
+  }
+  return results;
+}
+var SERVER_CANDIDATES, MASON_BIN_DIR, SOULFORGE_BIN_DIR, probeCache;
+var init_server_registry = __esm(() => {
+  init_config();
+  SERVER_CANDIDATES = {
+    typescript: [{
+      command: "typescript-language-server",
+      args: ["--stdio"]
+    }, {
+      command: "biome",
+      args: ["lsp-proxy"]
+    }, {
+      command: "deno",
+      args: ["lsp"]
+    }, {
+      command: "vscode-eslint-language-server",
+      args: ["--stdio"]
+    }],
+    javascript: [{
+      command: "typescript-language-server",
+      args: ["--stdio"]
+    }, {
+      command: "biome",
+      args: ["lsp-proxy"]
+    }, {
+      command: "deno",
+      args: ["lsp"]
+    }, {
+      command: "vscode-eslint-language-server",
+      args: ["--stdio"]
+    }],
+    python: [{
+      command: "pyright-langserver",
+      args: ["--stdio"]
+    }, {
+      command: "pylsp",
+      args: []
+    }],
+    go: [{
+      command: "gopls",
+      args: ["serve"]
+    }],
+    rust: [{
+      command: "rust-analyzer",
+      args: []
+    }],
+    lua: [{
+      command: "lua-language-server",
+      args: []
+    }],
+    c: [{
+      command: "clangd",
+      args: []
+    }],
+    cpp: [{
+      command: "clangd",
+      args: []
+    }],
+    ruby: [{
+      command: "solargraph",
+      args: ["stdio"]
+    }],
+    php: [{
+      command: "intelephense",
+      args: ["--stdio"]
+    }],
+    zig: [{
+      command: "zls",
+      args: []
+    }],
+    bash: [{
+      command: "bash-language-server",
+      args: ["start"]
+    }],
+    css: [{
+      command: "vscode-css-language-server",
+      args: ["--stdio"]
+    }, {
+      command: "biome",
+      args: ["lsp-proxy"]
+    }, {
+      command: "tailwindcss-language-server",
+      args: ["--stdio"]
+    }],
+    html: [{
+      command: "vscode-html-language-server",
+      args: ["--stdio"]
+    }, {
+      command: "emmet-language-server",
+      args: ["--stdio"]
+    }],
+    json: [{
+      command: "vscode-json-language-server",
+      args: ["--stdio"]
+    }, {
+      command: "biome",
+      args: ["lsp-proxy"]
+    }],
+    yaml: [{
+      command: "yaml-language-server",
+      args: ["--stdio"]
+    }],
+    toml: [{
+      command: "taplo",
+      args: ["lsp", "stdio"]
+    }],
+    dockerfile: [{
+      command: "docker-langserver",
+      args: ["--stdio"]
+    }],
+    java: [{
+      command: "jdtls",
+      args: []
+    }],
+    kotlin: [{
+      command: "kotlin-language-server",
+      args: []
+    }],
+    scala: [{
+      command: "metals",
+      args: []
+    }],
+    csharp: [{
+      command: "csharp-ls",
+      args: []
+    }, {
+      command: "OmniSharp",
+      args: ["--languageserver"]
+    }],
+    swift: [{
+      command: "sourcekit-lsp",
+      args: []
+    }],
+    dart: [{
+      command: "dart",
+      args: ["language-server", "--protocol=lsp"]
+    }],
+    elixir: [{
+      command: "elixir-ls",
+      args: []
+    }, {
+      command: "expert",
+      args: []
+    }],
+    ocaml: [{
+      command: "ocamllsp",
+      args: []
+    }],
+    vue: [{
+      command: "vue-language-server",
+      args: ["--stdio"]
+    }]
+  };
+  MASON_BIN_DIR = join9(homedir5(), ".local", "share", "soulforge", "mason", "bin");
+  SOULFORGE_BIN_DIR = join9(homedir5(), ".soulforge", "lsp-servers");
+  probeCache = new Map;
+});
+
 // src/core/process-tracker.ts
 function trackProcess(proc) {
   tracked.add(proc);
@@ -29552,36 +29556,48 @@ var init_process_tracker = __esm(() => {
 });
 
 // src/core/intelligence/backends/lsp/pid-tracker.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir6 } from "os";
+import { appendFileSync as appendFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir6, userInfo } from "os";
 import { join as join10 } from "path";
 function ensureDir() {
-  const dir = join10(homedir6(), ".soulforge");
-  if (!existsSync8(dir))
-    mkdirSync3(dir, {
-      recursive: true
-    });
+  if (!existsSync8(SOULFORGE_DIR)) {
+    try {
+      mkdirSync3(SOULFORGE_DIR, {
+        recursive: true
+      });
+    } catch {}
+  }
 }
-function flush() {
+function trackLspPid(pid) {
+  activePids.add(pid);
   try {
     ensureDir();
-    const tmp = `${PID_FILE}.${String(process.pid)}.tmp`;
-    writeFileSync4(tmp, JSON.stringify([...activePids]), "utf-8");
-    renameSync(tmp, PID_FILE);
+    appendFileSync2(PID_LOG, `+${String(pid)}
+`, "utf-8");
   } catch {}
 }
-function trackLspPid(pid) {
-  activePids.add(pid);
-  flush();
-}
 function untrackLspPid(pid) {
   activePids.delete(pid);
-  flush();
+  try {
+    appendFileSync2(PID_LOG, `-${String(pid)}
+`, "utf-8");
+  } catch {}
 }
-var PID_FILE, activePids;
+var SOULFORGE_DIR, PID_LOG, activePids, SOULFORGE_PATH_MARKERS;
 var init_pid_tracker = __esm(() => {
-  PID_FILE = join10(homedir6(), ".soulforge", "lsp-pids.json");
+  SOULFORGE_DIR = join10(homedir6(), ".soulforge");
+  PID_LOG = join10(SOULFORGE_DIR, "lsp-pids.log");
   activePids = new Set;
+  SOULFORGE_PATH_MARKERS = [
+    join10(homedir6(), ".local", "share", "soulforge", "mason"),
+    join10(homedir6(), ".soulforge", "lsp-servers"),
+    join10(homedir6(), ".soulforge", "bin"),
+    "node_modules/.bin/biome",
+    "node_modules/@biomejs/",
+    "node_modules/.bin/typescript-language-server",
+    "node_modules/typescript/lib/tsserver",
+    "node_modules/.bin/vtsls"
+  ];
 });
 
 // src/core/intelligence/backends/lsp/standalone-client.ts
@@ -29806,6 +29822,13 @@ class StandaloneLspClient {
       if (!oldest)
         break;
       this.openDocuments.delete(oldest);
+      this.diagnostics.delete(oldest);
+      const waiters = this.diagnosticWaiters.get(oldest);
+      if (waiters) {
+        for (const w3 of waiters)
+          w3();
+        this.diagnosticWaiters.delete(oldest);
+      }
       this.notify("textDocument/didClose", {
         textDocument: {
           uri: oldest
@@ -277755,774 +277778,2424 @@ __export(exports_ts_morph, {
   TsMorphBackend: () => TsMorphBackend
 });
 import { resolve as resolve6 } from "path";
+function validTargetsFor(action) {
+  return ACTION_VALID_TARGETS[action];
+}
+function targetsHint(action) {
+  const valid2 = validTargetsFor(action);
+  if (!valid2 || valid2.length === 0)
+    return "";
+  return ` Valid targets for ${action}: ${valid2.map((t) => `"${t}"`).join(", ")}.`;
+}
+function editDistance(a2, b3) {
+  if (a2 === b3)
+    return 0;
+  if (!a2.length)
+    return b3.length;
+  if (!b3.length)
+    return a2.length;
+  const prev = Array.from({
+    length: b3.length + 1
+  }, (_3, j2) => j2);
+  for (let i4 = 1;i4 <= a2.length; i4++) {
+    const curr = [i4];
+    for (let j2 = 1;j2 <= b3.length; j2++) {
+      const cost = a2[i4 - 1] === b3[j2 - 1] ? 0 : 1;
+      const del = (prev[j2] ?? 0) + 1;
+      const ins = (curr[j2 - 1] ?? 0) + 1;
+      const sub = (prev[j2 - 1] ?? 0) + cost;
+      curr.push(Math.min(del, ins, sub));
+    }
+    for (let j2 = 0;j2 <= b3.length; j2++)
+      prev[j2] = curr[j2] ?? 0;
+  }
+  return prev[b3.length] ?? 0;
+}
+function closestSymbolName(needle, listings) {
+  if (!needle || listings.length === 0)
+    return null;
+  const candidates = [];
+  for (const line of listings) {
+    const m3 = /"([^"]+)"/.exec(line);
+    if (m3?.[1])
+      candidates.push(m3[1]);
+  }
+  if (candidates.length === 0)
+    return null;
+  const target = needle.toLowerCase();
+  const threshold = Math.max(2, Math.ceil(needle.length * 0.4));
+  let best = null;
+  for (const c of candidates) {
+    const bare = c.includes(".") ? c.split(".").pop() ?? c : c;
+    const d2 = editDistance(target, bare.toLowerCase());
+    if (d2 <= threshold && (!best || d2 < best.d))
+      best = {
+        name: c,
+        d: d2
+      };
+  }
+  return best?.name ?? null;
+}
 async function getTsMorph() {
   if (!tsMorphModule) {
     tsMorphModule = await Promise.resolve().then(() => __toESM(require_ts_morph(), 1));
   }
   return tsMorphModule;
 }
-
-class TsMorphBackend {
-  name = "ts-morph";
-  tier = 2;
-  project = null;
-  cwd = "";
-  supportsLanguage(language) {
-    return language === "typescript" || language === "javascript";
-  }
-  async initialize(cwd) {
-    this.cwd = cwd;
-  }
-  dispose() {
-    this.project = null;
-  }
-  async findDefinition(file, symbol, line, column) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const node = this.findNode(sourceFile, symbol, line, column);
-    if (!node)
-      return null;
-    const ts = await getTsMorph();
-    if (!ts.Node.isIdentifier(node)) {
-      return null;
+function fuzzyMatchMultilineInText(haystack, needle) {
+  if (!needle.includes(`
+`))
+    return null;
+  const hLines = haystack.split(`
+`);
+  const nLines = needle.split(`
+`);
+  if (nLines.length === 0 || nLines.length > hLines.length)
+    return null;
+  const norm = (s2) => s2.replace(/\r$/, "").replace(/^[\t ]+/, "").trimEnd();
+  const hNorm = hLines.map(norm);
+  const nNorm = nLines.map(norm);
+  const offsets = [0];
+  for (let i4 = 0;i4 < hLines.length; i4++) {
+    offsets.push((offsets[i4] ?? 0) + (hLines[i4] ?? "").length + 1);
+  }
+  let match = null;
+  for (let i4 = 0;i4 <= hLines.length - nLines.length; i4++) {
+    let ok = true;
+    for (let j2 = 0;j2 < nLines.length; j2++) {
+      if (hNorm[i4 + j2] !== nNorm[j2]) {
+        ok = false;
+        break;
+      }
     }
-    const defs = node.getDefinitionNodes();
-    if (defs.length === 0)
+    if (!ok)
+      continue;
+    const start2 = offsets[i4] ?? 0;
+    const endLineIdx = i4 + nLines.length - 1;
+    const end = (offsets[endLineIdx] ?? 0) + (hLines[endLineIdx] ?? "").length;
+    const found = {
+      index: start2,
+      length: end - start2
+    };
+    if (match !== null)
       return null;
-    return defs.map((d2) => ({
-      file: d2.getSourceFile().getFilePath(),
-      line: d2.getStartLineNumber(),
-      column: d2.getStart() - d2.getStartLinePos() + 1
-    }));
+    match = found;
   }
-  async findReferences(file, symbol, line, column) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const node = this.findNode(sourceFile, symbol, line, column);
-    if (!node)
-      return null;
-    const ts = await getTsMorph();
-    if (!ts.Node.isIdentifier(node))
-      return null;
-    const refs = node.findReferencesAsNodes();
-    if (refs.length === 0)
-      return null;
-    return refs.map((r4) => ({
-      file: r4.getSourceFile().getFilePath(),
-      line: r4.getStartLineNumber(),
-      column: r4.getStart() - r4.getStartLinePos() + 1
-    }));
+  return match;
+}
+function stripCommonIndent(s2) {
+  if (!s2.includes(`
+`))
+    return s2;
+  const lines = s2.split(`
+`);
+  let minIndent = Infinity;
+  for (const line of lines) {
+    if (line.trim() === "")
+      continue;
+    const m3 = line.match(/^[\t ]*/);
+    const len = m3 ? m3[0].length : 0;
+    if (len < minIndent)
+      minIndent = len;
+    if (minIndent === 0)
+      break;
   }
-  async findSymbols(file, query) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const symbols = [];
-    const ts = await getTsMorph();
-    for (const fn of sourceFile.getFunctions()) {
-      const name2 = fn.getName();
-      if (!name2)
-        continue;
-      if (query && !name2.toLowerCase().includes(query.toLowerCase()))
-        continue;
-      symbols.push({
-        name: name2,
-        kind: "function",
-        location: {
-          file: resolve6(file),
-          line: fn.getStartLineNumber(),
-          column: 1,
-          endLine: fn.getEndLineNumber()
-        }
-      });
+  if (!Number.isFinite(minIndent) || minIndent === 0)
+    return s2;
+  const indent = minIndent;
+  return lines.map((l3) => l3.length >= indent ? l3.slice(indent) : l3).join(`
+`);
+}
+var ACTION_VALID_TARGETS, tsMorphModule = null, TsMorphBackend;
+var init_ts_morph = __esm(() => {
+  ACTION_VALID_TARGETS = {
+    set_body: ["function", "method", "arrow_function", "constructor"],
+    add_statement: ["function", "method", "arrow_function", "constructor"],
+    insert_statement: ["function", "method", "arrow_function", "constructor"],
+    remove_statement: ["function", "method", "arrow_function", "constructor"],
+    set_return_type: ["function", "method", "arrow_function"],
+    set_async: ["function", "method", "arrow_function"],
+    set_generator: ["function", "method"],
+    add_parameter: ["function", "method", "arrow_function", "constructor"],
+    remove_parameter: ["function", "method", "arrow_function", "constructor"],
+    add_overload: ["function", "method"],
+    set_type: ["variable", "constant", "property", "parameter"],
+    set_initializer: ["variable", "constant", "property"],
+    remove_initializer: ["variable", "constant", "property"],
+    set_declaration_kind: ["variable", "constant"],
+    add_property: ["class", "interface", "property"],
+    remove_property: ["class", "interface"],
+    add_method: ["class", "interface", "method"],
+    remove_method: ["class", "interface"],
+    add_member: ["class", "interface", "enum"],
+    remove_member: ["class", "interface", "enum"],
+    add_constructor: ["class"],
+    add_getter: ["class"],
+    add_setter: ["class"],
+    set_extends: ["class"],
+    remove_extends: ["class"],
+    add_extends: ["interface"],
+    add_implements: ["class"],
+    remove_implements: ["class"],
+    extract_interface: ["class"],
+    set_value: ["enum"],
+    set_const_enum: ["enum"],
+    set_export: ["function", "class", "interface", "type", "enum", "variable", "constant"],
+    set_default_export: ["function", "class", "interface", "variable"],
+    set_abstract: ["class", "method"],
+    set_static: ["property", "method"],
+    set_readonly: ["property"],
+    set_scope: ["property", "method", "constructor"],
+    set_optional: ["property", "parameter", "method"],
+    set_overrides: ["method", "property"],
+    set_ambient: ["function", "class", "interface", "type", "enum", "variable"],
+    add_decorator: ["class", "method", "property"],
+    remove_decorator: ["class", "method", "property"],
+    add_type_parameter: ["function", "class", "interface", "type", "method"],
+    add_jsdoc: ["function", "class", "interface", "type", "enum", "method", "property", "variable"],
+    remove_jsdoc: ["function", "class", "interface", "type", "enum", "method", "property", "variable"],
+    unwrap: ["function", "namespace"]
+  };
+  TsMorphBackend = class TsMorphBackend {
+    name = "ts-morph";
+    tier = 2;
+    project = null;
+    cwd = "";
+    static SOURCE_FILE_CAP = 200;
+    sourceFileLru = new Map;
+    supportsLanguage(language) {
+      return language === "typescript" || language === "javascript";
     }
-    for (const cls of sourceFile.getClasses()) {
-      const name2 = cls.getName();
-      if (!name2)
-        continue;
-      if (query && !name2.toLowerCase().includes(query.toLowerCase()))
-        continue;
-      symbols.push({
-        name: name2,
-        kind: "class",
-        location: {
-          file: resolve6(file),
-          line: cls.getStartLineNumber(),
-          column: 1,
-          endLine: cls.getEndLineNumber()
-        }
-      });
+    async initialize(cwd) {
+      this.cwd = cwd;
     }
-    for (const iface of sourceFile.getInterfaces()) {
-      const name2 = iface.getName();
-      if (query && !name2.toLowerCase().includes(query.toLowerCase()))
-        continue;
-      symbols.push({
-        name: name2,
-        kind: "interface",
-        location: {
-          file: resolve6(file),
-          line: iface.getStartLineNumber(),
-          column: 1,
-          endLine: iface.getEndLineNumber()
-        }
-      });
+    dispose() {
+      this.project = null;
     }
-    for (const ta of sourceFile.getTypeAliases()) {
-      const name2 = ta.getName();
-      if (query && !name2.toLowerCase().includes(query.toLowerCase()))
-        continue;
-      symbols.push({
-        name: name2,
-        kind: "type",
-        location: {
-          file: resolve6(file),
-          line: ta.getStartLineNumber(),
-          column: 1,
-          endLine: ta.getEndLineNumber()
-        }
-      });
+    async findDefinition(file, symbol, line, column) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const node = this.findNode(sourceFile, symbol, line, column);
+      if (!node)
+        return null;
+      const ts = await getTsMorph();
+      if (!ts.Node.isIdentifier(node)) {
+        return null;
+      }
+      const defs = node.getDefinitionNodes();
+      if (defs.length === 0)
+        return null;
+      return defs.map((d2) => ({
+        file: d2.getSourceFile().getFilePath(),
+        line: d2.getStartLineNumber(),
+        column: d2.getStart() - d2.getStartLinePos() + 1
+      }));
     }
-    for (const en of sourceFile.getEnums()) {
-      const name2 = en.getName();
-      if (query && !name2.toLowerCase().includes(query.toLowerCase()))
-        continue;
-      symbols.push({
-        name: name2,
-        kind: "enum",
-        location: {
-          file: resolve6(file),
-          line: en.getStartLineNumber(),
-          column: 1,
-          endLine: en.getEndLineNumber()
-        }
-      });
+    async findReferences(file, symbol, line, column) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const node = this.findNode(sourceFile, symbol, line, column);
+      if (!node)
+        return null;
+      const ts = await getTsMorph();
+      if (!ts.Node.isIdentifier(node))
+        return null;
+      const refs = node.findReferencesAsNodes();
+      if (refs.length === 0)
+        return null;
+      return refs.map((r4) => ({
+        file: r4.getSourceFile().getFilePath(),
+        line: r4.getStartLineNumber(),
+        column: r4.getStart() - r4.getStartLinePos() + 1
+      }));
     }
-    for (const stmt of sourceFile.getVariableStatements()) {
-      for (const decl of stmt.getDeclarations()) {
-        const name2 = decl.getName();
+    async findSymbols(file, query) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const symbols = [];
+      const ts = await getTsMorph();
+      for (const fn of sourceFile.getFunctions()) {
+        const name2 = fn.getName();
+        if (!name2)
+          continue;
         if (query && !name2.toLowerCase().includes(query.toLowerCase()))
           continue;
-        const isConst = stmt.getDeclarationKind() === ts.VariableDeclarationKind.Const;
         symbols.push({
           name: name2,
-          kind: isConst ? "constant" : "variable",
+          kind: "function",
           location: {
             file: resolve6(file),
-            line: decl.getStartLineNumber(),
+            line: fn.getStartLineNumber(),
             column: 1,
-            endLine: decl.getEndLineNumber()
+            endLine: fn.getEndLineNumber()
           }
         });
       }
-    }
-    return symbols;
-  }
-  async findImports(file) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    return sourceFile.getImportDeclarations().map((imp) => {
-      const specifiers = [];
-      const defaultImport = imp.getDefaultImport();
-      if (defaultImport)
-        specifiers.push(defaultImport.getText());
-      for (const named of imp.getNamedImports()) {
-        specifiers.push(named.getName());
-      }
-      const namespaceImport = imp.getNamespaceImport();
-      return {
-        source: imp.getModuleSpecifierValue(),
-        specifiers,
-        isDefault: !!defaultImport,
-        isNamespace: !!namespaceImport,
-        location: {
-          file: resolve6(file),
-          line: imp.getStartLineNumber(),
-          column: 1,
-          endLine: imp.getEndLineNumber()
-        }
-      };
-    });
-  }
-  async findExports(file) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const exports = [];
-    for (const exp of sourceFile.getExportedDeclarations()) {
-      const [name2, decls] = exp;
-      for (const decl of decls) {
-        let kind = "variable";
-        const ts = await getTsMorph();
-        if (ts.Node.isFunctionDeclaration(decl))
-          kind = "function";
-        else if (ts.Node.isClassDeclaration(decl))
-          kind = "class";
-        else if (ts.Node.isInterfaceDeclaration(decl))
-          kind = "interface";
-        else if (ts.Node.isTypeAliasDeclaration(decl))
-          kind = "type";
-        else if (ts.Node.isEnumDeclaration(decl))
-          kind = "enum";
-        exports.push({
+      for (const cls of sourceFile.getClasses()) {
+        const name2 = cls.getName();
+        if (!name2)
+          continue;
+        if (query && !name2.toLowerCase().includes(query.toLowerCase()))
+          continue;
+        symbols.push({
           name: name2,
-          isDefault: name2 === "default",
-          kind,
+          kind: "class",
+          location: {
+            file: resolve6(file),
+            line: cls.getStartLineNumber(),
+            column: 1,
+            endLine: cls.getEndLineNumber()
+          }
+        });
+      }
+      for (const iface of sourceFile.getInterfaces()) {
+        const name2 = iface.getName();
+        if (query && !name2.toLowerCase().includes(query.toLowerCase()))
+          continue;
+        symbols.push({
+          name: name2,
+          kind: "interface",
+          location: {
+            file: resolve6(file),
+            line: iface.getStartLineNumber(),
+            column: 1,
+            endLine: iface.getEndLineNumber()
+          }
+        });
+      }
+      for (const ta of sourceFile.getTypeAliases()) {
+        const name2 = ta.getName();
+        if (query && !name2.toLowerCase().includes(query.toLowerCase()))
+          continue;
+        symbols.push({
+          name: name2,
+          kind: "type",
+          location: {
+            file: resolve6(file),
+            line: ta.getStartLineNumber(),
+            column: 1,
+            endLine: ta.getEndLineNumber()
+          }
+        });
+      }
+      for (const en of sourceFile.getEnums()) {
+        const name2 = en.getName();
+        if (query && !name2.toLowerCase().includes(query.toLowerCase()))
+          continue;
+        symbols.push({
+          name: name2,
+          kind: "enum",
           location: {
             file: resolve6(file),
-            line: decl.getStartLineNumber(),
+            line: en.getStartLineNumber(),
             column: 1,
-            endLine: decl.getEndLineNumber()
+            endLine: en.getEndLineNumber()
           }
         });
       }
+      for (const stmt of sourceFile.getVariableStatements()) {
+        for (const decl of stmt.getDeclarations()) {
+          const name2 = decl.getName();
+          if (query && !name2.toLowerCase().includes(query.toLowerCase()))
+            continue;
+          const isConst = stmt.getDeclarationKind() === ts.VariableDeclarationKind.Const;
+          symbols.push({
+            name: name2,
+            kind: isConst ? "constant" : "variable",
+            location: {
+              file: resolve6(file),
+              line: decl.getStartLineNumber(),
+              column: 1,
+              endLine: decl.getEndLineNumber()
+            }
+          });
+        }
+      }
+      return symbols;
     }
-    return exports;
-  }
-  async getDiagnostics(file) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const project = this.getProject();
-    if (!project)
-      return null;
-    const preDiags = project.getPreEmitDiagnostics().filter((d2) => d2.getSourceFile()?.getFilePath() === sourceFile.getFilePath());
-    const ts = await getTsMorph();
-    return preDiags.map((d2) => {
-      const start2 = d2.getStart();
-      let line = 1;
-      let column = 1;
-      if (start2 !== undefined) {
-        const lineAndCol = sourceFile.getLineAndColumnAtPos(start2);
-        line = lineAndCol.line;
-        column = lineAndCol.column;
-      }
-      const catMap = {
-        [ts.DiagnosticCategory.Error]: "error",
-        [ts.DiagnosticCategory.Warning]: "warning",
-        [ts.DiagnosticCategory.Suggestion]: "hint",
-        [ts.DiagnosticCategory.Message]: "info"
-      };
-      return {
-        file: resolve6(file),
-        line,
-        column,
-        severity: catMap[d2.getCategory()] ?? "error",
-        message: d2.getMessageText().toString(),
-        code: d2.getCode(),
-        source: "typescript"
-      };
-    });
-  }
-  async getTypeInfo(file, symbol, line, column) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const node = this.findNode(sourceFile, symbol, line, column);
-    if (!node)
-      return null;
-    const nodeType = node.getType();
-    return {
-      symbol,
-      type: nodeType.getText(node),
-      documentation: this.getNodeDocumentation(node)
-    };
-  }
-  async getFileOutline(file) {
-    const [symbols, imports, exports] = await Promise.all([this.findSymbols(file), this.findImports(file), this.findExports(file)]);
-    if (!symbols)
-      return null;
-    const language = this.detectLang(file);
-    return {
-      file: resolve6(file),
-      language,
-      symbols,
-      imports: imports ?? [],
-      exports: exports ?? []
-    };
-  }
-  async readSymbol(file, symbolName, symbolKind) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const ts = await getTsMorph();
-    const language = this.detectLang(file);
-    const candidates = [];
-    if (!symbolKind || symbolKind === "function") {
-      candidates.push(...sourceFile.getFunctions().filter((f3) => f3.getName() === symbolName));
+    async findImports(file) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      return sourceFile.getImportDeclarations().map((imp) => {
+        const specifiers = [];
+        const defaultImport = imp.getDefaultImport();
+        if (defaultImport)
+          specifiers.push(defaultImport.getText());
+        for (const named of imp.getNamedImports()) {
+          specifiers.push(named.getName());
+        }
+        const namespaceImport = imp.getNamespaceImport();
+        return {
+          source: imp.getModuleSpecifierValue(),
+          specifiers,
+          isDefault: !!defaultImport,
+          isNamespace: !!namespaceImport,
+          location: {
+            file: resolve6(file),
+            line: imp.getStartLineNumber(),
+            column: 1,
+            endLine: imp.getEndLineNumber()
+          }
+        };
+      });
     }
-    if (!symbolKind || symbolKind === "class") {
-      candidates.push(...sourceFile.getClasses().filter((c) => c.getName() === symbolName));
+    async findExports(file) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const exports = [];
+      for (const exp of sourceFile.getExportedDeclarations()) {
+        const [name2, decls] = exp;
+        for (const decl of decls) {
+          let kind = "variable";
+          const ts = await getTsMorph();
+          if (ts.Node.isFunctionDeclaration(decl))
+            kind = "function";
+          else if (ts.Node.isClassDeclaration(decl))
+            kind = "class";
+          else if (ts.Node.isInterfaceDeclaration(decl))
+            kind = "interface";
+          else if (ts.Node.isTypeAliasDeclaration(decl))
+            kind = "type";
+          else if (ts.Node.isEnumDeclaration(decl))
+            kind = "enum";
+          exports.push({
+            name: name2,
+            isDefault: name2 === "default",
+            kind,
+            location: {
+              file: resolve6(file),
+              line: decl.getStartLineNumber(),
+              column: 1,
+              endLine: decl.getEndLineNumber()
+            }
+          });
+        }
+      }
+      return exports;
     }
-    if (!symbolKind || symbolKind === "interface") {
-      candidates.push(...sourceFile.getInterfaces().filter((i4) => i4.getName() === symbolName));
+    async getDiagnostics(file) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const project = this.getProject();
+      if (!project)
+        return null;
+      const preDiags = project.getPreEmitDiagnostics().filter((d2) => d2.getSourceFile()?.getFilePath() === sourceFile.getFilePath());
+      const ts = await getTsMorph();
+      return preDiags.map((d2) => {
+        const start2 = d2.getStart();
+        let line = 1;
+        let column = 1;
+        if (start2 !== undefined) {
+          const lineAndCol = sourceFile.getLineAndColumnAtPos(start2);
+          line = lineAndCol.line;
+          column = lineAndCol.column;
+        }
+        const catMap = {
+          [ts.DiagnosticCategory.Error]: "error",
+          [ts.DiagnosticCategory.Warning]: "warning",
+          [ts.DiagnosticCategory.Suggestion]: "hint",
+          [ts.DiagnosticCategory.Message]: "info"
+        };
+        return {
+          file: resolve6(file),
+          line,
+          column,
+          severity: catMap[d2.getCategory()] ?? "error",
+          message: d2.getMessageText().toString(),
+          code: d2.getCode(),
+          source: "typescript"
+        };
+      });
     }
-    if (!symbolKind || symbolKind === "type") {
-      candidates.push(...sourceFile.getTypeAliases().filter((t) => t.getName() === symbolName));
+    async getTypeInfo(file, symbol, line, column) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const node = this.findNode(sourceFile, symbol, line, column);
+      if (!node)
+        return null;
+      const nodeType = node.getType();
+      return {
+        symbol,
+        type: nodeType.getText(node),
+        documentation: this.getNodeDocumentation(node)
+      };
     }
-    if (!symbolKind || symbolKind === "enum") {
-      candidates.push(...sourceFile.getEnums().filter((e) => e.getName() === symbolName));
+    async getFileOutline(file) {
+      const [symbols, imports, exports] = await Promise.all([this.findSymbols(file), this.findImports(file), this.findExports(file)]);
+      if (!symbols)
+        return null;
+      const language = this.detectLang(file);
+      return {
+        file: resolve6(file),
+        language,
+        symbols,
+        imports: imports ?? [],
+        exports: exports ?? []
+      };
     }
-    if (!symbolKind || symbolKind === "variable" || symbolKind === "constant") {
-      for (const stmt of sourceFile.getVariableStatements()) {
-        for (const decl of stmt.getDeclarations()) {
-          if (decl.getName() === symbolName) {
-            candidates.push(stmt);
+    async readSymbol(file, symbolName, symbolKind) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const ts = await getTsMorph();
+      const language = this.detectLang(file);
+      const candidates = [];
+      if (!symbolKind || symbolKind === "function") {
+        candidates.push(...sourceFile.getFunctions().filter((f3) => f3.getName() === symbolName));
+      }
+      if (!symbolKind || symbolKind === "class") {
+        candidates.push(...sourceFile.getClasses().filter((c) => c.getName() === symbolName));
+      }
+      if (!symbolKind || symbolKind === "interface") {
+        candidates.push(...sourceFile.getInterfaces().filter((i4) => i4.getName() === symbolName));
+      }
+      if (!symbolKind || symbolKind === "type") {
+        candidates.push(...sourceFile.getTypeAliases().filter((t) => t.getName() === symbolName));
+      }
+      if (!symbolKind || symbolKind === "enum") {
+        candidates.push(...sourceFile.getEnums().filter((e) => e.getName() === symbolName));
+      }
+      if (!symbolKind || symbolKind === "variable" || symbolKind === "constant") {
+        for (const stmt of sourceFile.getVariableStatements()) {
+          for (const decl of stmt.getDeclarations()) {
+            if (decl.getName() === symbolName) {
+              candidates.push(stmt);
+            }
           }
         }
       }
+      const target = candidates[0];
+      if (!target)
+        return null;
+      let kind = "unknown";
+      if (ts.Node.isFunctionDeclaration(target))
+        kind = "function";
+      else if (ts.Node.isClassDeclaration(target))
+        kind = "class";
+      else if (ts.Node.isInterfaceDeclaration(target))
+        kind = "interface";
+      else if (ts.Node.isTypeAliasDeclaration(target))
+        kind = "type";
+      else if (ts.Node.isEnumDeclaration(target))
+        kind = "enum";
+      else if (ts.Node.isVariableStatement(target))
+        kind = "variable";
+      return {
+        content: target.getFullText().trimStart(),
+        location: {
+          file: resolve6(file),
+          line: target.getStartLineNumber(),
+          column: 1,
+          endLine: target.getEndLineNumber()
+        },
+        symbolName,
+        symbolKind: kind,
+        language
+      };
     }
-    const target = candidates[0];
-    if (!target)
-      return null;
-    let kind = "unknown";
-    if (ts.Node.isFunctionDeclaration(target))
-      kind = "function";
-    else if (ts.Node.isClassDeclaration(target))
-      kind = "class";
-    else if (ts.Node.isInterfaceDeclaration(target))
-      kind = "interface";
-    else if (ts.Node.isTypeAliasDeclaration(target))
-      kind = "type";
-    else if (ts.Node.isEnumDeclaration(target))
-      kind = "enum";
-    else if (ts.Node.isVariableStatement(target))
-      kind = "variable";
-    return {
-      content: target.getFullText().trimStart(),
-      location: {
-        file: resolve6(file),
-        line: target.getStartLineNumber(),
-        column: 1,
-        endLine: target.getEndLineNumber()
-      },
-      symbolName,
-      symbolKind: kind,
-      language
-    };
-  }
-  async readScope(file, startLine, endLine) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const language = this.detectLang(file);
-    const fullText = sourceFile.getFullText();
-    const lines = fullText.split(`
+    async readScope(file, startLine, endLine) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const language = this.detectLang(file);
+      const fullText = sourceFile.getFullText();
+      const lines = fullText.split(`
 `);
-    const startIdx = Math.max(0, startLine - 1);
-    const endIdx = endLine ? Math.min(endLine - 1, lines.length - 1) : Math.min(startIdx + 50, lines.length - 1);
-    const blockContent = lines.slice(startIdx, endIdx + 1).join(`
+      const startIdx = Math.max(0, startLine - 1);
+      const endIdx = endLine ? Math.min(endLine - 1, lines.length - 1) : Math.min(startIdx + 50, lines.length - 1);
+      const blockContent = lines.slice(startIdx, endIdx + 1).join(`
 `);
-    return {
-      content: blockContent,
-      location: {
-        file: resolve6(file),
-        line: startLine,
-        column: 1,
-        endLine: endIdx + 1
-      },
-      language
-    };
-  }
-  async rename(file, symbol, newName, line, column) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const node = this.findNode(sourceFile, symbol, line, column);
-    if (!node)
-      return null;
-    const ts = await getTsMorph();
-    if (!ts.Node.isIdentifier(node))
-      return null;
-    const refs = node.findReferencesAsNodes();
-    const affectedFiles = new Set;
-    for (const ref of refs) {
-      affectedFiles.add(ref.getSourceFile().getFilePath());
-    }
-    affectedFiles.add(sourceFile.getFilePath());
-    const beforeContent = new Map;
-    for (const filePath of affectedFiles) {
-      const sf = this.getProject()?.getSourceFile(filePath);
-      if (sf)
-        beforeContent.set(filePath, sf.getFullText());
-    }
-    node.rename(newName);
-    const edits = [];
-    for (const filePath of affectedFiles) {
-      const sf = this.getProject()?.getSourceFile(filePath);
-      const before = beforeContent.get(filePath);
-      if (sf && before) {
-        const after = sf.getFullText();
-        if (before !== after) {
-          edits.push({
-            file: filePath,
-            oldContent: before,
-            newContent: after
-          });
+      return {
+        content: blockContent,
+        location: {
+          file: resolve6(file),
+          line: startLine,
+          column: 1,
+          endLine: endIdx + 1
+        },
+        language
+      };
+    }
+    async rename(file, symbol, newName, line, column) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const node = this.findNode(sourceFile, symbol, line, column);
+      if (!node)
+        return null;
+      const ts = await getTsMorph();
+      if (!ts.Node.isIdentifier(node))
+        return null;
+      const refs = node.findReferencesAsNodes();
+      const affectedFiles = new Set;
+      for (const ref of refs) {
+        affectedFiles.add(ref.getSourceFile().getFilePath());
+      }
+      affectedFiles.add(sourceFile.getFilePath());
+      const beforeContent = new Map;
+      for (const filePath of affectedFiles) {
+        const sf = this.getProject()?.getSourceFile(filePath);
+        if (sf)
+          beforeContent.set(filePath, sf.getFullText());
+      }
+      node.rename(newName);
+      const edits = [];
+      for (const filePath of affectedFiles) {
+        const sf = this.getProject()?.getSourceFile(filePath);
+        const before = beforeContent.get(filePath);
+        if (sf && before) {
+          const after = sf.getFullText();
+          if (before !== after) {
+            edits.push({
+              file: filePath,
+              oldContent: before,
+              newContent: after
+            });
+          }
         }
       }
+      return {
+        edits,
+        description: `Renamed '${symbol}' to '${newName}' in ${String(edits.length)} file(s)`
+      };
     }
-    return {
-      edits,
-      description: `Renamed '${symbol}' to '${newName}' in ${String(edits.length)} file(s)`
-    };
-  }
-  async extractFunction(file, startLine, endLine, functionName) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const ts = await getTsMorph();
-    const fullText = sourceFile.getFullText();
-    const lines = fullText.split(`
+    async extractFunction(file, startLine, endLine, functionName) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const ts = await getTsMorph();
+      const fullText = sourceFile.getFullText();
+      const lines = fullText.split(`
 `);
-    const startIdx = Math.max(0, startLine - 1);
-    const endIdx = Math.min(endLine - 1, lines.length - 1);
-    const extractedLines = lines.slice(startIdx, endIdx + 1);
-    const extractedCode = extractedLines.join(`
+      const startIdx = Math.max(0, startLine - 1);
+      const endIdx = Math.min(endLine - 1, lines.length - 1);
+      const extractedLines = lines.slice(startIdx, endIdx + 1);
+      const extractedCode = extractedLines.join(`
 `);
-    const indent = (extractedLines[0] ?? "").match(/^(\s*)/)?.[1] ?? "";
-    const startPos = sourceFile.compilerNode.getPositionOfLineAndCharacter(startIdx, 0);
-    const endPos = sourceFile.compilerNode.getPositionOfLineAndCharacter(endIdx, (lines[endIdx] ?? "").length);
-    const params = [];
-    const paramNames = new Set;
-    sourceFile.forEachDescendant((node) => {
-      if (!ts.Node.isIdentifier(node))
-        return;
-      const nodeStart = node.getStart();
-      if (nodeStart < startPos || nodeStart > endPos)
-        return;
-      const name2 = node.getText();
-      if (paramNames.has(name2))
-        return;
-      const defs = node.getDefinitionNodes();
-      for (const def of defs) {
-        const defStart = def.getStartLineNumber();
-        if (def.getSourceFile() === sourceFile && (defStart < startLine || defStart > endLine)) {
-          const nodeType = node.getType();
-          const typeText = nodeType.getText(node);
-          params.push(`${name2}: ${typeText}`);
-          paramNames.add(name2);
-          break;
+      const indent = (extractedLines[0] ?? "").match(/^(\s*)/)?.[1] ?? "";
+      const startPos = sourceFile.compilerNode.getPositionOfLineAndCharacter(startIdx, 0);
+      const endPos = sourceFile.compilerNode.getPositionOfLineAndCharacter(endIdx, (lines[endIdx] ?? "").length);
+      const params = [];
+      const paramNames = new Set;
+      sourceFile.forEachDescendant((node) => {
+        if (!ts.Node.isIdentifier(node))
+          return;
+        const nodeStart = node.getStart();
+        if (nodeStart < startPos || nodeStart > endPos)
+          return;
+        const name2 = node.getText();
+        if (paramNames.has(name2))
+          return;
+        const defs = node.getDefinitionNodes();
+        for (const def of defs) {
+          const defStart = def.getStartLineNumber();
+          if (def.getSourceFile() === sourceFile && (defStart < startLine || defStart > endLine)) {
+            const nodeType = node.getType();
+            const typeText = nodeType.getText(node);
+            params.push(`${name2}: ${typeText}`);
+            paramNames.add(name2);
+            break;
+          }
         }
-      }
-    });
-    const lastLine = extractedLines[extractedLines.length - 1]?.trim() ?? "";
-    const hasReturn = lastLine.startsWith("return ");
-    const paramList = params.join(", ");
-    const argList = [...paramNames].join(", ");
-    const newFunc = `
+      });
+      const lastLine = extractedLines[extractedLines.length - 1]?.trim() ?? "";
+      const hasReturn = lastLine.startsWith("return ");
+      const paramList = params.join(", ");
+      const argList = [...paramNames].join(", ");
+      const newFunc = `
 function ${functionName}(${paramList}) {
 ${extractedCode}
 }
 `;
-    const callExpr = hasReturn ? `${indent}return ${functionName}(${argList});` : `${indent}${functionName}(${argList});`;
-    const newLines = [...lines];
-    newLines.splice(startIdx, endIdx - startIdx + 1, callExpr);
-    const newContent = `${newLines.join(`
+      const callExpr = hasReturn ? `${indent}return ${functionName}(${argList});` : `${indent}${functionName}(${argList});`;
+      const newLines = [...lines];
+      newLines.splice(startIdx, endIdx - startIdx + 1, callExpr);
+      const newContent = `${newLines.join(`
 `)}
 ${newFunc}`;
-    return {
-      edits: [{
-        file: resolve6(file),
-        oldContent: fullText,
-        newContent
-      }],
-      description: `Extracted lines ${String(startLine)}-${String(endLine)} into function '${functionName}(${paramList})'`
-    };
-  }
-  async extractVariable(file, startLine, endLine, variableName) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const fullText = sourceFile.getFullText();
-    const lines = fullText.split(`
+      return {
+        edits: [{
+          file: resolve6(file),
+          oldContent: fullText,
+          newContent
+        }],
+        description: `Extracted lines ${String(startLine)}-${String(endLine)} into function '${functionName}(${paramList})'`
+      };
+    }
+    async extractVariable(file, startLine, endLine, variableName) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const fullText = sourceFile.getFullText();
+      const lines = fullText.split(`
 `);
-    const startIdx = Math.max(0, startLine - 1);
-    const endIdx = Math.min(endLine - 1, lines.length - 1);
-    const extractedCode = lines.slice(startIdx, endIdx + 1).join(`
+      const startIdx = Math.max(0, startLine - 1);
+      const endIdx = Math.min(endLine - 1, lines.length - 1);
+      const extractedCode = lines.slice(startIdx, endIdx + 1).join(`
 `).trim();
-    const indent = (lines[startIdx] ?? "").match(/^(\s*)/)?.[1] ?? "";
-    const declaration = `${indent}const ${variableName} = ${extractedCode};`;
-    const replacement = `${indent}${variableName}`;
-    const newLines = [...lines];
-    newLines.splice(startIdx, endIdx - startIdx + 1, declaration, replacement);
-    return {
-      edits: [{
-        file: resolve6(file),
-        oldContent: fullText,
-        newContent: newLines.join(`
-`)
-      }],
-      description: `Extracted lines ${String(startLine)}-${String(endLine)} into variable '${variableName}'`
-    };
-  }
-  async findImplementation(file, symbol, line, column) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const node = this.findNode(sourceFile, symbol, line, column);
-    if (!node)
-      return null;
-    const ts = await getTsMorph();
-    if (!ts.Node.isIdentifier(node))
-      return null;
-    const impls = node.getImplementations();
-    if (impls.length === 0)
-      return null;
-    return impls.map((impl) => {
-      const sf = impl.getSourceFile();
-      const pos = sf.getLineAndColumnAtPos(impl.getTextSpan().getStart());
+      const indent = (lines[startIdx] ?? "").match(/^(\s*)/)?.[1] ?? "";
+      const declaration = `${indent}const ${variableName} = ${extractedCode};`;
+      const replacement = `${indent}${variableName}`;
+      const newLines = [...lines];
+      newLines.splice(startIdx, endIdx - startIdx + 1, declaration, replacement);
       return {
-        file: sf.getFilePath(),
-        line: pos.line,
-        column: pos.column
+        edits: [{
+          file: resolve6(file),
+          oldContent: fullText,
+          newContent: newLines.join(`
+`)
+        }],
+        description: `Extracted lines ${String(startLine)}-${String(endLine)} into variable '${variableName}'`
       };
-    });
-  }
-  async getTypeHierarchy(file, symbol, line, column) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const node = this.findNode(sourceFile, symbol, line, column);
-    if (!node)
-      return null;
-    const ts = await getTsMorph();
-    const parent = ts.Node.isIdentifier(node) ? node.getParent() : node;
-    if (!parent)
-      return null;
-    const item = {
-      name: symbol,
-      kind: "function",
-      file: resolve6(file),
-      line: node.getStartLineNumber()
-    };
-    const supertypes = [];
-    const subtypes = [];
-    if (ts.Node.isClassDeclaration(parent)) {
-      item.kind = "class";
-      const baseClass = parent.getBaseClass();
-      if (baseClass) {
-        supertypes.push({
-          name: baseClass.getName() ?? "anonymous",
-          kind: "class",
-          file: baseClass.getSourceFile().getFilePath(),
-          line: baseClass.getStartLineNumber()
-        });
-      }
-      for (const impl of parent.getImplements()) {
-        const typeNode = impl.getExpression();
-        const defs = ts.Node.isIdentifier(typeNode) ? typeNode.getDefinitionNodes() : [];
-        for (const def of defs) {
+    }
+    async findImplementation(file, symbol, line, column) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const node = this.findNode(sourceFile, symbol, line, column);
+      if (!node)
+        return null;
+      const ts = await getTsMorph();
+      if (!ts.Node.isIdentifier(node))
+        return null;
+      const impls = node.getImplementations();
+      if (impls.length === 0)
+        return null;
+      return impls.map((impl) => {
+        const sf = impl.getSourceFile();
+        const pos = sf.getLineAndColumnAtPos(impl.getTextSpan().getStart());
+        return {
+          file: sf.getFilePath(),
+          line: pos.line,
+          column: pos.column
+        };
+      });
+    }
+    async getTypeHierarchy(file, symbol, line, column) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const node = this.findNode(sourceFile, symbol, line, column);
+      if (!node)
+        return null;
+      const ts = await getTsMorph();
+      const parent = ts.Node.isIdentifier(node) ? node.getParent() : node;
+      if (!parent)
+        return null;
+      const item = {
+        name: symbol,
+        kind: "function",
+        file: resolve6(file),
+        line: node.getStartLineNumber()
+      };
+      const supertypes = [];
+      const subtypes = [];
+      if (ts.Node.isClassDeclaration(parent)) {
+        item.kind = "class";
+        const baseClass = parent.getBaseClass();
+        if (baseClass) {
           supertypes.push({
-            name: typeNode.getText(),
-            kind: "interface",
-            file: def.getSourceFile().getFilePath(),
-            line: def.getStartLineNumber()
+            name: baseClass.getName() ?? "anonymous",
+            kind: "class",
+            file: baseClass.getSourceFile().getFilePath(),
+            line: baseClass.getStartLineNumber()
           });
         }
+        for (const impl of parent.getImplements()) {
+          const typeNode = impl.getExpression();
+          const defs = ts.Node.isIdentifier(typeNode) ? typeNode.getDefinitionNodes() : [];
+          for (const def of defs) {
+            supertypes.push({
+              name: typeNode.getText(),
+              kind: "interface",
+              file: def.getSourceFile().getFilePath(),
+              line: def.getStartLineNumber()
+            });
+          }
+        }
+        const refs = parent.getNameNode()?.findReferencesAsNodes() ?? [];
+        for (const ref of refs) {
+          const refParent = ref.getParent();
+          if (refParent && ts.Node.isHeritageClause(refParent.getParent() ?? refParent)) {
+            const classDecl = refParent.getParent()?.getParent();
+            if (classDecl && ts.Node.isClassDeclaration(classDecl)) {
+              subtypes.push({
+                name: classDecl.getName() ?? "anonymous",
+                kind: "class",
+                file: classDecl.getSourceFile().getFilePath(),
+                line: classDecl.getStartLineNumber()
+              });
+            }
+          }
+        }
+      } else if (ts.Node.isInterfaceDeclaration(parent)) {
+        item.kind = "interface";
+        for (const ext of parent.getExtends()) {
+          const typeNode = ext.getExpression();
+          const defs = ts.Node.isIdentifier(typeNode) ? typeNode.getDefinitionNodes() : [];
+          for (const def of defs) {
+            supertypes.push({
+              name: typeNode.getText(),
+              kind: "interface",
+              file: def.getSourceFile().getFilePath(),
+              line: def.getStartLineNumber()
+            });
+          }
+        }
+        const refs = parent.getNameNode().findReferencesAsNodes();
+        for (const ref of refs) {
+          const refParent = ref.getParent();
+          if (refParent && ts.Node.isHeritageClause(refParent.getParent() ?? refParent)) {
+            const container = refParent.getParent()?.getParent();
+            if (container && ts.Node.isClassDeclaration(container)) {
+              subtypes.push({
+                name: container.getName() ?? "anonymous",
+                kind: "class",
+                file: container.getSourceFile().getFilePath(),
+                line: container.getStartLineNumber()
+              });
+            }
+          }
+        }
+      } else {
+        return null;
       }
-      const refs = parent.getNameNode()?.findReferencesAsNodes() ?? [];
-      for (const ref of refs) {
-        const refParent = ref.getParent();
-        if (refParent && ts.Node.isHeritageClause(refParent.getParent() ?? refParent)) {
-          const classDecl = refParent.getParent()?.getParent();
-          if (classDecl && ts.Node.isClassDeclaration(classDecl)) {
-            subtypes.push({
-              name: classDecl.getName() ?? "anonymous",
-              kind: "class",
-              file: classDecl.getSourceFile().getFilePath(),
-              line: classDecl.getStartLineNumber()
+      return {
+        item,
+        supertypes,
+        subtypes
+      };
+    }
+    async findUnused(file) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return null;
+      const ts = await getTsMorph();
+      const unused = [];
+      for (const imp of sourceFile.getImportDeclarations()) {
+        const defaultImport = imp.getDefaultImport();
+        if (defaultImport) {
+          const refs = defaultImport.findReferencesAsNodes();
+          if (refs.length <= 1) {
+            unused.push({
+              name: defaultImport.getText(),
+              kind: "import",
+              file: resolve6(file),
+              line: imp.getStartLineNumber()
+            });
+          }
+        }
+        for (const named of imp.getNamedImports()) {
+          const nameNode = named.getAliasNode();
+          const effectiveNode = nameNode ?? named.getNameNode();
+          const refs = "findReferencesAsNodes" in effectiveNode ? effectiveNode.findReferencesAsNodes() : [];
+          if (refs.length <= 1) {
+            unused.push({
+              name: named.getName(),
+              kind: "import",
+              file: resolve6(file),
+              line: imp.getStartLineNumber()
             });
           }
         }
       }
-    } else if (ts.Node.isInterfaceDeclaration(parent)) {
-      item.kind = "interface";
-      for (const ext of parent.getExtends()) {
-        const typeNode = ext.getExpression();
-        const defs = ts.Node.isIdentifier(typeNode) ? typeNode.getDefinitionNodes() : [];
-        for (const def of defs) {
-          supertypes.push({
-            name: typeNode.getText(),
-            kind: "interface",
-            file: def.getSourceFile().getFilePath(),
-            line: def.getStartLineNumber()
+      const project = this.getProject();
+      if (project) {
+        for (const [name2, decls] of sourceFile.getExportedDeclarations()) {
+          if (name2 === "default")
+            continue;
+          const decl = decls[0];
+          if (!decl)
+            continue;
+          const nameNode = ts.Node.isIdentifier(decl) ? decl : ("getNameNode" in decl) && typeof decl.getNameNode === "function" ? decl.getNameNode() : null;
+          if (!nameNode || !ts.Node.isIdentifier(nameNode))
+            continue;
+          const refs = nameNode.findReferencesAsNodes();
+          const externalRefs = refs.filter((r4) => r4.getSourceFile() !== sourceFile);
+          if (externalRefs.length === 0) {
+            unused.push({
+              name: name2,
+              kind: "export",
+              file: resolve6(file),
+              line: decl.getStartLineNumber()
+            });
+          }
+        }
+      }
+      return unused.length > 0 ? unused : null;
+    }
+    static SURGICAL_ACTIONS = [
+      "set_type",
+      "set_return_type",
+      "set_value",
+      "set_initializer",
+      "remove_initializer",
+      "set_async",
+      "set_generator",
+      "set_export",
+      "set_default_export",
+      "set_abstract",
+      "set_static",
+      "set_readonly",
+      "set_scope",
+      "set_optional",
+      "set_overrides",
+      "set_ambient",
+      "set_const_enum",
+      "rename",
+      "rename_global",
+      "remove",
+      "add_parameter",
+      "remove_parameter",
+      "set_declaration_kind",
+      "set_body",
+      "add_statement",
+      "insert_statement",
+      "remove_statement",
+      "add_property",
+      "remove_property",
+      "add_method",
+      "remove_method",
+      "add_member",
+      "remove_member",
+      "add_constructor",
+      "add_getter",
+      "add_setter",
+      "add_decorator",
+      "remove_decorator",
+      "add_overload",
+      "set_extends",
+      "remove_extends",
+      "add_implements",
+      "remove_implements",
+      "add_type_parameter",
+      "add_extends",
+      "add_jsdoc",
+      "remove_jsdoc",
+      "unwrap",
+      "set_structure",
+      "extract_interface",
+      "replace",
+      "replace_in_body",
+      "create_file",
+      "add_import",
+      "remove_import",
+      "add_named_import",
+      "remove_named_import",
+      "set_module_specifier",
+      "add_export_declaration",
+      "add_named_reexport",
+      "add_namespace",
+      "organize_imports",
+      "fix_missing_imports",
+      "fix_unused",
+      "add_function",
+      "add_class",
+      "add_interface",
+      "add_type_alias",
+      "add_enum",
+      "add_variable",
+      "insert_text"
+    ];
+    async surgicalEdit(file, operations) {
+      const sourceFile = await this.getSourceFile(file);
+      if (!sourceFile)
+        return {
+          ok: false,
+          error: `Could not parse file: ${file}`
+        };
+      const ts = await getTsMorph();
+      const before = sourceFile.getFullText();
+      const details = [];
+      for (let i4 = 0;i4 < operations.length; i4++) {
+        const op = operations[i4];
+        const label = operations.length > 1 ? `Op ${String(i4 + 1)}/${String(operations.length)}: ` : "";
+        try {
+          const detail = await this.executeSurgicalOp(sourceFile, op, ts);
+          details.push(`${label}${detail}`);
+        } catch (err2) {
+          const msg = err2 instanceof Error ? err2.message : String(err2);
+          sourceFile.replaceWithText(before);
+          return {
+            ok: false,
+            error: `${label}${msg}
+NO edits were applied (atomic rollback).`
+          };
+        }
+      }
+      const after = sourceFile.getFullText();
+      if (before === after) {
+        const allIdempotent = details.every((d2) => /already present|nothing to add|nothing to do|no-op/i.test(d2));
+        if (allIdempotent) {
+          return {
+            ok: true,
+            before,
+            after,
+            details
+          };
+        }
+        return {
+          ok: false,
+          error: "No changes produced by the operations."
+        };
+      }
+      sourceFile.refreshFromFileSystemSync();
+      return {
+        ok: true,
+        before,
+        after,
+        details
+      };
+    }
+    async executeSurgicalOp(sf, op, ts) {
+      const action = op.action;
+      switch (action) {
+        case "organize_imports":
+          sf.organizeImports();
+          return "Organized imports";
+        case "fix_missing_imports":
+          sf.fixMissingImports();
+          return "Fixed missing imports";
+        case "fix_unused":
+          sf.fixUnusedIdentifiers();
+          return "Fixed unused identifiers";
+        case "add_import": {
+          if (!op.value)
+            throw new Error('add_import requires value (module specifier, e.g. "node:fs"). Pass named imports via newCode (comma-separated), default import via name. Example: { action:"add_import", value:"node:fs", newCode:"readFile, writeFile" }');
+          const desiredNamed = op.newCode?.split(",").map((s2) => s2.trim()).filter(Boolean) ?? [];
+          const desiredDefault = op.name?.trim();
+          const existing = sf.getImportDeclaration(op.value);
+          if (existing) {
+            const addedNamed = [];
+            const existingNames = new Set(existing.getNamedImports().map((n) => n.getName()));
+            for (const n of desiredNamed) {
+              if (!existingNames.has(n)) {
+                existing.addNamedImport(n);
+                addedNamed.push(n);
+              }
+            }
+            let addedDefault = "";
+            if (desiredDefault && !existing.getDefaultImport()) {
+              existing.setDefaultImport(desiredDefault);
+              addedDefault = desiredDefault;
+            }
+            if (addedNamed.length === 0 && !addedDefault) {
+              return `Import from "${op.value}" already present \u2014 nothing to add`;
+            }
+            const parts2 = [];
+            if (addedDefault)
+              parts2.push(addedDefault);
+            if (addedNamed.length)
+              parts2.push(`{ ${addedNamed.join(", ")} }`);
+            return `Merged import ${parts2.join(", ")} into existing "${op.value}"`;
+          }
+          sf.addImportDeclaration({
+            moduleSpecifier: op.value,
+            ...desiredNamed.length > 0 ? {
+              namedImports: desiredNamed
+            } : {},
+            ...desiredDefault ? {
+              defaultImport: desiredDefault
+            } : {}
           });
+          const specDesc = desiredNamed.length ? `{ ${desiredNamed.join(", ")} }` : desiredDefault ?? "*";
+          return `Added import ${specDesc} from "${op.value}"`;
+        }
+        case "remove_import": {
+          if (!op.value)
+            throw new Error("remove_import requires value (module specifier)");
+          const imp = sf.getImportDeclaration(op.value);
+          if (!imp)
+            throw new Error(`Import "${op.value}" not found`);
+          imp.remove();
+          return `Removed import from "${op.value}"`;
+        }
+        case "add_function": {
+          if (!op.newCode)
+            throw new Error("add_function requires newCode");
+          sf.addStatements(op.newCode);
+          return `Added function${op.name ? ` "${op.name}"` : ""}`;
+        }
+        case "add_class": {
+          if (!op.newCode)
+            throw new Error("add_class requires newCode");
+          sf.addStatements(op.newCode);
+          return `Added class${op.name ? ` "${op.name}"` : ""}`;
+        }
+        case "add_interface": {
+          if (!op.newCode)
+            throw new Error("add_interface requires newCode");
+          sf.addStatements(op.newCode);
+          return `Added interface${op.name ? ` "${op.name}"` : ""}`;
+        }
+        case "add_type_alias": {
+          if (!op.newCode)
+            throw new Error("add_type_alias requires newCode");
+          sf.addStatements(op.newCode);
+          return `Added type alias${op.name ? ` "${op.name}"` : ""}`;
+        }
+        case "add_enum": {
+          if (!op.newCode)
+            throw new Error("add_enum requires newCode");
+          sf.addStatements(op.newCode);
+          return `Added enum${op.name ? ` "${op.name}"` : ""}`;
+        }
+        case "add_variable": {
+          if (!op.newCode)
+            throw new Error("add_variable requires newCode");
+          sf.addStatements(op.newCode);
+          return `Added variable${op.name ? ` "${op.name}"` : ""}`;
+        }
+        case "add_named_import": {
+          if (!op.value)
+            throw new Error("add_named_import requires value (module specifier)");
+          if (!op.newCode)
+            throw new Error("add_named_import requires newCode (import names, comma-separated). " + "Tip: add_import is also idempotent and creates the declaration if missing \u2014 prefer it.");
+          let imp = sf.getImportDeclaration(op.value);
+          if (!imp) {
+            imp = sf.addImportDeclaration({
+              moduleSpecifier: op.value
+            });
+          }
+          const names = op.newCode.split(",").map((s2) => s2.trim()).filter(Boolean);
+          const existing = new Set(imp.getNamedImports().map((n) => n.getName()));
+          const added = [];
+          for (const n of names) {
+            if (!existing.has(n)) {
+              imp.addNamedImport(n);
+              added.push(n);
+            }
+          }
+          if (added.length === 0) {
+            return `All requested named imports already present in "${op.value}" \u2014 nothing to add`;
+          }
+          return `Added { ${added.join(", ")} } to import from "${op.value}"`;
+        }
+        case "remove_named_import": {
+          if (!op.value)
+            throw new Error("remove_named_import requires value (module specifier)");
+          if (!op.name)
+            throw new Error("remove_named_import requires name (import name to remove)");
+          const rimp = sf.getImportDeclaration(op.value);
+          if (!rimp)
+            throw new Error(`Import from "${op.value}" not found`);
+          const namedImp = rimp.getNamedImports().find((n) => n.getName() === op.name);
+          if (!namedImp)
+            throw new Error(`Named import "${op.name}" not found in import from "${op.value}"`);
+          namedImp.remove();
+          return `Removed "${op.name}" from import from "${op.value}"`;
+        }
+        case "set_module_specifier": {
+          if (!op.value)
+            throw new Error("set_module_specifier requires value (old module specifier)");
+          if (!op.newCode)
+            throw new Error("set_module_specifier requires newCode (new module specifier)");
+          const simp = sf.getImportDeclaration(op.value);
+          if (!simp)
+            throw new Error(`Import from "${op.value}" not found`);
+          simp.setModuleSpecifier(op.newCode);
+          return `Changed import path "${op.value}" \u2192 "${op.newCode}"`;
+        }
+        case "insert_text": {
+          if (!op.newCode)
+            throw new Error("insert_text requires newCode");
+          let insertIdx;
+          let anchorDesc;
+          if (op.value === "after-imports") {
+            const imports = sf.getImportDeclarations();
+            insertIdx = imports.length;
+            anchorDesc = `after imports (index ${String(insertIdx)})`;
+          } else if (op.value === "before-exports") {
+            const stmts = sf.getStatements();
+            const firstExportIdx = stmts.findIndex((s2) => s2.getKindName() === "ExportDeclaration" || s2.getKindName() === "ExportAssignment");
+            insertIdx = firstExportIdx === -1 ? stmts.length : firstExportIdx;
+            anchorDesc = `before exports (index ${String(insertIdx)})`;
+          } else if (op.index === -1) {
+            const stmts = sf.getStatements();
+            insertIdx = stmts.length;
+            anchorDesc = `bottom (index ${String(insertIdx)})`;
+          } else if (op.index == null) {
+            throw new Error('insert_text requires an anchor: pass index (0 = top, -1 = bottom, N = slot), or value ("after-imports" | "before-exports"). Silent default removed to prevent accidental top-of-file insertion.');
+          } else {
+            insertIdx = op.index;
+            anchorDesc = `index ${String(insertIdx)}`;
+          }
+          sf.insertStatements(insertIdx, op.newCode);
+          return `Inserted text at ${anchorDesc}`;
+        }
+        case "add_export_declaration":
+        case "add_named_reexport": {
+          if (!op.value)
+            throw new Error(`${action} requires value (module specifier, e.g. "./bridge.js")`);
+          const desiredNames = op.newCode?.split(",").map((s2) => s2.trim()).filter(Boolean) ?? [];
+          const existingExport = sf.getExportDeclarations().find((e) => e.getModuleSpecifierValue() === op.value);
+          if (existingExport) {
+            if (existingExport.isNamespaceExport()) {
+              if (desiredNames.length === 0) {
+                return `Namespace re-export from "${op.value}" already present \u2014 nothing to add`;
+              }
+              throw new Error(`Cannot merge named exports into existing \`export * from "${op.value}"\`. Remove the namespace re-export first or use a different module specifier.`);
+            }
+            const existingNames = new Set(existingExport.getNamedExports().map((n) => n.getName()));
+            const added = [];
+            for (const n of desiredNames) {
+              if (!existingNames.has(n)) {
+                existingExport.addNamedExport(n);
+                added.push(n);
+              }
+            }
+            if (added.length === 0) {
+              return `All requested re-exports already present in "${op.value}" \u2014 nothing to add`;
+            }
+            return `Merged { ${added.join(", ")} } into existing re-export from "${op.value}"`;
+          }
+          sf.addExportDeclaration({
+            moduleSpecifier: op.value,
+            ...desiredNames.length > 0 ? {
+              namedExports: desiredNames
+            } : {}
+          });
+          const expDesc = desiredNames.length ? `{ ${desiredNames.join(", ")} }` : "*";
+          return `Added export ${expDesc} from "${op.value}"`;
+        }
+        case "add_namespace": {
+          if (!op.name)
+            throw new Error("add_namespace requires name");
+          sf.addModule({
+            name: op.name,
+            statements: op.newCode
+          });
+          return `Added namespace "${op.name}"`;
         }
       }
-      const refs = parent.getNameNode().findReferencesAsNodes();
-      for (const ref of refs) {
-        const refParent = ref.getParent();
-        if (refParent && ts.Node.isHeritageClause(refParent.getParent() ?? refParent)) {
-          const container = refParent.getParent()?.getParent();
-          if (container && ts.Node.isClassDeclaration(container)) {
-            subtypes.push({
-              name: container.getName() ?? "anonymous",
-              kind: "class",
-              file: container.getSourceFile().getFilePath(),
-              line: container.getStartLineNumber()
+      if (!op.target || !op.name) {
+        throw new Error(`Action "${action}" requires target and name.${targetsHint(action)}`);
+      }
+      let node = this.findSymbolNode(sf, op.target, op.name, ts);
+      const ADD_MEMBER_ACTIONS = new Set(["add_property", "add_method"]);
+      if (!node && ADD_MEMBER_ACTIONS.has(action) && op.name.includes(".")) {
+        const [ownerName] = op.name.split(".");
+        if (ownerName) {
+          const owner = sf.getClass(ownerName) ?? sf.getInterface(ownerName) ?? null;
+          if (owner)
+            node = owner;
+        }
+      }
+      if (!node) {
+        const available = this.listSymbolsOfKind(sf, op.target, ts);
+        const inherited = this.listInheritedMembers(sf, op.target, op.name, ts);
+        const allCandidates = [...available, ...inherited];
+        const closest = closestSymbolName(op.name, allCandidates);
+        const didYouMean = closest ? `
+Did you mean: "${closest}"?` : "";
+        const availBlock = available.length > 0 ? `
+Available ${op.target}s:
+${available.map((s2) => `  ${s2}`).join(`
+`)}` : `
+No ${op.target}s found in this file.`;
+        const inheritedBlock = inherited.length > 0 ? `
+Inherited ${op.target}s (from base class/interface):
+${inherited.map((s2) => `  ${s2}`).join(`
+`)}` : "";
+        throw new Error(`Symbol not found: ${op.target} "${op.name}".${didYouMean}${availBlock}${inheritedBlock}`);
+      }
+      switch (action) {
+        case "set_type": {
+          if (!op.value)
+            throw new Error("set_type requires value");
+          if ("setType" in node && typeof node.setType === "function") {
+            node.setType(op.value);
+            return `Set type of ${op.target} "${op.name}" \u2192 ${op.value}`;
+          }
+          if (ts.Node.isVariableStatement(node)) {
+            const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+            if (decl) {
+              decl.setType(op.value);
+              return `Set type of variable "${op.name}" \u2192 ${op.value}`;
+            }
+          }
+          if (ts.Node.isTypeAliasDeclaration(node)) {
+            throw new Error(`set_type not supported on type aliases. Use: { action:"replace", target:"type", name:"${op.name}", newCode:"type ${op.name} = \u2026" } to rewrite the whole alias.`);
+          }
+          throw new Error(`Cannot set type on ${op.target} "${op.name}".${targetsHint("set_type")}`);
+        }
+        case "set_return_type": {
+          if (!op.value)
+            throw new Error("set_return_type requires value");
+          if ("setReturnType" in node && typeof node.setReturnType === "function") {
+            node.setReturnType(op.value);
+            return `Set return type of ${op.target} "${op.name}" \u2192 ${op.value}`;
+          }
+          throw new Error(`Cannot set return type on ${op.target} "${op.name}"`);
+        }
+        case "set_value": {
+          if (op.value === undefined)
+            throw new Error("set_value requires value");
+          if (ts.Node.isEnumDeclaration(node)) {
+            const [memberName, memberValue] = op.value.split("=").map((s2) => s2.trim());
+            if (!memberName)
+              throw new Error("set_value on enum requires value format: memberName=newValue");
+            const member = node.getMember(memberName);
+            if (!member)
+              throw new Error(`Enum member "${memberName}" not found in "${op.name}"`);
+            if (memberValue !== undefined)
+              member.setValue(Number.isNaN(Number(memberValue)) ? memberValue : Number(memberValue));
+            return `Set enum "${op.name}".${memberName} = ${String(memberValue)}`;
+          }
+          throw new Error(`set_value not supported on ${op.target}`);
+        }
+        case "set_initializer": {
+          if (!op.value)
+            throw new Error("set_initializer requires value");
+          if (ts.Node.isVariableStatement(node)) {
+            const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+            if (decl) {
+              decl.setInitializer(op.value);
+              return `Set initializer of "${op.name}" \u2192 ${op.value}`;
+            }
+          }
+          if ("setInitializer" in node && typeof node.setInitializer === "function") {
+            node.setInitializer(op.value);
+            return `Set initializer of "${op.name}" \u2192 ${op.value}`;
+          }
+          throw new Error(`Cannot set initializer on ${op.target} "${op.name}"`);
+        }
+        case "set_async": {
+          if ("setIsAsync" in node && typeof node.setIsAsync === "function") {
+            const val = op.value !== "false";
+            node.setIsAsync(val);
+            return `Set ${op.target} "${op.name}" async \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set async on ${op.target} "${op.name}"`);
+        }
+        case "set_generator": {
+          if ("setIsGenerator" in node && typeof node.setIsGenerator === "function") {
+            const val = op.value !== "false";
+            node.setIsGenerator(val);
+            return `Set ${op.target} "${op.name}" generator \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set generator on ${op.target} "${op.name}"`);
+        }
+        case "set_export": {
+          if ("setIsExported" in node && typeof node.setIsExported === "function") {
+            const val = op.value !== "false";
+            node.setIsExported(val);
+            return `Set ${op.target} "${op.name}" exported \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set export on ${op.target} "${op.name}"`);
+        }
+        case "set_default_export": {
+          if ("setIsDefaultExport" in node && typeof node.setIsDefaultExport === "function") {
+            const val = op.value !== "false";
+            node.setIsDefaultExport(val);
+            return `Set ${op.target} "${op.name}" default export \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set default export on ${op.target} "${op.name}"`);
+        }
+        case "rename":
+        case "rename_global": {
+          if (!op.value)
+            throw new Error(`${action} requires value (new name)`);
+          const isGlobal = action === "rename_global";
+          const newName = op.value;
+          const localRename = (n) => {
+            const nameNode = n.getNameNode?.();
+            if (nameNode && typeof nameNode.replaceWithText === "function") {
+              nameNode.replaceWithText(newName);
+              return true;
+            }
+            return false;
+          };
+          if (isGlobal) {
+            if (ts.Node.isVariableStatement(node)) {
+              const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+              const nameNode = decl?.getNameNode();
+              if (nameNode && ts.Node.isIdentifier(nameNode)) {
+                nameNode.rename(newName);
+                return `Renamed (global) variable "${op.name}" \u2192 "${newName}"`;
+              }
+            }
+            if ("rename" in node && typeof node.rename === "function") {
+              node.rename(newName);
+              return `Renamed (global) ${op.target} "${op.name}" \u2192 "${newName}"`;
+            }
+            throw new Error(`Cannot rename ${op.target} "${op.name}" (global)`);
+          }
+          if (ts.Node.isVariableStatement(node)) {
+            const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+            if (!decl)
+              throw new Error(`Variable "${op.name}" not found in declaration`);
+            if (localRename(decl)) {
+              return `Renamed variable "${op.name}" \u2192 "${newName}" (declaration only \u2014 references untouched)`;
+            }
+          }
+          if (localRename(node)) {
+            return `Renamed ${op.target} "${op.name}" \u2192 "${newName}" (declaration only \u2014 references untouched)`;
+          }
+          throw new Error(`Cannot rename ${op.target} "${op.name}"`);
+        }
+        case "remove": {
+          const line = node.getStartLineNumber();
+          if ("remove" in node && typeof node.remove === "function") {
+            node.remove();
+            return `Removed ${op.target} "${op.name}" (was at line ${String(line)})`;
+          }
+          throw new Error(`Cannot remove ${op.target} "${op.name}"`);
+        }
+        case "set_optional": {
+          const val = op.value !== "false";
+          if ("setHasQuestionToken" in node && typeof node.setHasQuestionToken === "function") {
+            node.setHasQuestionToken(val);
+            return `Set ${op.target} "${op.name}" optional \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set optional on ${op.target} "${op.name}"`);
+        }
+        case "add_parameter": {
+          if (!op.value)
+            throw new Error("add_parameter requires value (name: type)");
+          if ("addParameter" in node && typeof node.addParameter === "function") {
+            const [pName, pType] = op.value.split(":").map((s2) => s2.trim());
+            node.addParameter({
+              name: pName ?? op.value,
+              ...pType ? {
+                type: pType
+              } : {}
+            });
+            return `Added parameter "${op.value}" to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add parameter to ${op.target} "${op.name}"`);
+        }
+        case "remove_parameter": {
+          if (!op.value)
+            throw new Error("remove_parameter requires value (parameter name)");
+          if ("getParameters" in node && typeof node.getParameters === "function") {
+            const params = node.getParameters();
+            const param = params.find((p2) => p2.getName() === op.value);
+            if (!param)
+              throw new Error(`Parameter "${op.value}" not found in ${op.target} "${op.name}"`);
+            param.remove();
+            return `Removed parameter "${op.value}" from ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot remove parameter from ${op.target} "${op.name}"`);
+        }
+        case "set_body": {
+          if (!op.newCode)
+            throw new Error("set_body requires newCode");
+          if (ts.Node.isVariableStatement(node)) {
+            const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+            const init2 = decl?.getInitializer();
+            if (init2 && (init2.getKindName() === "ArrowFunction" || init2.getKindName() === "FunctionExpression")) {
+              throw new Error(`Cannot set body on variable "${op.name}" directly \u2014 the initializer is an arrow/function expression. Use: { action:"set_body", target:"arrow_function", name:"${op.name}", newCode:"\u2026" }.`);
+            }
+          }
+          if ("setBodyText" in node && typeof node.setBodyText === "function") {
+            node.setBodyText(op.newCode);
+            return `Set body of ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot set body on ${op.target} "${op.name}" \u2014 no body (interface signature? type alias? use replace instead).${targetsHint("set_body")}`);
+        }
+        case "add_statement": {
+          if (!op.newCode)
+            throw new Error("add_statement requires newCode");
+          if (ts.Node.isVariableStatement(node)) {
+            const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+            const init2 = decl?.getInitializer();
+            if (init2 && (init2.getKindName() === "ArrowFunction" || init2.getKindName() === "FunctionExpression")) {
+              throw new Error(`Cannot add statement to variable "${op.name}" directly \u2014 the initializer is an arrow/function expression. Use: { action:"add_statement", target:"arrow_function", name:"${op.name}", newCode:"\u2026" }.`);
+            }
+          }
+          if (ts.Node.isArrowFunction(node)) {
+            const body4 = node.getBody();
+            if (!ts.Node.isBlock(body4)) {
+              const exprText = body4.getText();
+              node.setBodyText(`return ${exprText};
+${op.newCode}`);
+              return `Added statement to arrow_function "${op.name}" (expression body wrapped into block)`;
+            }
+          }
+          if ("addStatements" in node && typeof node.addStatements === "function") {
+            node.addStatements(op.newCode);
+            return `Added statement to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add statement to ${op.target} "${op.name}".${targetsHint("add_statement")}`);
+        }
+        case "insert_statement": {
+          if (!op.newCode)
+            throw new Error("insert_statement requires newCode");
+          const idx = op.index ?? 0;
+          if ("insertStatements" in node && typeof node.insertStatements === "function") {
+            node.insertStatements(idx, op.newCode);
+            return `Inserted statement at index ${String(idx)} in ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot insert statement in ${op.target} "${op.name}"`);
+        }
+        case "remove_statement": {
+          const idx = op.index ?? 0;
+          if ("removeStatement" in node && typeof node.removeStatement === "function") {
+            node.removeStatement(idx);
+            return `Removed statement at index ${String(idx)} from ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot remove statement from ${op.target} "${op.name}"`);
+        }
+        case "add_property": {
+          if (!op.newCode)
+            throw new Error("add_property requires newCode (name: type or name = value)");
+          let container = node;
+          if (op.target === "property" && op.name.includes(".")) {
+            const parent = node.getParent();
+            if (parent && (ts.Node.isClassDeclaration(parent) || ts.Node.isInterfaceDeclaration(parent))) {
+              container = parent;
+            }
+          }
+          if (ts.Node.isInterfaceDeclaration(container)) {
+            const optional = op.newCode.includes("?:");
+            const [pName, pType] = op.newCode.replace("?:", ":").split(":").map((s2) => s2.trim());
+            container.addProperty({
+              name: pName ?? op.newCode,
+              type: pType,
+              hasQuestionToken: optional
+            });
+            return `Added property "${pName ?? op.newCode}" to interface "${container.getName() ?? op.name}"`;
+          }
+          if (ts.Node.isClassDeclaration(container)) {
+            container.addProperty({
+              name: op.newCode.split(/[=:]/)[0]?.trim() ?? op.newCode
+            });
+            const props = container.getProperties();
+            const last = props[props.length - 1];
+            if (last)
+              last.replaceWithText(op.newCode);
+            return `Added property to class "${container.getName() ?? op.name}"`;
+          }
+          throw new Error(`Cannot add property to ${op.target} "${op.name}". For classes/interfaces pass target:"class"|"interface" with name=ContainerName, or pass target:"property" with a dotted name like "Container.prop" to auto-resolve the owner.`);
+        }
+        case "remove_property": {
+          if (!op.value)
+            throw new Error("remove_property requires value (property name)");
+          if (ts.Node.isInterfaceDeclaration(node)) {
+            const prop = node.getProperty(op.value);
+            if (!prop)
+              throw new Error(`Property "${op.value}" not found in interface "${op.name}"`);
+            prop.remove();
+            return `Removed property "${op.value}" from interface "${op.name}"`;
+          }
+          if (ts.Node.isClassDeclaration(node)) {
+            const prop = node.getProperty(op.value);
+            if (!prop)
+              throw new Error(`Property "${op.value}" not found in class "${op.name}"`);
+            prop.remove();
+            return `Removed property "${op.value}" from class "${op.name}"`;
+          }
+          throw new Error(`Cannot remove property from ${op.target} "${op.name}"`);
+        }
+        case "add_method": {
+          if (!op.newCode)
+            throw new Error("add_method requires newCode");
+          let container = node;
+          if ((op.target === "method" || op.target === "function") && op.name.includes(".")) {
+            const parent = node.getParent();
+            if (parent && (ts.Node.isClassDeclaration(parent) || ts.Node.isInterfaceDeclaration(parent))) {
+              container = parent;
+            }
+          }
+          if (ts.Node.isClassDeclaration(container)) {
+            const methodMatch = op.newCode.match(/(?:async\s+)?(\w+)\s*\(/);
+            if (methodMatch) {
+              const methodName = methodMatch[1] ?? "method";
+              const method = container.addMethod({
+                name: methodName
+              });
+              method.replaceWithText(op.newCode);
+            } else {
+              container.addMember(op.newCode);
+            }
+            return `Added method to class "${container.getName() ?? op.name}"`;
+          }
+          if (ts.Node.isInterfaceDeclaration(container)) {
+            const sigMatch = op.newCode.match(/(\w+)\s*\(/);
+            if (sigMatch) {
+              const sigName = sigMatch[1] ?? "method";
+              const sig = container.addMethod({
+                name: sigName
+              });
+              sig.replaceWithText(op.newCode);
+            } else {
+              container.addMember(op.newCode);
+            }
+            return `Added method signature to interface "${container.getName() ?? op.name}"`;
+          }
+          throw new Error(`Cannot add method to ${op.target} "${op.name}". For classes/interfaces pass target:"class"|"interface" with name=ContainerName, or pass target:"method" with a dotted name like "Container.methodName" to auto-resolve the owner.`);
+        }
+        case "add_member": {
+          if (!op.newCode)
+            throw new Error("add_member requires newCode");
+          if (ts.Node.isEnumDeclaration(node)) {
+            const eqIdx = op.newCode.indexOf("=");
+            if (eqIdx >= 0) {
+              const mName = op.newCode.slice(0, eqIdx).trim();
+              const mVal = op.newCode.slice(eqIdx + 1).trim();
+              node.addMember({
+                name: mName,
+                value: Number.isNaN(Number(mVal)) ? mVal : Number(mVal)
+              });
+            } else {
+              node.addMember({
+                name: op.newCode.trim()
+              });
+            }
+            return `Added member to enum "${op.name}"`;
+          }
+          if ("addMember" in node && typeof node.addMember === "function") {
+            node.addMember(op.newCode);
+            return `Added member to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add member to ${op.target} "${op.name}"`);
+        }
+        case "remove_member": {
+          if (!op.value)
+            throw new Error("remove_member requires value (member name)");
+          if (ts.Node.isEnumDeclaration(node)) {
+            const member = node.getMember(op.value);
+            if (!member)
+              throw new Error(`Member "${op.value}" not found in enum "${op.name}"`);
+            member.remove();
+            return `Removed member "${op.value}" from enum "${op.name}"`;
+          }
+          if (ts.Node.isClassDeclaration(node)) {
+            const method = node.getMethod(op.value);
+            if (method) {
+              method.remove();
+              return `Removed method "${op.value}" from class "${op.name}"`;
+            }
+            const prop = node.getProperty(op.value);
+            if (prop) {
+              prop.remove();
+              return `Removed property "${op.value}" from class "${op.name}"`;
+            }
+            throw new Error(`Member "${op.value}" not found in class "${op.name}"`);
+          }
+          throw new Error(`Cannot remove member from ${op.target} "${op.name}"`);
+        }
+        case "set_extends": {
+          if (!op.value)
+            throw new Error("set_extends requires value (base class/interface name)");
+          if (ts.Node.isClassDeclaration(node)) {
+            node.setExtends(op.value);
+            return `Set class "${op.name}" extends ${op.value}`;
+          }
+          throw new Error(`Cannot set extends on ${op.target} "${op.name}"`);
+        }
+        case "remove_extends": {
+          if (ts.Node.isClassDeclaration(node)) {
+            node.removeExtends();
+            return `Removed extends from class "${op.name}"`;
+          }
+          throw new Error(`Cannot remove extends from ${op.target} "${op.name}"`);
+        }
+        case "add_implements": {
+          if (!op.value)
+            throw new Error("add_implements requires value (interface name(s), comma-separated)");
+          if (ts.Node.isClassDeclaration(node)) {
+            const ifaces = op.value.split(",").map((s2) => s2.trim()).filter(Boolean);
+            node.addImplements(ifaces);
+            return `Added implements ${ifaces.join(", ")} to class "${op.name}"`;
+          }
+          throw new Error(`Cannot add implements to ${op.target} "${op.name}"`);
+        }
+        case "remove_implements": {
+          if (op.index === undefined)
+            throw new Error("remove_implements requires index");
+          if (ts.Node.isClassDeclaration(node)) {
+            node.removeImplements(op.index);
+            return `Removed implements at index ${String(op.index)} from class "${op.name}"`;
+          }
+          throw new Error(`Cannot remove implements from ${op.target} "${op.name}"`);
+        }
+        case "add_constructor": {
+          let cls;
+          let existingCtor;
+          if (ts.Node.isClassDeclaration(node)) {
+            cls = node;
+            existingCtor = node.getConstructors()[0];
+          } else if (ts.Node.isConstructorDeclaration(node)) {
+            existingCtor = node;
+            const parent = node.getParent();
+            if (parent && ts.Node.isClassDeclaration(parent))
+              cls = parent;
+          } else if (op.target === "method" && op.name.includes(".")) {
+            const [className] = op.name.split(".");
+            if (className)
+              cls = sf.getClass(className);
+            existingCtor = cls?.getConstructors()[0];
+          }
+          if (!cls) {
+            throw new Error(`Cannot add constructor to ${op.target} "${op.name}". Use target:"class" with name=ClassName.${targetsHint("add_constructor")}`);
+          }
+          if (existingCtor) {
+            if (op.newCode)
+              existingCtor.setBodyText(op.newCode);
+            return `Modified existing constructor of class "${cls.getName() ?? op.name}"`;
+          }
+          const ctor = cls.addConstructor({});
+          if (op.newCode)
+            ctor.setBodyText(op.newCode);
+          return `Added constructor to class "${cls.getName() ?? op.name}"`;
+        }
+        case "add_getter": {
+          if (!op.value)
+            throw new Error("add_getter requires value (getter name)");
+          if (ts.Node.isClassDeclaration(node)) {
+            node.addGetAccessor({
+              name: op.value,
+              statements: op.newCode ? [op.newCode] : []
+            });
+            return `Added getter "${op.value}" to class "${op.name}"`;
+          }
+          throw new Error(`Cannot add getter to ${op.target} "${op.name}"`);
+        }
+        case "add_setter": {
+          if (!op.value)
+            throw new Error("add_setter requires value (setter name)");
+          if (ts.Node.isClassDeclaration(node)) {
+            const paramParts = op.newCode?.split(":").map((s2) => s2.trim());
+            const paramName = paramParts?.[0] ?? "value";
+            const paramType = paramParts?.[1];
+            node.addSetAccessor({
+              name: op.value,
+              parameters: [{
+                name: paramName,
+                ...paramType ? {
+                  type: paramType
+                } : {}
+              }]
             });
+            return `Added setter "${op.value}" to class "${op.name}"`;
+          }
+          throw new Error(`Cannot add setter to ${op.target} "${op.name}"`);
+        }
+        case "set_abstract": {
+          const val = op.value !== "false";
+          if ("setIsAbstract" in node && typeof node.setIsAbstract === "function") {
+            node.setIsAbstract(val);
+            return `Set ${op.target} "${op.name}" abstract \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set abstract on ${op.target} "${op.name}"`);
+        }
+        case "set_static": {
+          const val = op.value !== "false";
+          if ("setIsStatic" in node && typeof node.setIsStatic === "function") {
+            node.setIsStatic(val);
+            return `Set "${op.name}" static \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set static on ${op.target} "${op.name}"`);
+        }
+        case "set_readonly": {
+          const val = op.value !== "false";
+          if ("setIsReadonly" in node && typeof node.setIsReadonly === "function") {
+            node.setIsReadonly(val);
+            return `Set "${op.name}" readonly \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set readonly on ${op.target} "${op.name}"`);
+        }
+        case "set_scope": {
+          if (!op.value)
+            throw new Error("set_scope requires value (public/protected/private)");
+          if ("setScope" in node && typeof node.setScope === "function") {
+            node.setScope(op.value);
+            return `Set scope of "${op.name}" \u2192 ${op.value}`;
           }
+          throw new Error(`Cannot set scope on ${op.target} "${op.name}"`);
         }
+        case "set_overrides": {
+          const val = op.value !== "false";
+          if ("setHasOverrideKeyword" in node && typeof node.setHasOverrideKeyword === "function") {
+            node.setHasOverrideKeyword(val);
+            return `Set "${op.name}" override \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set override on ${op.target} "${op.name}"`);
+        }
+        case "set_ambient": {
+          const val = op.value !== "false";
+          if ("setHasDeclareKeyword" in node && typeof node.setHasDeclareKeyword === "function") {
+            node.setHasDeclareKeyword(val);
+            return `Set ${op.target} "${op.name}" ambient (declare) \u2192 ${String(val)}`;
+          }
+          throw new Error(`Cannot set ambient on ${op.target} "${op.name}"`);
+        }
+        case "set_const_enum": {
+          if (ts.Node.isEnumDeclaration(node)) {
+            const val = op.value !== "false";
+            node.setIsConstEnum(val);
+            return `Set enum "${op.name}" const \u2192 ${String(val)}`;
+          }
+          throw new Error(`set_const_enum only works on enums, not ${op.target}`);
+        }
+        case "remove_initializer": {
+          if (ts.Node.isVariableStatement(node)) {
+            const decl = node.getDeclarations().find((d2) => d2.getName() === op.name);
+            if (decl && "removeInitializer" in decl) {
+              decl.removeInitializer();
+              return `Removed initializer from "${op.name}"`;
+            }
+          }
+          if ("removeInitializer" in node && typeof node.removeInitializer === "function") {
+            node.removeInitializer();
+            return `Removed initializer from "${op.name}"`;
+          }
+          throw new Error(`Cannot remove initializer from ${op.target} "${op.name}"`);
+        }
+        case "set_declaration_kind": {
+          if (!op.value)
+            throw new Error("set_declaration_kind requires value (const/let/var)");
+          if (ts.Node.isVariableStatement(node)) {
+            const kindMap = {
+              const: ts.VariableDeclarationKind.Const,
+              let: ts.VariableDeclarationKind.Let,
+              var: ts.VariableDeclarationKind.Var
+            };
+            const dk = kindMap[op.value];
+            if (!dk)
+              throw new Error(`Invalid declaration kind "${op.value}" \u2014 use const, let, or var`);
+            node.setDeclarationKind(dk);
+            return `Set declaration kind of "${op.name}" \u2192 ${op.value}`;
+          }
+          throw new Error(`Cannot set declaration kind on ${op.target} "${op.name}"`);
+        }
+        case "add_decorator": {
+          if (!op.value)
+            throw new Error("add_decorator requires value (decorator text, e.g. @Injectable())");
+          if ("addDecorator" in node && typeof node.addDecorator === "function") {
+            const decoratorName = op.value.startsWith("@") ? op.value.slice(1) : op.value;
+            const parenIdx = decoratorName.indexOf("(");
+            if (parenIdx >= 0) {
+              const name2 = decoratorName.slice(0, parenIdx);
+              const args2 = decoratorName.slice(parenIdx + 1, -1);
+              node.addDecorator({
+                name: name2,
+                arguments: args2 ? [args2] : []
+              });
+            } else {
+              node.addDecorator({
+                name: decoratorName
+              });
+            }
+            return `Added decorator @${decoratorName} to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add decorator to ${op.target} "${op.name}"`);
+        }
+        case "remove_decorator": {
+          if (!op.value)
+            throw new Error("remove_decorator requires value (decorator name)");
+          if ("getDecorators" in node && typeof node.getDecorators === "function") {
+            const decorators = node.getDecorators();
+            const dec = decorators.find((d2) => d2.getName() === op.value);
+            if (!dec)
+              throw new Error(`Decorator "${op.value}" not found on ${op.target} "${op.name}"`);
+            dec.remove();
+            return `Removed decorator @${op.value} from ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot remove decorator from ${op.target} "${op.name}"`);
+        }
+        case "add_type_parameter": {
+          if (!op.value)
+            throw new Error("add_type_parameter requires value (e.g. T, T extends Base, T = Default)");
+          if ("addTypeParameter" in node && typeof node.addTypeParameter === "function") {
+            const parts2 = op.value.split(/\s+extends\s+/);
+            const name2 = (parts2[0] ?? op.value).trim();
+            let constraint;
+            let defaultType;
+            if (parts2[1]) {
+              const defParts = parts2[1].split(/\s*=\s*/);
+              constraint = defParts[0]?.trim();
+              defaultType = defParts[1]?.trim();
+            }
+            node.addTypeParameter({
+              name: name2,
+              constraint,
+              default: defaultType
+            });
+            return `Added type parameter <${op.value}> to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add type parameter to ${op.target} "${op.name}"`);
+        }
+        case "add_extends": {
+          if (!op.value)
+            throw new Error("add_extends requires value (interface/type name)");
+          if (ts.Node.isInterfaceDeclaration(node)) {
+            node.addExtends(op.value);
+            return `Added extends ${op.value} to interface "${op.name}"`;
+          }
+          throw new Error(`Cannot add extends to ${op.target} "${op.name}" \u2014 use set_extends for classes`);
+        }
+        case "remove_method": {
+          if (!op.value)
+            throw new Error("remove_method requires value (method name)");
+          if (ts.Node.isClassDeclaration(node)) {
+            const method = node.getMethod(op.value);
+            if (!method)
+              throw new Error(`Method "${op.value}" not found in class "${op.name}"`);
+            method.remove();
+            return `Removed method "${op.value}" from class "${op.name}"`;
+          }
+          if (ts.Node.isInterfaceDeclaration(node)) {
+            const method = node.getMethod(op.value);
+            if (!method)
+              throw new Error(`Method "${op.value}" not found in interface "${op.name}"`);
+            method.remove();
+            return `Removed method "${op.value}" from interface "${op.name}"`;
+          }
+          throw new Error(`Cannot remove method from ${op.target} "${op.name}"`);
+        }
+        case "add_overload": {
+          if (!op.newCode)
+            throw new Error("add_overload requires newCode (overload signature)");
+          if ("addOverload" in node && typeof node.addOverload === "function") {
+            node.addOverload({});
+            if (ts.Node.isFunctionDeclaration(node)) {
+              const overloads = node.getOverloads();
+              const last = overloads[overloads.length - 1];
+              if (last)
+                last.replaceWithText(op.newCode);
+            }
+            return `Added overload to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add overload to ${op.target} "${op.name}"`);
+        }
+        case "add_jsdoc": {
+          if (!op.newCode)
+            throw new Error("add_jsdoc requires newCode (description text)");
+          if ("addJsDoc" in node && typeof node.addJsDoc === "function") {
+            node.addJsDoc({
+              description: op.newCode
+            });
+            return `Added JSDoc to ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot add JSDoc to ${op.target} "${op.name}"`);
+        }
+        case "remove_jsdoc": {
+          if ("getJsDocs" in node && typeof node.getJsDocs === "function") {
+            const docs = node.getJsDocs();
+            if (docs.length === 0)
+              throw new Error(`No JSDoc found on ${op.target} "${op.name}"`);
+            if (op.value === "all") {
+              for (const doc of docs)
+                doc.remove();
+              return `Removed all ${String(docs.length)} JSDoc(s) from ${op.target} "${op.name}"`;
+            }
+            const last = docs[docs.length - 1];
+            if (last)
+              last.remove();
+            return `Removed JSDoc from ${op.target} "${op.name}"`;
+          }
+          throw new Error(`Cannot remove JSDoc from ${op.target} "${op.name}"`);
+        }
+        case "unwrap": {
+          if ("unwrap" in node && typeof node.unwrap === "function") {
+            node.unwrap();
+            return `Unwrapped ${op.target} "${op.name}" (replaced with its body)`;
+          }
+          throw new Error(`Cannot unwrap ${op.target} "${op.name}" \u2014 only functions and namespaces support unwrap`);
+        }
+        case "set_structure": {
+          if (!op.newCode)
+            throw new Error("set_structure requires newCode (JSON structure object)");
+          if ("set" in node && typeof node.set === "function") {
+            try {
+              const structure = JSON.parse(op.newCode);
+              node.set(structure);
+              return `Applied structure to ${op.target} "${op.name}"`;
+            } catch (e) {
+              const msg = e instanceof Error ? e.message : String(e);
+              throw new Error(`Invalid structure JSON: ${msg}`);
+            }
+          }
+          throw new Error(`Cannot set structure on ${op.target} "${op.name}"`);
+        }
+        case "extract_interface": {
+          if (!ts.Node.isClassDeclaration(node)) {
+            throw new Error(`extract_interface only works on classes, not ${op.target}`);
+          }
+          const ifaceName = op.value ?? `I${op.name}`;
+          const structure = node.extractInterface(ifaceName);
+          sf.addInterface(structure);
+          return `Extracted interface "${ifaceName}" from class "${op.name}"`;
+        }
+        case "replace": {
+          if (!op.newCode)
+            throw new Error("replace requires newCode");
+          const startLine = node.getStartLineNumber();
+          const endLine = node.getEndLineNumber();
+          node.replaceWithText(op.newCode);
+          const newLineCount = op.newCode.split(`
+`).length;
+          return `Replaced ${op.target} "${op.name}" (lines ${String(startLine)}-${String(endLine)} \u2192 ${String(startLine)}-${String(startLine + newLineCount - 1)})`;
+        }
+        case "replace_in_body": {
+          if (!op.value)
+            throw new Error("replace_in_body requires value (substring/anchor to find)");
+          if (op.newCode === undefined)
+            throw new Error("replace_in_body requires newCode (replacement text)");
+          const nodeText = node.getFullText();
+          const absFullStart = node.getFullStart();
+          const findOneIn = (hay, raw2, label) => {
+            const passes = [{
+              needle: raw2,
+              matcher: "exact"
+            }, {
+              needle: stripCommonIndent(raw2),
+              matcher: "exact"
+            }, {
+              needle: raw2,
+              matcher: "fuzzy"
+            }];
+            for (const {
+              needle,
+              matcher
+            } of passes) {
+              if (!needle)
+                continue;
+              if (matcher === "exact") {
+                const first = hay.indexOf(needle);
+                if (first === -1)
+                  continue;
+                const second = hay.indexOf(needle, first + needle.length);
+                if (second !== -1) {
+                  throw new Error(`replace_in_body: ${label} is ambiguous (found \u22652 exact matches) inside ${op.target} "${op.name}". Add more surrounding context to make the anchor unique, or use an anchor pair (value + valueEnd).`);
+                }
+                return {
+                  index: first,
+                  length: needle.length
+                };
+              }
+              if (!needle.includes(`
+`))
+                continue;
+              const hit = fuzzyMatchMultilineInText(hay, needle);
+              if (hit)
+                return hit;
+            }
+            const bodyPreview = hay.length > 1200 ? `${hay.slice(0, 1200)}
+\u2026(truncated \u2014 ${String(hay.length)} chars total)` : hay;
+            const valPreview = raw2.length > 300 ? `${raw2.slice(0, 300)}\u2026(${label} has ${String(raw2.length)} chars)` : raw2;
+            const hint = raw2.length > 200 ? `
+HINT: ${label} is long \u2014 use an anchor pair (value + valueEnd, each 1-2 unique lines) to replace a large range, or \`replace\` on the whole symbol for full rewrites.` : "";
+            throw new Error(`replace_in_body: ${label} not found inside ${op.target} "${op.name}".${hint}
+Searched for:
+${valPreview}
+
+Actual body:
+${bodyPreview}`);
+          };
+          let fromRel;
+          let toRel;
+          let modeDesc;
+          if (op.valueEnd) {
+            const startHit = findOneIn(nodeText, op.value, "value (start anchor)");
+            const searchAfter = nodeText.slice(startHit.index + startHit.length);
+            const endHit = findOneIn(searchAfter, op.valueEnd, "valueEnd (end anchor)");
+            fromRel = startHit.index;
+            toRel = startHit.index + startHit.length + endHit.index + endHit.length;
+            modeDesc = `anchors (${String(toRel - fromRel)} chars)`;
+          } else {
+            const hit = findOneIn(nodeText, op.value, "value");
+            fromRel = hit.index;
+            toRel = hit.index + hit.length;
+            modeDesc = `substring (${String(hit.length)} chars)`;
+          }
+          const from = absFullStart + fromRel;
+          const to = absFullStart + toRel;
+          if (from < absFullStart || to > absFullStart + nodeText.length) {
+            throw new Error("replace_in_body: computed range outside node \u2014 aborting");
+          }
+          sf.replaceText([from, to], op.newCode);
+          return `Replaced ${modeDesc} in ${op.target} "${op.name}" \u2192 ${String(op.newCode.length)} chars`;
+        }
+        default:
+          throw new Error(`Unknown action: ${action}`);
       }
-    } else {
-      return null;
     }
-    return {
-      item,
-      supertypes,
-      subtypes
-    };
-  }
-  async findUnused(file) {
-    const sourceFile = await this.getSourceFile(file);
-    if (!sourceFile)
-      return null;
-    const ts = await getTsMorph();
-    const unused = [];
-    for (const imp of sourceFile.getImportDeclarations()) {
-      const defaultImport = imp.getDefaultImport();
-      if (defaultImport) {
-        const refs = defaultImport.findReferencesAsNodes();
-        if (refs.length <= 1) {
-          unused.push({
-            name: defaultImport.getText(),
-            kind: "import",
-            file: resolve6(file),
-            line: imp.getStartLineNumber()
-          });
+    findSymbolNode(sf, target, name2, _ts) {
+      if (target === "function") {
+        const fn = sf.getFunction(name2);
+        if (fn)
+          return fn;
+        for (const cls of sf.getClasses()) {
+          const method = cls.getMethod(name2);
+          if (method)
+            return method;
         }
+        return null;
       }
-      for (const named of imp.getNamedImports()) {
-        const nameNode = named.getAliasNode();
-        const effectiveNode = nameNode ?? named.getNameNode();
-        const refs = "findReferencesAsNodes" in effectiveNode ? effectiveNode.findReferencesAsNodes() : [];
-        if (refs.length <= 1) {
-          unused.push({
-            name: named.getName(),
-            kind: "import",
-            file: resolve6(file),
-            line: imp.getStartLineNumber()
-          });
+      if (target === "method") {
+        if (name2.includes(".")) {
+          const [className, methodName] = name2.split(".");
+          const cls = sf.getClass(className ?? "");
+          if (!cls)
+            return null;
+          if (methodName === "constructor") {
+            return cls.getConstructors()[0] ?? null;
+          }
+          return cls.getMethod(methodName ?? "") ?? cls.getProperty(methodName ?? "") ?? null;
+        }
+        if (name2 === "constructor") {
+          for (const cls of sf.getClasses()) {
+            const ctor = cls.getConstructors()[0];
+            if (ctor)
+              return ctor;
+          }
+          return null;
+        }
+        for (const cls of sf.getClasses()) {
+          const method = cls.getMethod(name2);
+          if (method)
+            return method;
+        }
+        return null;
+      }
+      if (target === "constructor") {
+        const cls = sf.getClass(name2);
+        if (!cls)
+          return null;
+        const ctors = cls.getConstructors();
+        return ctors[0] ?? null;
+      }
+      if (target === "property") {
+        if (name2.includes(".")) {
+          const [ownerName, propName] = name2.split(".");
+          const cls = sf.getClass(ownerName ?? "");
+          if (cls)
+            return cls.getProperty(propName ?? "") ?? null;
+          const iface = sf.getInterface(ownerName ?? "");
+          if (iface)
+            return iface.getProperty(propName ?? "") ?? null;
+          return null;
+        }
+        for (const cls of sf.getClasses()) {
+          const prop = cls.getProperty(name2);
+          if (prop)
+            return prop;
+        }
+        for (const iface of sf.getInterfaces()) {
+          const prop = iface.getProperty(name2);
+          if (prop)
+            return prop;
+        }
+        return null;
+      }
+      if (target === "class") {
+        return sf.getClass(name2) ?? null;
+      }
+      if (target === "interface") {
+        return sf.getInterface(name2) ?? null;
+      }
+      if (target === "type") {
+        return sf.getTypeAlias(name2) ?? null;
+      }
+      if (target === "enum") {
+        return sf.getEnum(name2) ?? null;
+      }
+      if (target === "variable" || target === "constant") {
+        for (const stmt of sf.getVariableStatements()) {
+          for (const decl of stmt.getDeclarations()) {
+            if (decl.getName() === name2)
+              return stmt;
+          }
+        }
+      }
+      if (target === "arrow_function") {
+        for (const stmt of sf.getVariableStatements()) {
+          for (const decl of stmt.getDeclarations()) {
+            if (decl.getName() !== name2)
+              continue;
+            const init2 = decl.getInitializer();
+            if (!init2)
+              return null;
+            const kind = init2.getKindName();
+            if (kind === "ArrowFunction" || kind === "FunctionExpression")
+              return init2;
+            return null;
+          }
         }
+        return null;
       }
+      return null;
     }
-    const project = this.getProject();
-    if (project) {
-      for (const [name2, decls] of sourceFile.getExportedDeclarations()) {
-        if (name2 === "default")
-          continue;
-        const decl = decls[0];
-        if (!decl)
-          continue;
-        const nameNode = ts.Node.isIdentifier(decl) ? decl : ("getNameNode" in decl) && typeof decl.getNameNode === "function" ? decl.getNameNode() : null;
-        if (!nameNode || !ts.Node.isIdentifier(nameNode))
-          continue;
-        const refs = nameNode.findReferencesAsNodes();
-        const externalRefs = refs.filter((r4) => r4.getSourceFile() !== sourceFile);
-        if (externalRefs.length === 0) {
-          unused.push({
-            name: name2,
-            kind: "export",
-            file: resolve6(file),
-            line: decl.getStartLineNumber()
-          });
+    listSymbolsOfKind(sourceFile, kind, ts) {
+      const names = [];
+      if (kind === "function") {
+        for (const f3 of sourceFile.getFunctions()) {
+          const n = f3.getName();
+          if (n)
+            names.push(`${kind} "${n}" (line ${String(f3.getStartLineNumber())})`);
+        }
+        for (const cls of sourceFile.getClasses()) {
+          const className = cls.getName() ?? "anonymous";
+          for (const m3 of cls.getMethods()) {
+            names.push(`method "${className}.${m3.getName()}" (line ${String(m3.getStartLineNumber())})`);
+          }
+        }
+      }
+      if (kind === "method") {
+        for (const cls of sourceFile.getClasses()) {
+          const className = cls.getName() ?? "anonymous";
+          for (const m3 of cls.getMethods()) {
+            names.push(`method "${className}.${m3.getName()}" (line ${String(m3.getStartLineNumber())})`);
+          }
+        }
+      }
+      if (kind === "property") {
+        for (const cls of sourceFile.getClasses()) {
+          const className = cls.getName() ?? "anonymous";
+          for (const p2 of cls.getProperties()) {
+            names.push(`property "${className}.${p2.getName()}" (line ${String(p2.getStartLineNumber())})`);
+          }
+        }
+        for (const iface of sourceFile.getInterfaces()) {
+          for (const p2 of iface.getProperties()) {
+            names.push(`property "${iface.getName()}.${p2.getName()}" (line ${String(p2.getStartLineNumber())})`);
+          }
+        }
+      }
+      if (kind === "class") {
+        for (const c of sourceFile.getClasses()) {
+          const n = c.getName();
+          if (n)
+            names.push(`${kind} "${n}" (line ${String(c.getStartLineNumber())})`);
+        }
+      }
+      if (kind === "constructor") {
+        for (const cls of sourceFile.getClasses()) {
+          const className = cls.getName() ?? "anonymous";
+          const ctors = cls.getConstructors();
+          if (ctors.length > 0) {
+            const ctor = ctors[0];
+            if (ctor) {
+              names.push(`constructor "${className}" (line ${String(ctor.getStartLineNumber())})`);
+            }
+          } else {
+            names.push(`class "${className}" (no constructor \u2014 add_constructor will create one)`);
+          }
+        }
+      }
+      if (kind === "interface") {
+        for (const i4 of sourceFile.getInterfaces()) {
+          names.push(`${kind} "${i4.getName()}" (line ${String(i4.getStartLineNumber())})`);
+        }
+      }
+      if (kind === "type") {
+        for (const t of sourceFile.getTypeAliases()) {
+          names.push(`${kind} "${t.getName()}" (line ${String(t.getStartLineNumber())})`);
+        }
+      }
+      if (kind === "enum") {
+        for (const e of sourceFile.getEnums()) {
+          names.push(`${kind} "${e.getName()}" (line ${String(e.getStartLineNumber())})`);
+        }
+      }
+      if (kind === "variable" || kind === "constant") {
+        for (const stmt of sourceFile.getVariableStatements()) {
+          const isConst = stmt.getDeclarationKind() === ts.VariableDeclarationKind.Const;
+          for (const decl of stmt.getDeclarations()) {
+            names.push(`${isConst ? "constant" : "variable"} "${decl.getName()}" (line ${String(stmt.getStartLineNumber())})`);
+          }
         }
       }
+      return names;
     }
-    return unused.length > 0 ? unused : null;
-  }
-  getProject() {
-    return this.project;
-  }
-  async ensureProject() {
-    if (this.project)
+    getProject() {
       return this.project;
-    const ts = await getTsMorph();
-    const tsconfigPath = resolve6(this.cwd, "tsconfig.json");
-    try {
-      this.project = new ts.Project({
-        tsConfigFilePath: tsconfigPath,
-        skipAddingFilesFromTsConfig: false
-      });
-    } catch {
-      this.project = new ts.Project({
-        compilerOptions: {
-          target: ts.ScriptTarget.ESNext,
-          module: ts.ModuleKind.ESNext,
-          moduleResolution: ts.ModuleResolutionKind.Bundler,
-          strict: true,
-          jsx: ts.ts.JsxEmit.ReactJSX,
-          esModuleInterop: true,
-          skipLibCheck: true,
-          allowJs: true
-        }
-      });
     }
-    return this.project;
-  }
-  async getSourceFile(file) {
-    const project = await this.ensureProject();
-    const absPath = resolve6(file);
-    let sourceFile = project.getSourceFile(absPath);
-    if (!sourceFile) {
+    async ensureProject() {
+      if (this.project)
+        return this.project;
+      const ts = await getTsMorph();
+      const tsconfigPath = resolve6(this.cwd, "tsconfig.json");
       try {
-        sourceFile = project.addSourceFileAtPath(absPath);
+        this.project = new ts.Project({
+          tsConfigFilePath: tsconfigPath,
+          skipAddingFilesFromTsConfig: true,
+          skipFileDependencyResolution: true
+        });
       } catch {
-        return null;
+        this.project = new ts.Project({
+          compilerOptions: {
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.Bundler,
+            strict: true,
+            jsx: ts.ts.JsxEmit.ReactJSX,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            allowJs: true
+          }
+        });
       }
+      return this.project;
     }
-    return sourceFile;
-  }
-  findNode(sourceFile, symbol, line, column) {
-    if (line && column) {
-      const pos = sourceFile.compilerNode.getPositionOfLineAndCharacter(line - 1, column - 1);
-      return sourceFile.getDescendantAtPos(pos) ?? null;
+    async getSourceFile(file, opts) {
+      const project = await this.ensureProject();
+      const absPath = resolve6(file);
+      let sourceFile = project.getSourceFile(absPath);
+      if (!sourceFile) {
+        try {
+          sourceFile = project.addSourceFileAtPath(absPath);
+        } catch {
+          return null;
+        }
+      } else if (opts?.refresh !== false) {
+        try {
+          sourceFile.refreshFromFileSystemSync();
+        } catch {
+          try {
+            project.removeSourceFile(sourceFile);
+            this.sourceFileLru.delete(absPath);
+            sourceFile = project.addSourceFileAtPath(absPath);
+          } catch {
+            return null;
+          }
+        }
+      }
+      this.sourceFileLru.delete(absPath);
+      this.sourceFileLru.set(absPath, Date.now());
+      this.evictSourceFilesIfNeeded(project);
+      return sourceFile;
+    }
+    evictSourceFilesIfNeeded(project) {
+      const overflow = this.sourceFileLru.size - TsMorphBackend.SOURCE_FILE_CAP;
+      if (overflow <= 0)
+        return;
+      let evicted = 0;
+      for (const absPath of this.sourceFileLru.keys()) {
+        if (evicted >= overflow)
+          break;
+        const sf = project.getSourceFile(absPath);
+        if (sf) {
+          try {
+            project.removeSourceFile(sf);
+          } catch {}
+        }
+        this.sourceFileLru.delete(absPath);
+        evicted++;
+      }
+    }
+    findNode(sourceFile, symbol, line, column) {
+      if (line && column) {
+        const pos = sourceFile.compilerNode.getPositionOfLineAndCharacter(line - 1, column - 1);
+        return sourceFile.getDescendantAtPos(pos) ?? null;
+      }
+      const found = sourceFile.forEachDescendant((node) => {
+        const ts = tsMorphModule;
+        if (!ts)
+          return;
+        if (ts.Node.isIdentifier(node) && node.getText() === symbol) {
+          return node;
+        }
+        return;
+      });
+      return found ?? null;
     }
-    const found = sourceFile.forEachDescendant((node) => {
+    getNodeDocumentation(node) {
       const ts = tsMorphModule;
       if (!ts)
         return;
-      if (ts.Node.isIdentifier(node) && node.getText() === symbol) {
-        return node;
-      }
-      return;
-    });
-    return found ?? null;
-  }
-  getNodeDocumentation(node) {
-    const ts = tsMorphModule;
-    if (!ts)
-      return;
-    const target = ts.Node.isIdentifier(node) ? node.getParent() : node;
-    if (!target)
-      return;
-    if ("getJsDocs" in target && typeof target.getJsDocs === "function") {
-      const jsDocs = target.getJsDocs();
-      if (jsDocs.length > 0) {
-        return jsDocs.map((d2) => d2.getDescription()).join(`
+      const target = ts.Node.isIdentifier(node) ? node.getParent() : node;
+      if (!target)
+        return;
+      if ("getJsDocs" in target && typeof target.getJsDocs === "function") {
+        const jsDocs = target.getJsDocs();
+        if (jsDocs.length > 0) {
+          return jsDocs.map((d2) => d2.getDescription()).join(`
 `);
+        }
       }
+      return;
     }
-    return;
-  }
-  detectLang(file) {
-    const dot = file.lastIndexOf(".");
-    if (dot === -1)
+    detectLang(file) {
+      const dot = file.lastIndexOf(".");
+      if (dot === -1)
+        return "unknown";
+      const ext = file.slice(dot);
+      if ([".ts", ".tsx", ".mts", ".cts"].includes(ext))
+        return "typescript";
+      if ([".js", ".jsx", ".mjs", ".cjs"].includes(ext))
+        return "javascript";
       return "unknown";
-    const ext = file.slice(dot);
-    if ([".ts", ".tsx", ".mts", ".cts"].includes(ext))
-      return "typescript";
-    if ([".js", ".jsx", ".mjs", ".cjs"].includes(ext))
-      return "javascript";
-    return "unknown";
-  }
-}
-var tsMorphModule = null;
-var init_ts_morph = () => {};
+    }
+    listInheritedMembers(sf, target, name2, ts) {
+      if (!name2.includes("."))
+        return [];
+      if (target !== "method" && target !== "property")
+        return [];
+      const [ownerName] = name2.split(".");
+      if (!ownerName)
+        return [];
+      const out2 = [];
+      const seen = new Set;
+      const push = (kind, owner, memberName) => {
+        const key2 = `${kind}:${owner}.${memberName}`;
+        if (seen.has(key2))
+          return;
+        seen.add(key2);
+        out2.push(`${kind} "${owner}.${memberName}" (inherited from ${owner})`);
+      };
+      const cls = sf.getClass(ownerName);
+      if (cls) {
+        let base = cls.getBaseClass();
+        while (base) {
+          const baseName = base.getName() ?? "anonymous";
+          if (target === "method") {
+            for (const m3 of base.getMethods())
+              push("method", baseName, m3.getName());
+          }
+          if (target === "property") {
+            for (const p2 of base.getProperties())
+              push("property", baseName, p2.getName());
+          }
+          base = base.getBaseClass();
+        }
+        for (const impl of cls.getImplements()) {
+          const exprText = impl.getExpression().getText();
+          const iface2 = sf.getInterface(exprText);
+          if (!iface2)
+            continue;
+          if (target === "method") {
+            for (const m3 of iface2.getMethods())
+              push("method", iface2.getName(), m3.getName());
+          }
+          if (target === "property") {
+            for (const p2 of iface2.getProperties())
+              push("property", iface2.getName(), p2.getName());
+          }
+        }
+        return out2;
+      }
+      const iface = sf.getInterface(ownerName);
+      if (iface) {
+        for (const ext of iface.getBaseDeclarations()) {
+          if (!ts.Node.isInterfaceDeclaration(ext))
+            continue;
+          const extName = ext.getName();
+          if (target === "method") {
+            for (const m3 of ext.getMethods())
+              push("method", extName, m3.getName());
+          }
+          if (target === "property") {
+            for (const p2 of ext.getProperties())
+              push("property", extName, p2.getName());
+          }
+        }
+      }
+      return out2;
+    }
+  };
+});
 
 // src/core/intelligence/backends/regex.ts
 var exports_regex = {};
@@ -278991,10 +280664,17 @@ async function ensureHighlighter() {
   } = await Promise.resolve().then(() => (init_dist7(), exports_dist2));
   highlighter = await createHighlighter2({
     themes: ["catppuccin-mocha"],
-    langs: [...SHIKI_LANGS]
+    langs: []
   });
   return highlighter;
 }
+async function loadLanguage(hl, lang254) {
+  if (hl.getLoadedLanguages().includes(lang254))
+    return;
+  try {
+    await hl.loadLanguage(lang254);
+  } catch {}
+}
 function requireRepoMap() {
   if (!repoMap)
     throw new Error("RepoMap not initialized \u2014 send init first");
@@ -279214,6 +280894,8 @@ var handlers = {
   codeToAnsi: async (code, lang254) => {
     const hl = await ensureHighlighter();
     const normalized = lang254 ? normalizeLang(lang254) : "text";
+    if (normalized !== "text")
+      await loadLanguage(hl, normalized);
     const langId = hl.getLoadedLanguages().includes(normalized) ? normalized : "text";
     try {
       const RST = "\x1B[0m";
@@ -279246,6 +280928,8 @@ var handlers = {
   codeToStyledTokens: async (code, lang254) => {
     const hl = await ensureHighlighter();
     const normalized = lang254 ? normalizeLang(lang254) : "text";
+    if (normalized !== "text")
+      await loadLanguage(hl, normalized);
     const langId = hl.getLoadedLanguages().includes(normalized) ? normalized : "text";
     try {
       const result = hl.codeToTokens(code, {
@@ -279264,9 +280948,8 @@ var handlers = {
     }
   },
   isShikiLanguage: async (lang254) => {
-    const hl = await ensureHighlighter();
     const normalized = normalizeLang(lang254);
-    return hl.getLoadedLanguages().includes(normalized);
+    return SHIKI_LANGS.includes(normalized);
   }
 };
 ctx = createWorkerHandler(handlers, async (config) => {