@ctxo/cli 0.14.0 → 0.15.0

package/dist/chunk-IT426P3F.js

@@ -0,0 +1,1036 @@
+#!/usr/bin/env node
+import {
+  SymbolGraph,
+  SymbolTokenizer
+} from "./chunk-I7RPXT6L.js";
+import {
+  DetailLevelSchema,
+  JsonIndexReader
+} from "./chunk-EC6INGPV.js";
+import {
+  createLogger
+} from "./chunk-5DSKZJNN.js";
+
+// src/core/search/fuzzy-corrector.ts
+var FuzzyCorrector = class {
+  /** term → frequency (for tie-breaking) */
+  vocabulary = /* @__PURE__ */ new Map();
+  buildVocabulary(termFrequencies) {
+    this.vocabulary = new Map(termFrequencies);
+  }
+  /**
+   * Attempt to correct query tokens.
+   * Returns null if no correction found or no improvement possible.
+   */
+  correct(queryTokens) {
+    if (this.vocabulary.size === 0) return null;
+    const corrections = [];
+    const correctedTokens = [];
+    let anyChanged = false;
+    for (const token of queryTokens) {
+      if (token.length <= 2) {
+        correctedTokens.push(token);
+        continue;
+      }
+      if (this.vocabulary.has(token)) {
+        correctedTokens.push(token);
+        continue;
+      }
+      const maxDist = token.length <= 5 ? 1 : 2;
+      const best = this.findClosest(token, maxDist);
+      if (best) {
+        corrections.push({
+          original: token,
+          corrected: best.term,
+          distance: best.distance
+        });
+        correctedTokens.push(best.term);
+        anyChanged = true;
+      } else {
+        correctedTokens.push(token);
+      }
+    }
+    if (!anyChanged) return null;
+    return {
+      originalQuery: queryTokens.join(" "),
+      correctedQuery: correctedTokens.join(" "),
+      corrections
+    };
+  }
+  /**
+   * Find the closest vocabulary term within maxDistance.
+   * Tie-breaks by frequency (higher = preferred).
+   */
+  findClosest(token, maxDistance) {
+    let bestTerm = null;
+    let bestDist = maxDistance + 1;
+    let bestFreq = -1;
+    for (const [vocabTerm, freq] of this.vocabulary) {
+      if (Math.abs(vocabTerm.length - token.length) > maxDistance) continue;
+      const dist = damerauLevenshtein(token, vocabTerm);
+      if (dist <= maxDistance) {
+        if (dist < bestDist || dist === bestDist && freq > bestFreq) {
+          bestTerm = vocabTerm;
+          bestDist = dist;
+          bestFreq = freq;
+        }
+      }
+    }
+    return bestTerm !== null ? { term: bestTerm, distance: bestDist } : null;
+  }
+};
+function damerauLevenshtein(a, b) {
+  const lenA = a.length;
+  const lenB = b.length;
+  if (lenA === 0) return lenB;
+  if (lenB === 0) return lenA;
+  const d = Array.from({ length: lenA + 1 }, () => new Array(lenB + 1).fill(0));
+  for (let i = 0; i <= lenA; i++) d[i][0] = i;
+  for (let j = 0; j <= lenB; j++) d[0][j] = j;
+  for (let i = 1; i <= lenA; i++) {
+    for (let j = 1; j <= lenB; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1,
+        // deletion
+        d[i][j - 1] + 1,
+        // insertion
+        d[i - 1][j - 1] + cost
+        // substitution
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
+      }
+    }
+  }
+  return d[lenA][lenB];
+}
+
+// src/core/search/search-engine.ts
+var log = createLogger("ctxo:search");
+var DEFAULT_CONFIG = {
+  bm25: { k1: 1.2, b: 0.25 },
+  pageRankWeight: 0.5,
+  trigramPenalty: 0.8,
+  phase2Threshold: 3,
+  fuzzyThreshold: 3,
+  maxPerPhase: 50
+};
+var DOCUMENT_SEARCH_CONFIG = Object.freeze({
+  bm25: Object.freeze({ k1: 1.2, b: 0.75 }),
+  pageRankWeight: 0
+});
+var SearchEngine = class {
+  config;
+  tokenizer;
+  fuzzy;
+  // Primary index (exact + tokenized)
+  documents = [];
+  primaryIndex = /* @__PURE__ */ new Map();
+  avgDocLength = 0;
+  isDocumentIndex = false;
+  // Trigram index (character 3-grams)
+  trigramIndex = /* @__PURE__ */ new Map();
+  // PageRank scores
+  pageRankScores = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.tokenizer = new SymbolTokenizer({ includeOriginal: true, includeFilePath: true });
+    this.fuzzy = new FuzzyCorrector();
+  }
+  getTier() {
+    return "in-memory";
+  }
+  buildIndex(symbols, pageRankScores) {
+    const start = performance.now();
+    this.indexEntries(
+      symbols.map((sym) => {
+        const filePath = sym.symbolId.split("::")[0] ?? "";
+        return {
+          doc: {
+            symbolId: sym.symbolId,
+            name: sym.name,
+            kind: sym.kind,
+            filePath,
+            tokens: this.tokenizer.tokenize(sym.name, filePath),
+            length: 0
+          },
+          trigramText: sym.name.toLowerCase()
+        };
+      }),
+      pageRankScores ?? /* @__PURE__ */ new Map(),
+      false
+    );
+    const elapsed = performance.now() - start;
+    log.info(`Index built: ${symbols.length} symbols, ${this.primaryIndex.size} terms, ${this.trigramIndex.size} trigrams (${elapsed.toFixed(0)}ms)`);
+  }
+  /**
+   * Index documents instead of symbols: a hit carries the document `id` in `symbolId`, the `title` in `name`,
+   * `kind` and the `path` in `filePath`. The tokens are the title words, the path words and the text words
+   * (repeats kept); trigrams come from the lowercased title; there is no PageRank. A document index is
+   * rebuilt as a whole: `updateFile` does not apply to it.
+   */
+  buildDocumentIndex(documents) {
+    const start = performance.now();
+    this.indexEntries(
+      documents.map((document) => {
+        const tokens = [
+          ...this.tokenizer.tokenizeText(document.title),
+          ...SymbolTokenizer.tokenizeFilePath(document.path),
+          ...this.tokenizer.tokenizeText(document.text)
+        ];
+        return {
+          doc: {
+            symbolId: document.id,
+            name: document.title,
+            kind: document.kind,
+            filePath: document.path,
+            tokens,
+            length: 0
+          },
+          trigramText: document.title.toLowerCase()
+        };
+      }),
+      /* @__PURE__ */ new Map(),
+      true
+    );
+    const elapsed = performance.now() - start;
+    log.info(`Document index built: ${documents.length} documents, ${this.primaryIndex.size} terms, ${this.trigramIndex.size} trigrams (${elapsed.toFixed(0)}ms)`);
+  }
+  /** The indexing both `buildIndex` and `buildDocumentIndex` share: replaces the whole index. */
+  indexEntries(entries, pageRankScores, isDocumentIndex) {
+    this.isDocumentIndex = isDocumentIndex;
+    this.documents = [];
+    this.primaryIndex = /* @__PURE__ */ new Map();
+    this.trigramIndex = /* @__PURE__ */ new Map();
+    this.pageRankScores = pageRankScores;
+    let totalLength = 0;
+    const vocabFreq = /* @__PURE__ */ new Map();
+    for (const { doc, trigramText } of entries) {
+      const tokens = doc.tokens;
+      doc.length = tokens.length;
+      const docIndex = this.documents.length;
+      this.documents.push(doc);
+      totalLength += tokens.length;
+      const termFreqs = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        termFreqs.set(token, (termFreqs.get(token) ?? 0) + 1);
+        vocabFreq.set(token, (vocabFreq.get(token) ?? 0) + 1);
+      }
+      for (const [term, tf] of termFreqs) {
+        let postings = this.primaryIndex.get(term);
+        if (!postings) {
+          postings = [];
+          this.primaryIndex.set(term, postings);
+        }
+        postings.push({ docIndex, termFrequency: tf });
+      }
+      const trigrams = this.extractTrigrams(trigramText);
+      const trigramFreqs = /* @__PURE__ */ new Map();
+      for (const tri of trigrams) {
+        trigramFreqs.set(tri, (trigramFreqs.get(tri) ?? 0) + 1);
+      }
+      for (const [tri, tf] of trigramFreqs) {
+        let postings = this.trigramIndex.get(tri);
+        if (!postings) {
+          postings = [];
+          this.trigramIndex.set(tri, postings);
+        }
+        postings.push({ docIndex, termFrequency: tf });
+      }
+    }
+    this.avgDocLength = this.documents.length > 0 ? totalLength / this.documents.length : 1;
+    this.fuzzy.buildVocabulary(vocabFreq);
+  }
+  search(query, limit = 50) {
+    const start = performance.now();
+    const queryTokens = this.tokenizer.tokenizeQuery(query);
+    if (queryTokens.length === 0) {
+      return this.emptyResponse(query, start);
+    }
+    const metrics = {
+      porterHits: 0,
+      trigramHits: 0,
+      phase2Activated: false,
+      fuzzyApplied: false,
+      latencyMs: 0
+    };
+    const phase1Scores = this.bm25Search(queryTokens, this.primaryIndex);
+    metrics.porterHits = phase1Scores.size;
+    let allScores = phase1Scores;
+    if (phase1Scores.size < this.config.phase2Threshold) {
+      metrics.phase2Activated = true;
+      const queryLower = query.toLowerCase();
+      if (queryLower.length >= 3) {
+        const queryTrigrams = this.extractTrigrams(queryLower);
+        const phase2Scores = this.bm25Search(queryTrigrams, this.trigramIndex);
+        metrics.trigramHits = phase2Scores.size;
+        allScores = this.mergeScores(phase1Scores, phase2Scores, this.config.trigramPenalty);
+      }
+    }
+    let fuzzyCorrection;
+    if (allScores.size < this.config.fuzzyThreshold) {
+      const correction = this.fuzzy.correct(queryTokens);
+      if (correction) {
+        metrics.fuzzyApplied = true;
+        fuzzyCorrection = correction;
+        const correctedTokens = this.tokenizer.tokenizeQuery(correction.correctedQuery);
+        const fuzzyScores = this.bm25Search(correctedTokens, this.primaryIndex);
+        allScores = this.mergeScores(allScores, fuzzyScores, 0.9);
+        if (allScores.size < this.config.fuzzyThreshold && correction.correctedQuery.length >= 3) {
+          const correctedTrigrams = this.extractTrigrams(correction.correctedQuery.toLowerCase());
+          const fuzzyTrigramScores = this.bm25Search(correctedTrigrams, this.trigramIndex);
+          allScores = this.mergeScores(allScores, fuzzyTrigramScores, this.config.trigramPenalty * 0.9);
+        }
+      }
+    }
+    const rawRelevance = new Map(allScores);
+    const effectiveQueryTerms = fuzzyCorrection ? this.tokenizer.tokenizeQuery(fuzzyCorrection.correctedQuery) : queryTokens;
+    if (effectiveQueryTerms.length >= 2) {
+      for (const [docIdx, score] of allScores) {
+        const doc = this.documents[docIdx];
+        const boost = this.bigramBoost(effectiveQueryTerms, doc.tokens);
+        allScores.set(docIdx, score * boost);
+      }
+    }
+    for (const [docIdx, score] of allScores) {
+      const doc = this.documents[docIdx];
+      const pr = this.pageRankScores.get(doc.symbolId) ?? 0;
+      allScores.set(docIdx, score * (1 + this.config.pageRankWeight * pr));
+    }
+    metrics.latencyMs = performance.now() - start;
+    const results = this.buildResults(allScores, rawRelevance, limit);
+    const phaseInfo = metrics.phase2Activated ? "phase2=yes" : "phase2=no";
+    if (fuzzyCorrection) {
+      log.info(`search "${query}" \u2192 fuzzy "${fuzzyCorrection.correctedQuery}": ${results.length} results (${metrics.latencyMs.toFixed(0)}ms)`);
+    } else {
+      log.info(`search "${query}": ${results.length} results, porter=${metrics.porterHits} trigram=${metrics.trigramHits} ${phaseInfo} (${metrics.latencyMs.toFixed(0)}ms)`);
+    }
+    return { query, results, metrics, ...fuzzyCorrection ? { fuzzyCorrection } : {} };
+  }
+  updateFile(filePath, symbols) {
+    if (this.isDocumentIndex) {
+      log.warn("updateFile does not apply to a document index; rebuild it with buildDocumentIndex");
+      return;
+    }
+    const oldIndices = /* @__PURE__ */ new Set();
+    for (let i = 0; i < this.documents.length; i++) {
+      if (this.documents[i].filePath === filePath) {
+        oldIndices.add(i);
+      }
+    }
+    if (oldIndices.size === 0 && symbols.length === 0) return;
+    const allSymbols = [];
+    for (let i = 0; i < this.documents.length; i++) {
+      if (!oldIndices.has(i)) {
+        const doc = this.documents[i];
+        allSymbols.push({
+          symbolId: doc.symbolId,
+          name: doc.name,
+          kind: doc.kind,
+          startLine: 0,
+          endLine: 0
+        });
+      }
+    }
+    allSymbols.push(...symbols);
+    this.buildIndex(allSymbols, this.pageRankScores);
+  }
+  /**
+   * BM25 scoring over an inverted index.
+   * Returns Map<docIndex, score>
+   */
+  bm25Search(queryTerms, index) {
+    const scores = /* @__PURE__ */ new Map();
+    const N = this.documents.length;
+    const { k1, b } = this.config.bm25;
+    for (const term of queryTerms) {
+      const postings = index.get(term);
+      if (!postings) continue;
+      const df = postings.length;
+      const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+      for (const { docIndex, termFrequency } of postings) {
+        const doc = this.documents[docIndex];
+        const tf = termFrequency;
+        const docLen = doc.length;
+        const numerator = tf * (k1 + 1);
+        const denominator = tf + k1 * (1 - b + b * (docLen / this.avgDocLength));
+        const termScore = idf * (numerator / denominator);
+        scores.set(docIndex, (scores.get(docIndex) ?? 0) + termScore);
+      }
+    }
+    const queryJoined = queryTerms.join("");
+    for (const [docIdx, score] of scores) {
+      const doc = this.documents[docIdx];
+      const nameLower = doc.name.toLowerCase();
+      if (nameLower === queryJoined || nameLower === queryTerms.join(" ")) {
+        scores.set(docIdx, score * 5);
+      }
+    }
+    return scores;
+  }
+  /**
+   * Merge two score maps. Phase 2 scores are penalized.
+   */
+  mergeScores(primary, secondary, penalty) {
+    const merged = new Map(primary);
+    for (const [docIdx, score] of secondary) {
+      const existing = merged.get(docIdx);
+      const penalized = score * penalty;
+      if (existing !== void 0) {
+        merged.set(docIdx, Math.max(existing, penalized));
+      } else {
+        merged.set(docIdx, penalized);
+      }
+    }
+    return merged;
+  }
+  /**
+   * Bigram boost for multi-word queries.
+   * Each adjacent query term pair found adjacent in symbol tokens → 2x boost.
+   */
+  bigramBoost(queryTerms, symbolTokens) {
+    if (queryTerms.length < 2) return 1;
+    let adjacentPairs = 0;
+    for (let i = 0; i < queryTerms.length - 1; i++) {
+      const idxA = symbolTokens.findIndex((t) => t.includes(queryTerms[i]));
+      const idxB = symbolTokens.findIndex((t) => t.includes(queryTerms[i + 1]));
+      if (idxA >= 0 && idxB >= 0 && Math.abs(idxA - idxB) === 1) {
+        adjacentPairs++;
+      }
+    }
+    return 1 + adjacentPairs * 2;
+  }
+  /**
+   * Extract character trigrams from a string.
+   * "sqlite" → ["sql", "qli", "lit", "ite"]
+   */
+  extractTrigrams(text) {
+    const trigrams = [];
+    for (let i = 0; i <= text.length - 3; i++) {
+      trigrams.push(text.substring(i, i + 3));
+    }
+    return trigrams;
+  }
+  buildResults(combinedScores, rawRelevance, limit) {
+    const entries = [...combinedScores.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
+    return entries.map(([docIdx, combined]) => {
+      const doc = this.documents[docIdx];
+      const pr = this.pageRankScores.get(doc.symbolId) ?? 0;
+      return {
+        symbolId: doc.symbolId,
+        name: doc.name,
+        kind: doc.kind,
+        filePath: doc.filePath,
+        relevanceScore: rawRelevance.get(docIdx) ?? 0,
+        importanceScore: pr,
+        combinedScore: combined
+      };
+    });
+  }
+  emptyResponse(query, start) {
+    return {
+      query,
+      results: [],
+      metrics: {
+        porterHits: 0,
+        trigramHits: 0,
+        phase2Activated: false,
+        fuzzyApplied: false,
+        latencyMs: performance.now() - start
+      }
+    };
+  }
+};
+
+// src/core/response-envelope.ts
+var DEFAULT_THRESHOLD = 8192;
+var workspaceMeta;
+function setWorkspaceMeta(workspace) {
+  workspaceMeta = workspace;
+}
+var TRUNCATABLE_FIELDS = {
+  impactedSymbols: "Use search_symbols to find specific impacted symbols, or get_blast_radius with a confidence filter.",
+  importers: "Use find_importers with edgeKinds filter or maxDepth to narrow results.",
+  deadSymbols: "Use search_symbols with kind filter to find specific dead symbols.",
+  unusedExports: "Use find_importers to check specific symbols.",
+  results: "Use search_symbols or get_ranked_context with a narrower query.",
+  rankings: "Use get_symbol_importance with kind or filePattern filter to narrow results.",
+  context: "Use get_context_for_task with a smaller tokenBudget.",
+  hierarchies: "Use get_class_hierarchy with a specific symbolId.",
+  scaffolding: "Review the scaffolding markers directly in the listed files.",
+  deadFiles: "Use find_dead_code with includeTests to adjust scope.",
+  files: "Use get_changed_symbols with a narrower since ref or smaller maxFiles.",
+  clusters: "Use get_architectural_overlay with mode=communities and layer filter for a focused view.",
+  candidates: "Use get_architectural_overlay with mode=contexts and candidate: <id> for one candidate in full, or ctxo contexts --json for the full contexts view.",
+  clustersAffected: "Use get_blast_radius on individual changed symbols for per-cluster impact.",
+  // The primary arrays of the @ctxo/domain tools (get_domain_context, get_rule). The additive domain lists
+  // on core tools (rulesAffected, cardsToUpdate, decisions, contextsTouched, cardsChanged, rulesWithoutTests)
+  // are capped at their source instead: listed here, a long one would take truncation over from the tool's
+  // primary array and `_meta.totalItems` would count the wrong list.
+  rules: "Use get_rule with a ruleId for one rule's tests, code and decisions.",
+  contexts: "Use get_domain_context with a symbolId or path for one context's card.",
+  terms: `Read the card's Language section, or use get_ranked_context with scope "domain".`,
+  openQuestions: "Read the card's Open questions section for the full list.",
+  tests: "Use search_symbols with a test file path as filePattern to list one file's tests.",
+  symbols: "Use get_blast_radius on one linked symbol for its impact.",
+  provenance: "Open the linked files directly; external references are never fetched.",
+  unresolved: 'Run "ctxo verify-domain --json" for every unresolved card reference.'
+};
+function getThreshold() {
+  const env = process.env["CTXO_RESPONSE_LIMIT"];
+  if (env) {
+    const n = parseInt(env, 10);
+    if (!isNaN(n) && n > 0) return n;
+  }
+  return DEFAULT_THRESHOLD;
+}
+function findTruncatableArray(data) {
+  let best = null;
+  for (const [key, value] of Object.entries(data)) {
+    if (Array.isArray(value) && key in TRUNCATABLE_FIELDS) {
+      if (!best || value.length > best.arr.length) {
+        best = { key, arr: value };
+      }
+    }
+  }
+  return best;
+}
+function buildMeta(base, extras) {
+  const meta = workspaceMeta ? { ...base, workspace: workspaceMeta } : base;
+  if (extras?.snapshotStaleness) {
+    return { ...meta, snapshotStaleness: extras.snapshotStaleness };
+  }
+  return meta;
+}
+function wrapResponse(data, extras) {
+  const threshold = getThreshold();
+  const fullJson = JSON.stringify(data);
+  const totalBytes = Buffer.byteLength(fullJson, "utf-8");
+  const truncatable = findTruncatableArray(data);
+  const totalItems = truncatable ? truncatable.arr.length : 0;
+  if (totalBytes <= threshold) {
+    return {
+      ...data,
+      _meta: buildMeta(
+        {
+          totalItems,
+          returnedItems: totalItems,
+          truncated: false,
+          totalBytes
+        },
+        extras
+      )
+    };
+  }
+  if (!truncatable || truncatable.arr.length <= 1) {
+    return {
+      ...data,
+      _meta: buildMeta(
+        {
+          totalItems,
+          returnedItems: totalItems,
+          truncated: false,
+          totalBytes
+        },
+        extras
+      )
+    };
+  }
+  let lo = 1;
+  let hi = truncatable.arr.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    const trial = {
+      ...data,
+      [truncatable.key]: truncatable.arr.slice(0, mid),
+      _meta: buildMeta(
+        {
+          totalItems,
+          returnedItems: mid,
+          truncated: true,
+          totalBytes,
+          hint: TRUNCATABLE_FIELDS[truncatable.key]
+        },
+        extras
+      )
+    };
+    const size = Buffer.byteLength(JSON.stringify(trial), "utf-8");
+    if (size <= threshold) {
+      lo = mid;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  const hint = TRUNCATABLE_FIELDS[truncatable.key];
+  return {
+    ...data,
+    [truncatable.key]: truncatable.arr.slice(0, lo),
+    _meta: buildMeta(
+      {
+        totalItems,
+        returnedItems: lo,
+        truncated: true,
+        totalBytes,
+        hint
+      },
+      extras
+    )
+  };
+}
+
+// src/core/describe-error.ts
+function describeError(err) {
+  try {
+    if (err instanceof Error) {
+      const message = err.message;
+      if (typeof message === "string") return message;
+    }
+    if (typeof err === "string") return err;
+    return String(err);
+  } catch {
+    try {
+      return Object.prototype.toString.call(err);
+    } catch {
+      return "[unprintable error]";
+    }
+  }
+}
+
+// src/adapters/mcp/enrich-payload.ts
+var log2 = createLogger("ctxo:modules");
+function applyEnricher(enrich, payload, args, tool) {
+  if (enrich === void 0) return payload;
+  try {
+    const enriched = enrich(structuredClone(payload), args);
+    if (isThenable(enriched)) {
+      Promise.resolve(enriched).catch(() => void 0);
+      log2.warn(`${tool} enricher returned a Promise; a synchronous tool cannot wait for it`);
+      return payload;
+    }
+    return accepted(enriched, payload, tool);
+  } catch (err) {
+    return failed(err, payload, tool);
+  }
+}
+async function applyEnricherAsync(enrich, payload, args, tool) {
+  if (enrich === void 0) return payload;
+  try {
+    const enriched = await enrich(structuredClone(payload), args);
+    return accepted(enriched, payload, tool);
+  } catch (err) {
+    return failed(err, payload, tool);
+  }
+}
+function accepted(enriched, payload, tool) {
+  if (!isPlainObject(enriched) || !isPlainData(enriched, /* @__PURE__ */ new Set())) {
+    log2.warn(
+      `The ${tool} enricher returned something other than a plain JSON payload object; its fields are left out of this response`
+    );
+    return payload;
+  }
+  JSON.stringify(enriched);
+  return enriched;
+}
+function failed(err, payload, tool) {
+  log2.warn(`The ${tool} enricher failed: ${describeError(err)}; its fields are left out of this response`);
+  return payload;
+}
+function isThenable(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+  return typeof value.then === "function";
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isPlainData(value, path) {
+  if (value === null) return true;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") return true;
+  if (type !== "object") return false;
+  const node = value;
+  if (path.has(node)) return false;
+  if (!Array.isArray(node) && !isPlainObject(node)) return false;
+  path.add(node);
+  try {
+    for (const child of Array.isArray(node) ? node : Object.values(node)) {
+      if (child !== void 0 && !isPlainData(child, path)) return false;
+    }
+  } finally {
+    path.delete(node);
+  }
+  return true;
+}
+function collectEnrichers(modules) {
+  const chains = /* @__PURE__ */ new Map();
+  for (const module of modules) {
+    let entries;
+    try {
+      entries = Object.entries(module.registration.enrich ?? {});
+    } catch (err) {
+      log2.warn(`${module.name} enrichers could not be read: ${describeError(err)}`);
+      continue;
+    }
+    for (const [tool, enrich] of entries) {
+      if (typeof enrich !== "function") continue;
+      const chain = chains.get(tool) ?? [];
+      chain.push(enrich);
+      chains.set(tool, chain);
+    }
+  }
+  const enrichers = /* @__PURE__ */ new Map();
+  for (const [tool, chain] of chains) {
+    enrichers.set(tool, chain.length === 1 ? chain[0] : composeChain(chain, tool));
+  }
+  return enrichers;
+}
+function composeChain(chain, tool) {
+  return (payload, args) => {
+    let current = payload;
+    for (let i = 0; i < chain.length; i++) {
+      try {
+        const enriched = chain[i](structuredClone(current), args);
+        if (isThenable(enriched)) return finishAsync(chain.slice(i + 1), enriched, current, args, tool);
+        current = accepted(enriched, current, tool);
+      } catch (err) {
+        current = failed(err, current, tool);
+      }
+    }
+    return current;
+  };
+}
+async function finishAsync(rest, pending, before, args, tool) {
+  let current;
+  try {
+    current = accepted(await pending, before, tool);
+  } catch (err) {
+    current = failed(err, before, tool);
+  }
+  for (const enrich of rest) current = await applyEnricherAsync(enrich, current, args, tool);
+  return current;
+}
+function collectTaskContextReservation(modules) {
+  const reservations = [];
+  for (const module of modules) {
+    let reserve;
+    try {
+      reserve = module.registration.reserveTaskContextTokens;
+    } catch (err) {
+      log2.warn(`${module.name} token reservation could not be read: ${describeError(err)}`);
+      continue;
+    }
+    if (typeof reserve === "function") reservations.push({ name: module.name, reserve });
+  }
+  if (reservations.length === 0) return void 0;
+  if (reservations.length === 1) return reservations[0].reserve;
+  return (args) => {
+    let sum = 0;
+    for (const { name, reserve } of reservations) {
+      let value;
+      try {
+        value = reserve(args);
+      } catch (err) {
+        log2.warn(`${name} token reservation failed: ${describeError(err)}; it is skipped`);
+        continue;
+      }
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        log2.warn(`${name} token reservation is not a finite number; it is skipped`);
+        continue;
+      }
+      sum += Math.max(value, 0);
+    }
+    return sum;
+  };
+}
+
+// src/adapters/mcp/get-logic-slice.ts
+import { z } from "zod";
+
+// src/core/logic-slice/logic-slice-query.ts
+var LogicSliceQuery = class {
+  getLogicSlice(graph, symbolId, maxDepth = Infinity) {
+    const root = graph.getNode(symbolId);
+    if (!root) return void 0;
+    const visited = /* @__PURE__ */ new Set([root.symbolId]);
+    const dependencies = [];
+    const collectedEdges = [];
+    const queue = [{ id: root.symbolId, depth: 0 }];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.depth >= maxDepth) continue;
+      const edges = graph.getForwardEdges(current.id);
+      for (const edge of edges) {
+        const depNode = graph.getNode(edge.to);
+        if (!depNode) continue;
+        collectedEdges.push(edge);
+        if (visited.has(edge.to)) continue;
+        visited.add(edge.to);
+        dependencies.push(depNode);
+        queue.push({ id: edge.to, depth: current.depth + 1 });
+      }
+    }
+    return { root, dependencies, edges: collectedEdges };
+  }
+};
+
+// src/core/detail-levels/detail-formatter.ts
+var L1_MAX_LINES = 150;
+var L4_TOKEN_BUDGET = 8e3;
+function withoutAnnotations(node) {
+  if (node.annotations === void 0) return node;
+  const { annotations: _annotations, ...rest } = node;
+  return rest;
+}
+var DetailFormatter = class {
+  format(slice, level) {
+    switch (level) {
+      case 1:
+        return this.formatL1(slice);
+      case 2:
+        return this.formatL2(slice);
+      case 3:
+        return this.formatL3(slice);
+      case 4:
+        return this.formatL4(slice);
+    }
+  }
+  formatL1(slice) {
+    const root = slice.root;
+    const lineCount = root.endLine - root.startLine + 1;
+    const clampedRoot = lineCount > L1_MAX_LINES ? { ...root, endLine: root.startLine + L1_MAX_LINES - 1 } : root;
+    return {
+      root: withoutAnnotations(clampedRoot),
+      dependencies: [],
+      edges: [],
+      level: 1,
+      levelDescription: "L1: Root symbol signature only (no dependencies)",
+      ...lineCount > L1_MAX_LINES ? { truncation: { truncated: true, reason: "token_budget_exceeded" } } : {}
+    };
+  }
+  formatL2(slice) {
+    const directEdges = slice.edges.filter((e) => e.from === slice.root.symbolId);
+    const directDepIds = new Set(directEdges.map((e) => e.to));
+    const directDeps = slice.dependencies.filter((d) => directDepIds.has(d.symbolId));
+    return {
+      root: withoutAnnotations(slice.root),
+      dependencies: directDeps.map(withoutAnnotations),
+      edges: directEdges,
+      level: 2,
+      levelDescription: "L2: Root + direct dependencies (depth 1)"
+    };
+  }
+  formatL3(slice) {
+    return {
+      root: withoutAnnotations(slice.root),
+      dependencies: slice.dependencies.map(withoutAnnotations),
+      edges: slice.edges,
+      level: 3,
+      levelDescription: "L3: Full transitive dependency closure"
+    };
+  }
+  formatL4(slice) {
+    const estimatedTokens = this.estimateTokens(slice);
+    if (estimatedTokens > L4_TOKEN_BUDGET) {
+      const truncated = this.truncateToTokenBudget(slice, L4_TOKEN_BUDGET);
+      return {
+        ...truncated,
+        level: 4,
+        levelDescription: "L4: Full closure with 8K token budget (truncated)",
+        truncation: {
+          truncated: true,
+          reason: "token_budget_exceeded"
+        }
+      };
+    }
+    return {
+      root: slice.root,
+      dependencies: slice.dependencies,
+      edges: slice.edges,
+      level: 4,
+      levelDescription: "L4: Full closure with 8K token budget"
+    };
+  }
+  estimateTokens(slice) {
+    let chars = this.symbolCharEstimate(slice.root);
+    for (const dep of slice.dependencies) {
+      chars += this.symbolCharEstimate(dep);
+    }
+    for (const edge of slice.edges) {
+      chars += edge.from.length + edge.to.length + edge.kind.length + 10;
+    }
+    return Math.ceil(chars / 4);
+  }
+  symbolCharEstimate(node) {
+    if (node.startOffset !== void 0 && node.endOffset !== void 0) {
+      return node.endOffset - node.startOffset;
+    }
+    return (node.endLine - node.startLine + 1) * 40;
+  }
+  truncateToTokenBudget(slice, budget) {
+    let currentTokens = this.symbolCharEstimate(slice.root) / 4;
+    const deps = [];
+    const includedIds = /* @__PURE__ */ new Set([slice.root.symbolId]);
+    for (const dep of slice.dependencies) {
+      const depTokens = this.symbolCharEstimate(dep) / 4;
+      if (currentTokens + depTokens > budget) break;
+      currentTokens += depTokens;
+      deps.push(dep);
+      includedIds.add(dep.symbolId);
+    }
+    const edges = slice.edges.filter(
+      (e) => includedIds.has(e.from) && includedIds.has(e.to)
+    );
+    return { root: slice.root, dependencies: deps, edges };
+  }
+};
+
+// src/core/intent-filter.ts
+function extractKeywords(intent) {
+  return intent.toLowerCase().split(/\s+/).filter((w) => w.length >= 2);
+}
+function matchesAny(keywords, values) {
+  const lower = values.map((v) => v.toLowerCase());
+  return keywords.some((kw) => lower.some((v) => v.includes(kw)));
+}
+function collectMatchableStrings(entry) {
+  const strings = [];
+  for (const key of ["symbolId", "file", "name", "kind", "edgeKind", "reason", "confidence"]) {
+    const v = entry[key];
+    if (typeof v === "string") strings.push(v);
+  }
+  const edgeKinds = entry["edgeKinds"];
+  if (Array.isArray(edgeKinds)) {
+    for (const ek of edgeKinds) {
+      if (typeof ek === "string") strings.push(ek);
+    }
+  }
+  return strings;
+}
+function filterByIntent(items, intent) {
+  if (!intent || intent.trim().length === 0) return items;
+  const keywords = extractKeywords(intent);
+  if (keywords.length === 0) return items;
+  return items.filter((item) => {
+    const strings = collectMatchableStrings(item);
+    return matchesAny(keywords, strings);
+  });
+}
+
+// src/adapters/mcp/get-logic-slice.ts
+var InputSchema = z.object({
+  symbolId: z.string().min(1).optional(),
+  symbolIds: z.array(z.string().min(1)).optional(),
+  level: DetailLevelSchema.optional().default(3),
+  intent: z.string().optional().describe('Filter dependencies by intent keywords (e.g., "core", "adapter", "storage")')
+}).refine(
+  (data) => data.symbolId || data.symbolIds && data.symbolIds.length > 0,
+  { message: "Either symbolId or symbolIds must be provided" }
+);
+function buildGraphFromStorage(storage) {
+  const graph = new SymbolGraph();
+  for (const sym of storage.getAllSymbols()) {
+    graph.addNode(sym);
+  }
+  for (const edge of storage.getAllEdges()) {
+    graph.addEdge(edge);
+  }
+  return graph;
+}
+function buildGraphAndFilesFromJsonIndex(ctxoRoot) {
+  const reader = new JsonIndexReader(ctxoRoot);
+  const indices = reader.readAll();
+  return { graph: buildGraphFromIndices(indices), indexedFiles: indices.map((fileIndex) => fileIndex.file) };
+}
+function buildGraphFromIndices(indices) {
+  const graph = new SymbolGraph();
+  for (const fileIndex of indices) {
+    for (const sym of fileIndex.symbols) {
+      graph.addNode(sym);
+    }
+  }
+  for (const fileIndex of indices) {
+    for (const edge of fileIndex.edges) {
+      graph.addEdge(edge);
+    }
+  }
+  return graph;
+}
+function getGraphAndFiles(ctxoRoot, storage) {
+  const json = buildGraphAndFilesFromJsonIndex(ctxoRoot);
+  if (json.graph.nodeCount > 0) return json;
+  return { graph: buildGraphFromStorage(storage), indexedFiles: storage.listIndexedFiles() };
+}
+function handleGetLogicSlice(storage, masking, staleness, ctxoRoot = ".ctxo", enrich) {
+  const query = new LogicSliceQuery();
+  const formatter = new DetailFormatter();
+  const getGraph = () => getGraphAndFiles(ctxoRoot, storage);
+  const handler = (args) => {
+    try {
+      const parsed = InputSchema.safeParse(args);
+      if (!parsed.success) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
+        };
+      }
+      const { symbolId, symbolIds, level, intent } = parsed.data;
+      const ids = symbolIds ?? (symbolId ? [symbolId] : []);
+      const { graph, indexedFiles } = getGraph();
+      const results = [];
+      for (const id of ids) {
+        const slice = query.getLogicSlice(graph, id);
+        if (slice) {
+          const formatted = formatter.format(slice, level);
+          if (intent && Array.isArray(formatted["dependencies"])) {
+            formatted["dependencies"] = filterByIntent(
+              formatted["dependencies"],
+              intent
+            );
+          }
+          results.push(formatted);
+        } else {
+          results.push({ found: false, symbolId: id, hint: 'Symbol not found. Run "ctxo index".' });
+        }
+      }
+      const responseData = ids.length === 1 ? results[0] : { batch: true, results };
+      const body = applyEnricher(enrich, responseData, parsed.data, "get_logic_slice");
+      const payload = masking.mask(JSON.stringify(wrapResponse(body)));
+      const content = [];
+      if (staleness) {
+        const warning = staleness.check(indexedFiles);
+        if (warning) {
+          content.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+        }
+      }
+      content.push({ type: "text", text: payload });
+      return { content };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: true, message: err.message }) }]
+      };
+    }
+  };
+  return handler;
+}
+
+export {
+  DOCUMENT_SEARCH_CONFIG,
+  SearchEngine,
+  LogicSliceQuery,
+  withoutAnnotations,
+  setWorkspaceMeta,
+  getThreshold,
+  wrapResponse,
+  filterByIntent,
+  describeError,
+  applyEnricher,
+  applyEnricherAsync,
+  collectEnrichers,
+  collectTaskContextReservation,
+  buildGraphFromStorage,
+  buildGraphFromIndices,
+  getGraphAndFiles,
+  handleGetLogicSlice
+};
+//# sourceMappingURL=chunk-IT426P3F.js.map