weavatrix 0.3.14 → 1.0.0

package/src/mcp-source-tools.mjs

@@ -1,163 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { extname, isAbsolute, join, relative, resolve } from 'node:path'
-import { resolveRepoPath } from './repo-path.js'
-import { runCommandSync } from './process.js'
-import { toolResult } from './mcp/tool-result.mjs'
-
-const SEARCH_SKIP = new Set(['.git', 'node_modules', 'dist', 'build', 'out', '.next', 'coverage', 'vendor', '.venv', 'venv', 'env', 'target', '__pycache__', '.idea', '.vscode', '.cache', 'bin', 'obj', 'weavatrix-graphs'])
-const BINARY_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.pdf', '.zip', '.gz', '.tar', '.exe', '.dll', '.so', '.dylib', '.woff', '.woff2', '.ttf', '.eot', '.mp4', '.mp3', '.wasm', '.class', '.jar', '.node', '.bin'])
-const MAX_SEARCH_FILE_BYTES = 1024 * 1024
-const MAX_SOURCE_FILE_BYTES = 2 * 1024 * 1024
-const MAX_SOURCE_CONTEXT_LINES = 1000
-
-function rgSearch(repoRoot, resolveRg, query, { isRegex, glob, maxResults }, spawnRg = runCommandSync) {
-    const rg = resolveRg()
-    if (!rg) return null
-    // Exclude node_modules explicitly: --hidden + the default gitignore stack is the only thing that
-    // keeps a dependency tree out, which fails for repos that commit node_modules or lack a gitignore.
-    // A caller-supplied glob is appended after this and still wins (rg: last matching glob decides).
-    const args = ['--line-number', '--no-heading', '--color', 'never', '--hidden', '-g', '!.git/**', '-g', '!node_modules', '-m', '100', '-i']
-    if (!isRegex) args.push('--fixed-strings')
-    if (glob) args.push('-g', glob)
-    // Run from the repository root and search `.` so path globs such as `src/**` are evaluated
-    // against repository-relative paths on Windows too. Passing an absolute search root makes rg
-    // compare the glob with a drive-prefixed path and silently return no matches.
-    args.push('--', query, '.')
-    const res = spawnRg(rg, args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: 15000 })
-    if (res.status !== 0 && res.status !== 1) return null
-    const out = []
-    for (const line of (res.stdout || '').split(/\r?\n/)) {
-        const match = line.match(/^(.*?):(\d+):(.*)$/)
-        if (!match) continue
-        out.push({
-            file: relative(repoRoot, isAbsolute(match[1]) ? match[1] : resolve(repoRoot, match[1])).replace(/\\/g, '/'),
-            line: Number(match[2]),
-            text: match[3].trim().slice(0, 300),
-        })
-        if (out.length >= maxResults) break
-    }
-    return out
-}
-
-function globToRe(glob) {
-    if (!glob) return null
-    try {
-        return new RegExp(glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.'), 'i')
-    } catch {
-        return null
-    }
-}
-
-function nodeGrep(repoRoot, query, { isRegex, glob, maxResults }) {
-    const out = []
-    let re = null
-    if (isRegex) {
-        try { re = new RegExp(query, 'i') } catch { return out }
-    }
-    const q = String(query).toLowerCase()
-    const globRe = globToRe(glob)
-    const stack = [repoRoot]
-    let filesScanned = 0
-    while (stack.length && out.length < maxResults) {
-        const dir = stack.pop()
-        let entries
-        try { entries = readdirSync(dir, { withFileTypes: true }) } catch { continue }
-        for (const ent of entries) {
-            if (out.length >= maxResults) break
-            const full = join(dir, ent.name)
-            if (ent.isDirectory()) {
-                if (!SEARCH_SKIP.has(ent.name)) stack.push(full)
-                continue
-            }
-            if (!ent.isFile() || BINARY_EXT.has(extname(ent.name).toLowerCase())) continue
-            const rel = relative(repoRoot, full).replace(/\\/g, '/')
-            if (globRe && !globRe.test(rel)) continue
-            let st
-            try { st = statSync(full) } catch { continue }
-            if (st.size > MAX_SEARCH_FILE_BYTES) continue
-            if (++filesScanned > 20000) return out
-            let text
-            try { text = readFileSync(full, 'utf8') } catch { continue }
-            if (text.indexOf('\0') >= 0) continue
-            const lines = text.split(/\r?\n/)
-            for (let i = 0; i < lines.length; i++) {
-                const ln = lines[i]
-                if (re ? re.test(ln) : ln.toLowerCase().includes(q)) {
-                    out.push({ file: rel, line: i + 1, text: ln.trim().slice(0, 300) })
-                    if (out.length >= maxResults) break
-                }
-            }
-        }
-    }
-    return out
-}
-
-export function searchCode({ repoRoot, resolveRg, spawnRg = runCommandSync }, { query, is_regex = false, max_results = 40, glob } = {}) {
-    if (!query) return 'Provide a "query" string.'
-    if (!repoRoot || !existsSync(repoRoot)) return 'Source search unavailable: repo root not provided to this MCP server.'
-    const max = Math.max(1, Math.min(200, Number(max_results) || 40))
-    const opts = { isRegex: !!is_regex, glob: glob || null, maxResults: max }
-    let matches = rgSearch(repoRoot, resolveRg, query, opts, spawnRg)
-    const engine = matches ? 'ripgrep' : 'node'
-    if (!matches) matches = nodeGrep(repoRoot, query, opts)
-    const what = is_regex ? `/${query}/i` : `"${query}"`
-    if (!matches.length) return toolResult(
-        `No matches for ${what}${glob ? ` in ${glob}` : ''}.`,
-        {query, isRegex: !!is_regex, glob: glob || null, engine, matches: []},
-        {completeness: {status: 'complete', reason: 'search completed with no matches'}},
-    )
-    const text = [
-        `${matches.length} match${matches.length === 1 ? '' : 'es'} for ${what}${glob ? ` (glob ${glob})` : ''} [${engine}]:`,
-        ...matches.map((m) => `  ${m.file}:${m.line}:  ${m.text}`),
-    ].join('\n')
-    return toolResult(text, {query, isRegex: !!is_regex, glob: glob || null, engine, matches}, {
-        completeness: {status: matches.length >= max ? 'bounded' : 'complete', limit: max},
-    })
-}
-
-export function readSource({ repoRoot, resolveNode, isSymbol }, g, { label, path, start_line, before = 3, after = 40 } = {}) {
-    if (!repoRoot || !existsSync(repoRoot)) return 'Source read unavailable: repo root not provided to this MCP server.'
-    let file = null
-    let focusLine = null
-    let title
-    // label resolves first; a path alongside it narrows rather than overrides — the node's focus line
-    // survives when both point at the same file (label+path used to silently return the file head).
-    const n = label && g ? resolveNode(g, label) : null
-    if (n) {
-        const nodeFile = String(n.source_file || (isSymbol(n.id) ? String(n.id).split('#')[0] : n.id))
-        if (!path || nodeFile.replace(/\\/g, '/') === String(path).replace(/\\/g, '/')) {
-            file = nodeFile
-            const match = String(n.source_location || '').match(/L(\d+)/)
-            focusLine = match ? Number(match[1]) : null
-            title = `${n.label ?? n.id}  [${n.id}]`
-        }
-    }
-    if (!file) {
-        if (!path) return label ? `No node found matching "${label}".` : 'Provide "label" or "path".'
-        file = String(path)
-        title = file
-    }
-    // explicit anchor wins: window = start_line-before .. start_line+after (how a path read escapes the file head)
-    if (start_line != null && Number(start_line) > 0) focusLine = Math.floor(Number(start_line))
-    const resolved = resolveRepoPath(repoRoot, file)
-    if (resolved.reason === 'escape') return `Refusing to read "${file}": path escapes the repository root.`
-    if (resolved.reason === 'not-found') return `File not found: ${file}`
-    if (!resolved.ok) return `Could not resolve ${file} inside the repository root.`
-    const abs = resolved.path
-    let st
-    try { st = statSync(abs) } catch (e) { return `Could not inspect ${file}: ${e.message}` }
-    if (!st.isFile()) return `Could not read ${file}: not a regular file.`
-    if (st.size > MAX_SOURCE_FILE_BYTES) return `Could not read ${file}: file exceeds the ${MAX_SOURCE_FILE_BYTES / 1024 / 1024} MB source-read limit.`
-    let text
-    try { text = readFileSync(abs, 'utf8') } catch (e) { return `Could not read ${file}: ${e.message}` }
-    const lines = text.split(/\r?\n/)
-    if (focusLine) focusLine = Math.min(focusLine, lines.length) // an anchor past EOF shows the tail, not nothing
-    const b = Math.min(MAX_SOURCE_CONTEXT_LINES, Math.max(0, Number(before) || 0))
-    const a = Math.min(MAX_SOURCE_CONTEXT_LINES, Math.max(1, Number(after) || 40))
-    const start = focusLine ? Math.max(1, focusLine - b) : 1
-    const end = focusLine ? Math.min(lines.length, focusLine + a) : Math.min(lines.length, 1 + b + a)
-    const width = String(end).length
-    const body = []
-    for (let i = start; i <= end; i++) body.push(`${focusLine === i ? '>' : ' '}${String(i).padStart(width)}  ${lines[i - 1] ?? ''}`)
-    return [`Source: ${title}`, `${file}  (lines ${start}-${end} of ${lines.length})`, '', ...body].join('\n')
-}

package/src/path-classification.js

@@ -1,226 +0,0 @@
-// Repository-semantic path classification. Unlike `.weavatrixignore`, this layer never removes a
-// file from the graph: it labels non-product surfaces so health/clone/test-reachability tools can
-// suppress noise while still explaining the exact rule that matched.
-import { openSync, closeSync, readSync, readFileSync, statSync } from "node:fs";
-import { createRepoBoundary } from "./repo-path.js";
-
-export const PATH_CLASS_NAMES = Object.freeze(["test", "e2e", "generated", "vendored", "mock", "story", "docs", "benchmark", "temp"]);
-export const PATH_CLASS_QUERY_TERMS = Object.freeze({
-  test: Object.freeze(["test", "tests", "testing", "unit"]),
-  e2e: Object.freeze(["e2e", "playwright", "cypress"]),
-  generated: Object.freeze(["generated", "autogenerated", "dist"]),
-  vendored: Object.freeze(["vendor", "vendored", "third-party", "third_party"]),
-  mock: Object.freeze(["mock", "mocks", "fixture", "fixtures", "fake"]),
-  story: Object.freeze(["story", "stories", "storybook"]),
-  docs: Object.freeze(["doc", "docs", "documentation", "readme", "guide"]),
-  benchmark: Object.freeze(["benchmark", "benchmarks", "bench"]),
-  temp: Object.freeze(["temp", "temporary", "tmp"]),
-});
-export const PATH_CLASS_TASK_QUERY_TERMS = Object.freeze({
-  ...PATH_CLASS_QUERY_TERMS,
-  test: Object.freeze([...PATH_CLASS_QUERY_TERMS.test, "spec", "coverage", "verify"]),
-});
-const PATH_CLASS_SET = new Set(PATH_CLASS_NAMES);
-const MAX_CONFIG_BYTES = 64 * 1024;
-const MAX_RULES_PER_CLASS = 64;
-const MAX_RULE_LENGTH = 256;
-const HEADER_BYTES = 8192;
-
-const normalizePath = (value) => String(value || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-const escapeRegex = (value) => value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-
-function compileGlob(input) {
-  let pattern = String(input || "").trim().replace(/\\/g, "/");
-  if (!pattern || pattern.length > MAX_RULE_LENGTH || pattern.includes("\0") || pattern.split("/").includes("..")) return null;
-  const anchored = pattern.startsWith("/");
-  const directory = pattern.endsWith("/");
-  pattern = pattern.replace(/^\/+|\/+$/g, "");
-  if (!pattern) return null;
-  let body = "";
-  for (let index = 0; index < pattern.length; index += 1) {
-    const char = pattern[index];
-    if (char === "*" && pattern[index + 1] === "*") {
-      const slash = pattern[index + 2] === "/";
-      body += slash ? "(?:.*/)?" : ".*";
-      index += slash ? 2 : 1;
-    } else if (char === "*") body += "[^/]*";
-    else if (char === "?") body += "[^/]";
-    else body += escapeRegex(char);
-  }
-  const prefix = anchored ? "^" : "(?:^|/)";
-  const suffix = directory ? "(?:/.*)?$" : "$";
-  return new RegExp(`${prefix}${body}${suffix}`, "i");
-}
-
-const DEFAULT_RULES = [
-  {
-    category: "e2e",
-    pattern: "test-e2e, e2e, Cypress, Playwright or acceptance/integration test roots",
-    regex: /(^|\/)(?:test-e2e|e2e|cypress|playwright|tests?[-_](?:e2e|integration|acceptance)|(?:e2e|integration|acceptance)[-_]tests?)(\/|$)|\.(?:e2e|cy)\.[^.\/]+$/i,
-  },
-  {
-    category: "test",
-    pattern: "test/spec roots and conventional test filenames",
-    regex: /(^|\/)(?:__tests?__|tests?|spec)(\/|$)|\.(?:test|itest|spec)\.[^.\/]+$|_test\.go$|(^|\/)test(?:_[^/]*)?\.py$/i,
-  },
-  {
-    category: "generated",
-    pattern: "generated/OpenAPI output path",
-    regex: /(^|\/)(?:generated|gen|openapi[-_]?generated|generated[-_]?client|api[-_]?client[-_]?generated)(\/|$)/i,
-  },
-  {
-    category: "generated",
-    pattern: "conventional build output path",
-    regex: /(^|\/)(?:dist|build|out|coverage|\.next)(\/|$)/i,
-  },
-  {
-    category: "vendored",
-    pattern: "vendored or third-party source root",
-    regex: /(^|\/)(?:vendor|vendored|third[-_]?party)(\/|$)/i,
-  },
-  {
-    category: "mock",
-    pattern: "mock/fixture path or mockData filename",
-    regex: /(^|\/)(?:__mocks__|mocks?|fixtures?|__fixtures__)(\/|$)|(^|\/)(?:mock[-_.]?data|test[-_.]?data|fake[-_.]?data)\.[^.\/]+$/i,
-  },
-  {
-    category: "story",
-    pattern: "Storybook story",
-    regex: /(^|\/)\.storybook(\/|$)|\.stories?\.[^.\/]+$/i,
-  },
-  {
-    category: "docs",
-    pattern: "documentation path or prose file",
-    regex: /(^|\/)(?:docs?|documentation)(\/|$)|\.(?:md|markdown|mdx|rst|adoc)$/i,
-  },
-  {
-    category: "benchmark",
-    pattern: "benchmark/benchmarks root",
-    regex: /(^|\/)benchmarks?(\/|$)/i,
-  },
-  {
-    category: "temp",
-    pattern: "__temp or .tmp-* working/generated root",
-    regex: /(^|\/)(?:__temp|\.tmp(?:[-_][^/]*)?)(\/|$)/i,
-  },
-];
-
-const GENERATED_HEADER_RE = /(?:@generated\b|auto[- ]generated\b|generated\s+(?:code|file|client).*do not edit|do not edit.*generated|openapi generator)/i;
-
-function boundedHeader(repoRoot, path) {
-  if (!repoRoot || !path) return "";
-  const resolved = createRepoBoundary(repoRoot).resolve(path);
-  if (!resolved.ok) return "";
-  let fd;
-  try {
-    fd = openSync(resolved.path, "r");
-    const buf = Buffer.alloc(HEADER_BYTES);
-    const count = readSync(fd, buf, 0, buf.length, 0);
-    return buf.subarray(0, count).toString("utf8");
-  } catch { return ""; }
-  finally { if (fd != null) try { closeSync(fd); } catch { /* already closed */ } }
-}
-
-export function loadPathClassificationConfig(repoRoot) {
-  if (!repoRoot) return { classify: {}, exclude: [], loaded: false };
-  const resolved = createRepoBoundary(repoRoot).resolve(".weavatrix.json");
-  if (!resolved.ok) return { classify: {}, exclude: [], loaded: false };
-  try {
-    if (statSync(resolved.path).size > MAX_CONFIG_BYTES) return { classify: {}, exclude: [], loaded: false, error: "config-too-large" };
-    const raw = JSON.parse(readFileSync(resolved.path, "utf8"));
-    const classify = {};
-    for (const category of PATH_CLASS_NAMES) {
-      const value = raw?.classify?.[category];
-      const patterns = (Array.isArray(value) ? value : typeof value === "string" ? [value] : [])
-        .slice(0, MAX_RULES_PER_CLASS)
-        .map((pattern) => String(pattern));
-      if (patterns.length) classify[category] = patterns;
-    }
-    // Explicit product opt-in removes only the default benchmark/temp classification. It does not
-    // override configured generated/test classes or a deliberate top-level exclude rule.
-    const productValue = raw?.classify?.product;
-    const productPatterns = (Array.isArray(productValue) ? productValue : typeof productValue === "string" ? [productValue] : [])
-      .slice(0, MAX_RULES_PER_CLASS)
-      .map((pattern) => String(pattern));
-    if (productPatterns.length) classify.product = productPatterns;
-    const exclude = (Array.isArray(raw?.exclude) ? raw.exclude : typeof raw?.exclude === "string" ? [raw.exclude] : [])
-      .slice(0, MAX_RULES_PER_CLASS)
-      .map((pattern) => String(pattern));
-    return { classify, exclude, loaded: true };
-  } catch { return { classify: {}, exclude: [], loaded: false, error: "invalid-config" }; }
-}
-
-function configuredRules(config) {
-  const rules = [];
-  for (const category of PATH_CLASS_NAMES) {
-    for (const pattern of config.classify?.[category] || []) {
-      const regex = compileGlob(pattern);
-      if (regex) rules.push({ category, pattern, regex, source: "config" });
-    }
-  }
-  const excludes = [];
-  for (const pattern of config.exclude || []) {
-    const regex = compileGlob(pattern);
-    if (regex) excludes.push({ pattern, regex, source: "config" });
-  }
-  const productRules = [];
-  for (const pattern of config.classify?.product || []) {
-    const regex = compileGlob(pattern);
-    if (regex) productRules.push({ category: "product", pattern, regex, source: "config" });
-  }
-  return { rules, excludes, productRules };
-}
-
-export function createPathClassifier(repoRoot) {
-  const config = loadPathClassificationConfig(repoRoot);
-  const compiled = configuredRules(config);
-  return {
-    config,
-    explain(path, options = {}) {
-      const normalized = normalizePath(path);
-      const matches = [];
-      const classes = new Set();
-      const productMatches = compiled.productRules
-        .filter((rule) => rule.regex.test(normalized))
-        .map((rule) => ({ category: "product", source: rule.source, pattern: rule.pattern }));
-      matches.push(...productMatches);
-      const productOverride = productMatches.length > 0;
-      const add = (rule) => {
-        classes.add(rule.category);
-        if (rule.category === "e2e") classes.add("test");
-        matches.push({ category: rule.category, source: rule.source || "default", pattern: rule.pattern });
-      };
-      for (const rule of compiled.rules) if (rule.regex.test(normalized)) add(rule);
-      for (const rule of DEFAULT_RULES) {
-        if (productOverride && (rule.category === "benchmark" || rule.category === "temp")) continue;
-        if (rule.regex.test(normalized)) add({ ...rule, source: "default" });
-      }
-      const header = options.content == null ? boundedHeader(repoRoot, normalized) : String(options.content).slice(0, HEADER_BYTES);
-      if (GENERATED_HEADER_RE.test(header) && !classes.has("generated")) {
-        add({ category: "generated", source: "default", pattern: "generated-file header" });
-      }
-      const excludeMatches = compiled.excludes
-        .filter((rule) => rule.regex.test(normalized))
-        .map((rule) => ({ category: "exclude", source: rule.source, pattern: rule.pattern }));
-      matches.push(...excludeMatches);
-      const orderedClasses = PATH_CLASS_NAMES.filter((category) => classes.has(category));
-      return {
-        path: normalized,
-        classes: orderedClasses,
-        excluded: excludeMatches.length > 0,
-        productOverride,
-        matchedRule: matches[0] || null,
-        matchedRules: matches,
-      };
-    },
-  };
-}
-
-export function explainPathClassification(repoRoot, path, options = {}) {
-  return createPathClassifier(repoRoot).explain(path, options);
-}
-
-export function hasPathClass(explanation, ...categories) {
-  const present = new Set(explanation?.classes || []);
-  return categories.some((category) => PATH_CLASS_SET.has(category) && present.has(category));
-}

package/src/path-ignore.js

@@ -1,69 +0,0 @@
-// Repository-local exclusions shared by graph building, audits and clone scanning.
-// `.weavatrixignore` follows the useful Gitignore subset: comments, *, **, ?, root-anchored
-// patterns, directory suffixes and ordered ! re-includes. It never expands paths or reads outside root.
-import { readFileSync } from "node:fs";
-import { isAbsolute, relative } from "node:path";
-import { createRepoBoundary } from "./repo-path.js";
-
-function escapeRegex(value) {
-  return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-}
-
-function globRegex(pattern) {
-  let out = "";
-  for (let index = 0; index < pattern.length; index += 1) {
-    const char = pattern[index];
-    if (char === "*" && pattern[index + 1] === "*") {
-      const slash = pattern[index + 2] === "/";
-      out += slash ? "(?:.*/)?" : ".*";
-      index += slash ? 2 : 1;
-    } else if (char === "*") out += "[^/]*";
-    else if (char === "?") out += "[^/]";
-    else out += escapeRegex(char);
-  }
-  return out;
-}
-
-export function parseWeavatrixIgnore(text) {
-  const rules = [];
-  for (const rawLine of String(text || "").split(/\r?\n/)) {
-    let line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const negated = line.startsWith("!");
-    if (negated) line = line.slice(1);
-    line = line.replace(/\\/g, "/");
-    const anchored = line.startsWith("/");
-    const directory = line.endsWith("/");
-    line = line.replace(/^\/+|\/+$/g, "");
-    if (!line || line.split("/").some((part) => part === "..")) continue;
-    const prefix = anchored ? "^" : "(?:^|/)";
-    const suffix = directory ? "(?:/.*)?$" : "$";
-    rules.push({ negated, regex: new RegExp(`${prefix}${globRegex(line)}${suffix}`) });
-  }
-  return rules;
-}
-
-export function loadWeavatrixIgnore(repoRoot) {
-  try {
-    const resolved = createRepoBoundary(repoRoot).resolve(".weavatrixignore");
-    if (!resolved.ok) return [];
-    return parseWeavatrixIgnore(readFileSync(resolved.path, "utf8"));
-  }
-  catch { return []; }
-}
-
-export function isWeavatrixIgnored(path, rules) {
-  const normalized = String(path || "").replace(/\\/g, "/").replace(/^\.\//, "");
-  let ignored = false;
-  for (const rule of rules || []) if (rule.regex.test(normalized)) ignored = !rule.negated;
-  return ignored;
-}
-
-export function filterWeavatrixIgnored(repoRoot, files) {
-  const rules = loadWeavatrixIgnore(repoRoot);
-  if (!rules.length) return files;
-  return files.filter((file) => {
-    const path = isAbsolute(file) ? relative(repoRoot, file) : file;
-    return !isWeavatrixIgnored(path, rules);
-  });
-}

package/src/precision/lsp-client/constants.js

@@ -1,12 +0,0 @@
-export const DEFAULT_MAX_MESSAGE_BYTES = 8 * 1024 * 1024
-export const DEFAULT_MAX_HEADER_BYTES = 16 * 1024
-export const DEFAULT_REQUEST_TIMEOUT_MS = 10_000
-export const JSON_RPC_VERSION = '2.0'
-
-export function positiveInteger(value, fallback, label) {
-    const candidate = value == null ? fallback : Number(value)
-    if (!Number.isSafeInteger(candidate) || candidate <= 0) {
-        throw new TypeError(`${label} must be a positive integer`)
-    }
-    return candidate
-}

package/src/precision/lsp-client/environment.js

@@ -1,20 +0,0 @@
-import {delimiter, dirname, join} from 'node:path'
-import {childProcessEnv} from '../../child-env.js'
-
-const LSP_ENV_ALLOWLIST = new Set([
-    'path', 'pathext', 'systemroot', 'windir', 'comspec',
-    'temp', 'tmp', 'tmpdir', 'home', 'userprofile', 'localappdata', 'appdata',
-    'lang', 'language', 'lc_all', 'lc_ctype',
-])
-
-export function lspChildProcessEnv(overrides = {}) {
-    const inherited = childProcessEnv(overrides)
-    const clean = Object.fromEntries(
-        Object.entries(inherited).filter(([key]) => LSP_ENV_ALLOWLIST.has(key.toLowerCase())),
-    )
-    const safePath = [dirname(process.execPath)]
-    const systemRoot = inherited.SystemRoot || inherited.SYSTEMROOT || inherited.WINDIR
-    if (process.platform === 'win32' && systemRoot) safePath.push(join(systemRoot, 'System32'))
-    clean.PATH = [...new Set(safePath)].join(delimiter)
-    return clean
-}

package/src/precision/lsp-client/errors.js

@@ -1,15 +0,0 @@
-export class LspProtocolError extends Error {
-    constructor(message, options) {
-        super(message, options)
-        this.name = 'LspProtocolError'
-    }
-}
-
-export class LspTimeoutError extends Error {
-    constructor(method, timeoutMs) {
-        super(`LSP request timed out after ${timeoutMs}ms: ${method}`)
-        this.name = 'LspTimeoutError'
-        this.method = method
-        this.timeoutMs = timeoutMs
-    }
-}

package/src/precision/lsp-client/lifecycle.js

@@ -1,114 +0,0 @@
-import {spawn as spawnChild} from 'node:child_process'
-import {positiveInteger} from './constants.js'
-import {lspChildProcessEnv} from './environment.js'
-import {LspTimeoutError} from './errors.js'
-import {isLspClientActive} from './registry.js'
-import {notifyClient, rejectPendingRequests, requestFromClient} from './protocol.js'
-
-export function failClient(client, error) {
-    if (client.state === 'closed' || client.state === 'failed') return
-    client.state = 'failed'
-    rejectPendingRequests(client, error)
-    killClient(client, error)
-}
-
-export function killClient(client, reason = new Error('LSP client was killed')) {
-    if (client.state !== 'closed') client.state = 'closed'
-    rejectPendingRequests(client, reason)
-    client.openDocuments.clear()
-    try { client.child.stdin?.destroy() } catch { /* already closed */ }
-    if (process.platform !== 'win32' && client.processGroupPid) {
-        try {
-            process.kill(-client.processGroupPid, 'SIGKILL')
-            return
-        } catch { /* fall through to direct child */ }
-    }
-    if (client.child.exitCode != null || client.child.signalCode != null) return
-    if (process.platform === 'win32' && client.child.pid) {
-        startWindowsTreeKill(client)
-    } else {
-        try { client.child.kill('SIGKILL') } catch { /* already exited */ }
-    }
-}
-
-function directChildKill(client) {
-    try { client.child.kill('SIGKILL') } catch { /* already exited */ }
-}
-
-function startWindowsTreeKill(client) {
-    if (client.windowsTreeKillPromise) return client.windowsTreeKillPromise
-    client.windowsTreeKillPromise = new Promise((resolveKill) => {
-        try {
-            const killer = spawnChild('taskkill', ['/pid', String(client.child.pid), '/T', '/F'], {
-                shell: false,
-                windowsHide: true,
-                env: lspChildProcessEnv(),
-                stdio: 'ignore',
-            })
-            killer.once('error', () => { directChildKill(client); resolveKill() })
-            killer.once('exit', (code) => { if (code !== 0) directChildKill(client); resolveKill() })
-        } catch {
-            directChildKill(client)
-            resolveKill()
-        }
-    })
-    return client.windowsTreeKillPromise
-}
-
-export async function killWindowsTreeAndWait(client, timeoutMs = 3_000) {
-    if (process.platform !== 'win32' || !client.child.pid || client.child.exitCode != null) return
-    const boundedTimeout = Math.max(250, Math.min(5_000, Number(timeoutMs) || 3_000))
-    let timer
-    await Promise.race([
-        startWindowsTreeKill(client),
-        new Promise((resolveKill) => {
-            timer = setTimeout(() => { directChildKill(client); resolveKill() }, boundedTimeout)
-        }),
-    ])
-    if (timer) clearTimeout(timer)
-}
-
-export async function waitForClientExit(client, timeoutMs = client.requestTimeoutMs) {
-    if (!isLspClientActive(client)) return true
-    const boundedTimeout = Math.max(100, Math.min(10_000, Number(timeoutMs) || client.requestTimeoutMs))
-    let timer
-    const outcome = await Promise.race([
-        client.exited.then(() => true),
-        new Promise((resolveExit) => { timer = setTimeout(() => resolveExit(false), boundedTimeout) }),
-    ])
-    if (timer) clearTimeout(timer)
-    return outcome
-}
-
-export function shutdownClient(client, options = {}) {
-    if (!client.shutdownPromise) client.shutdownPromise = shutdownClientOnce(client, options)
-    return client.shutdownPromise
-}
-
-export async function shutdownClientOnce(client, {timeoutMs = client.requestTimeoutMs} = {}) {
-    const boundedTimeout = positiveInteger(timeoutMs, client.requestTimeoutMs, 'timeoutMs')
-    try {
-        if (client.state === 'starting') await client.spawned
-        if (client.state === 'closed') {
-            await waitForClientExit(client, boundedTimeout)
-            return
-        }
-        if (client.state === 'initialized') {
-            await requestFromClient(client, 'shutdown', null, {timeoutMs: boundedTimeout})
-        }
-        client.state = 'stopping'
-        await notifyClient(client, 'exit', null)
-        await killWindowsTreeAndWait(client, Math.min(3_000, boundedTimeout))
-        if (process.platform !== 'win32' && client.processGroupPid) {
-            await waitForClientExit(client, Math.min(1_000, boundedTimeout))
-            try { process.kill(-client.processGroupPid, 'SIGKILL') } catch { /* group already exited */ }
-        }
-        if (!await waitForClientExit(client, boundedTimeout)) {
-            killClient(client, new LspTimeoutError('exit', boundedTimeout))
-        }
-    } catch (error) {
-        killClient(client, error)
-        await killWindowsTreeAndWait(client, Math.min(2_000, boundedTimeout))
-        await waitForClientExit(client, Math.min(2_000, boundedTimeout))
-    }
-}