ctxo-mcp 0.3.1 → 0.4.2

package/dist/index.js

@@ -1,20 +1,94 @@
 #!/usr/bin/env node
 import {
   RevertDetector,
+  SessionRecorderAdapter,
   SimpleGitAdapter,
   SqliteStorageAdapter,
   createLogger,
   loadCoChangeMap
-} from "./chunk-XSHNN6PU.js";
+} from "./chunk-WZKXGKKI.js";
 import {
   DetailLevelSchema,
   JsonIndexReader
-} from "./chunk-N6GPODUY.js";
+} from "./chunk-4OI75JDS.js";
 import "./chunk-JIDIH7DS.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/adapters/transport/http-server-transport.ts
+import { createServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { randomUUID } from "crypto";
+var log = createLogger("ctxo:http");
+async function startHttpTransport(serverFactory, port) {
+  const sessions = /* @__PURE__ */ new Map();
+  const httpServer = createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Accept, Mcp-Session-Id");
+    res.setHeader("Access-Control-Expose-Headers", "Mcp-Session-Id");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const sessionId = req.headers["mcp-session-id"];
+    if (sessionId && sessions.has(sessionId)) {
+      try {
+        await sessions.get(sessionId).transport.handleRequest(req, res);
+      } catch (err) {
+        log.error("Request error: %s", err.message);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end();
+        }
+      }
+      return;
+    }
+    if (sessionId && !sessions.has(sessionId)) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "Session not found" }, id: null }));
+      return;
+    }
+    try {
+      const server = await serverFactory();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID()
+      });
+      transport.onclose = () => {
+        if (transport.sessionId) {
+          sessions.delete(transport.sessionId);
+          log.info("Session closed: %s", transport.sessionId);
+        }
+      };
+      await server.connect(transport);
+      await transport.handleRequest(req, res);
+      if (transport.sessionId) {
+        sessions.set(transport.sessionId, { transport, server });
+        log.info("New session: %s (total: %d)", transport.sessionId, sessions.size);
+      }
+    } catch (err) {
+      log.error("Session creation error: %s", err.message);
+      if (!res.headersSent) {
+        res.writeHead(500);
+        res.end();
+      }
+    }
+  });
+  return new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    httpServer.listen(port, () => {
+      log.info("MCP HTTP server listening on http://localhost:%d", port);
+      process.stderr.write(`[ctxo] MCP HTTP server running at http://localhost:${port}
+`);
+      resolve({ httpServer });
+    });
+  });
+}
+
+// src/index.ts
 import { z as z15 } from "zod";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
@@ -1342,6 +1416,9 @@ var ContextAssembler = class {
   isInterfaceOrType(kind) {
     return kind === "interface" || kind === "type";
   }
+  estimateTokensPublic(node) {
+    return this.estimateTokens(node);
+  }
   estimateTokens(node) {
     if (node.startOffset !== void 0 && node.endOffset !== void 0) {
       return Math.ceil((node.endOffset - node.startOffset) / 4);
@@ -1400,18 +1477,575 @@ function handleGetContextForTask(storage, masking, staleness, ctxoRoot = ".ctxo"
 
 // src/adapters/mcp/get-ranked-context.ts
 import { z as z8 } from "zod";
+
+// src/core/search/symbol-tokenizer.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "get",
+  "set",
+  "is",
+  "has",
+  "can",
+  "do",
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "not",
+  "no",
+  "or"
+]);
+var DEFAULT_OPTIONS = {
+  includeStopWords: false,
+  includeOriginal: true,
+  includeFilePath: false
+};
+var SymbolTokenizer = class _SymbolTokenizer {
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Tokenize a symbol name into searchable tokens.
+   *
+   * Examples:
+   *   "getCoChangeMetrics"    → ["get", "co", "change", "metrics"]  (or without stop words: ["co", "change", "metrics"])
+   *   "SqliteStorageAdapter"  → ["sqlite", "storage", "adapter"]
+   *   "i_storage_port"        → ["i", "storage", "port"]
+   *   "BM25Scorer"            → ["bm", "25", "scorer"]
+   *   "DB_PASSWORD"           → ["db", "password"]
+   */
+  tokenize(symbolName, filePath) {
+    const splitTokens = _SymbolTokenizer.splitName(symbolName);
+    const lowered = splitTokens.map((t) => t.toLowerCase());
+    const tokens = this.options.includeStopWords ? lowered : lowered.filter((t) => !STOP_WORDS.has(t));
+    if (this.options.includeOriginal) {
+      const original = symbolName.toLowerCase();
+      if (!tokens.includes(original)) {
+        tokens.unshift(original);
+      }
+    }
+    if (this.options.includeFilePath && filePath) {
+      const pathTokens = _SymbolTokenizer.tokenizeFilePath(filePath);
+      for (const pt of pathTokens) {
+        if (!tokens.includes(pt)) {
+          tokens.push(pt);
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Tokenize a search query. Queries use stop words and don't include originals.
+   */
+  tokenizeQuery(query) {
+    const words = query.trim().split(/\s+/);
+    const tokens = [];
+    for (const word of words) {
+      const split = _SymbolTokenizer.splitName(word);
+      for (const t of split) {
+        const lowered = t.toLowerCase();
+        if (lowered.length > 0 && !tokens.includes(lowered)) {
+          tokens.push(lowered);
+        }
+      }
+    }
+    return tokens;
+  }
+  /**
+   * Split a name into constituent words based on naming convention boundaries.
+   *
+   * Rules:
+   *  1. Split on underscores and hyphens (snake_case, kebab-case)
+   *  2. Split on camelCase/PascalCase boundaries (uppercase after lowercase)
+   *  3. Split acronym boundaries (e.g., "HTMLParser" → ["HTML", "Parser"])
+   *  4. Split on digit ↔ letter boundaries
+   */
+  static splitName(name) {
+    if (!name || name.length === 0) return [];
+    const segments = name.split(/[_\-./\\]+/).filter((s) => s.length > 0);
+    const tokens = [];
+    for (const segment of segments) {
+      tokens.push(..._SymbolTokenizer.splitCamelCase(segment));
+    }
+    return tokens.filter((t) => t.length > 0);
+  }
+  /**
+   * Split a single segment on camelCase/PascalCase/digit boundaries.
+   */
+  static splitCamelCase(segment) {
+    const tokens = [];
+    let current = "";
+    for (let i = 0; i < segment.length; i++) {
+      const ch = segment[i];
+      const prev = i > 0 ? segment[i - 1] : "";
+      if (current.length > 0) {
+        const prevIsDigit = isDigit(prev);
+        const currIsDigit = isDigit(ch);
+        if (prevIsDigit !== currIsDigit) {
+          tokens.push(current);
+          current = ch;
+          continue;
+        }
+      }
+      if (current.length > 0 && isLower(prev) && isUpper(ch)) {
+        tokens.push(current);
+        current = ch;
+        continue;
+      }
+      if (current.length > 1 && isUpper(ch) === false && isUpper(prev) && !isDigit(ch)) {
+        const lastChar = current[current.length - 1];
+        if (isUpper(lastChar)) {
+          tokens.push(current.slice(0, -1));
+          current = lastChar + ch;
+          continue;
+        }
+      }
+      current += ch;
+    }
+    if (current.length > 0) {
+      tokens.push(current);
+    }
+    return tokens;
+  }
+  /**
+   * Extract searchable tokens from a file path.
+   * "src/core/search/symbol-tokenizer.ts" → ["src", "core", "search", "symbol", "tokenizer", "ts"]
+   */
+  static tokenizeFilePath(filePath) {
+    const withoutExt = filePath.replace(/\.[^.]+$/, "");
+    const segments = withoutExt.split(/[/\\]+/);
+    const tokens = [];
+    for (const seg of segments) {
+      const parts = seg.split(/[_\-.]+/).filter((s) => s.length > 0);
+      for (const p of parts) {
+        const lowered = p.toLowerCase();
+        if (lowered.length > 0 && !tokens.includes(lowered)) {
+          tokens.push(lowered);
+        }
+      }
+    }
+    return tokens;
+  }
+  /** Check if a token is a stop word */
+  static isStopWord(token) {
+    return STOP_WORDS.has(token.toLowerCase());
+  }
+};
+function isUpper(ch) {
+  return ch >= "A" && ch <= "Z";
+}
+function isLower(ch) {
+  return ch >= "a" && ch <= "z";
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+
+// 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 log2 = 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 SearchEngine = class {
+  config;
+  tokenizer;
+  fuzzy;
+  // Primary index (exact + tokenized)
+  documents = [];
+  primaryIndex = /* @__PURE__ */ new Map();
+  avgDocLength = 0;
+  // 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.documents = [];
+    this.primaryIndex = /* @__PURE__ */ new Map();
+    this.trigramIndex = /* @__PURE__ */ new Map();
+    this.pageRankScores = pageRankScores ?? /* @__PURE__ */ new Map();
+    let totalLength = 0;
+    const vocabFreq = /* @__PURE__ */ new Map();
+    for (const sym of symbols) {
+      const filePath = sym.symbolId.split("::")[0] ?? "";
+      const tokens = this.tokenizer.tokenize(sym.name, filePath);
+      const doc = {
+        symbolId: sym.symbolId,
+        name: sym.name,
+        kind: sym.kind,
+        filePath,
+        tokens,
+        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 nameLower = sym.name.toLowerCase();
+      const trigrams = this.extractTrigrams(nameLower);
+      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);
+    const elapsed = performance.now() - start;
+    log2.info(`Index built: ${symbols.length} symbols, ${this.primaryIndex.size} terms, ${this.trigramIndex.size} trigrams (${elapsed.toFixed(0)}ms)`);
+  }
+  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) {
+      log2.info(`search "${query}" \u2192 fuzzy "${fuzzyCorrection.correctedQuery}": ${results.length} results (${metrics.latencyMs.toFixed(0)}ms)`);
+    } else {
+      log2.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) {
+    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/adapters/mcp/get-ranked-context.ts
+var log3 = createLogger("ctxo:search");
 var InputSchema8 = z8.object({
   query: z8.string().min(1),
   tokenBudget: z8.number().min(100).optional().default(4e3),
-  strategy: z8.enum(["combined", "dependency", "importance"]).optional().default("combined")
+  strategy: z8.enum(["combined", "dependency", "importance"]).optional().default("combined"),
+  fuzzy: z8.boolean().optional().default(true),
+  searchMode: z8.enum(["fts", "legacy"]).optional().default("fts")
 });
-function handleGetRankedContext(storage, masking, staleness, ctxoRoot = ".ctxo") {
+function handleGetRankedContext(storage, masking, staleness, ctxoRoot = ".ctxo", searchEngine) {
   const assembler = new ContextAssembler();
+  const engine = searchEngine ?? new SearchEngine();
   const getGraph = () => {
     const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
     if (jsonGraph.nodeCount > 0) return jsonGraph;
     return buildGraphFromStorage(storage);
   };
+  let lastNodeCount = -1;
   return (args) => {
     try {
       const parsed = InputSchema8.safeParse(args);
@@ -1420,8 +2054,62 @@ function handleGetRankedContext(storage, masking, staleness, ctxoRoot = ".ctxo")
           content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
         };
       }
-      const { query, tokenBudget, strategy } = parsed.data;
+      const { query, tokenBudget, strategy, searchMode } = parsed.data;
       const graph = getGraph();
+      if (searchMode === "fts" && strategy !== "importance") {
+        const currentNodeCount = graph.nodeCount;
+        if (currentNodeCount !== lastNodeCount) {
+          const allNodes = graph.allNodes();
+          const pageRankScores = /* @__PURE__ */ new Map();
+          let maxReverseEdges = 1;
+          for (const node of allNodes) {
+            const count = graph.getReverseEdges(node.symbolId).length;
+            if (count > maxReverseEdges) maxReverseEdges = count;
+          }
+          for (const node of allNodes) {
+            const count = graph.getReverseEdges(node.symbolId).length;
+            pageRankScores.set(node.symbolId, count / maxReverseEdges);
+          }
+          engine.buildIndex(allNodes, pageRankScores);
+          lastNodeCount = currentNodeCount;
+          log3.info(`Search engine: ${engine.getTier()} (${allNodes.length} symbols)`);
+        }
+        const searchResult = engine.search(query, 100);
+        const results = [];
+        let totalTokens = 0;
+        for (const sr of searchResult.results) {
+          const node = graph.getNode(sr.symbolId);
+          const tokens = node ? assembler.estimateTokensPublic(node) : 90;
+          if (totalTokens + tokens > tokenBudget) continue;
+          results.push({
+            symbolId: sr.symbolId,
+            name: sr.name,
+            kind: sr.kind,
+            file: sr.filePath,
+            relevanceScore: Math.round(sr.relevanceScore * 1e3) / 1e3,
+            importanceScore: Math.round(sr.importanceScore * 1e3) / 1e3,
+            combinedScore: Math.round(sr.combinedScore * 1e3) / 1e3,
+            tokens
+          });
+          totalTokens += tokens;
+        }
+        const payload2 = masking.mask(JSON.stringify(wrapResponse({
+          query,
+          strategy,
+          results,
+          totalTokens,
+          tokenBudget,
+          searchMetrics: searchResult.metrics,
+          ...searchResult.fuzzyCorrection ? { fuzzyCorrection: searchResult.fuzzyCorrection } : {}
+        })));
+        const content2 = [];
+        if (staleness) {
+          const warning = staleness.check(storage.listIndexedFiles());
+          if (warning) content2.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+        }
+        content2.push({ type: "text", text: payload2 });
+        return { content: content2 };
+      }
       const result = assembler.assembleRanked(graph, query, strategy, tokenBudget);
       const payload = masking.mask(JSON.stringify(wrapResponse(result)));
       const content = [];
@@ -1445,9 +2133,12 @@ var InputSchema9 = z9.object({
   pattern: z9.string().min(1),
   kind: z9.enum(["function", "class", "interface", "method", "variable", "type"]).optional(),
   filePattern: z9.string().optional(),
-  limit: z9.number().int().min(1).max(100).optional().default(25)
+  limit: z9.number().int().min(1).max(100).optional().default(25),
+  mode: z9.enum(["regex", "fts"]).optional().default("regex")
 });
-function handleSearchSymbols(storage, masking, staleness, ctxoRoot = ".ctxo") {
+function handleSearchSymbols(storage, masking, staleness, ctxoRoot = ".ctxo", searchEngine) {
+  const engine = searchEngine ?? new SearchEngine();
+  let lastFtsNodeCount = -1;
   const getGraph = () => {
     const jsonGraph = buildGraphFromJsonIndex(ctxoRoot);
     if (jsonGraph.nodeCount > 0) return jsonGraph;
@@ -1461,9 +2152,49 @@ function handleSearchSymbols(storage, masking, staleness, ctxoRoot = ".ctxo") {
           content: [{ type: "text", text: JSON.stringify({ error: true, message: parsed.error.message }) }]
         };
       }
-      const { pattern, kind, filePattern, limit } = parsed.data;
+      const { pattern, kind, filePattern, limit, mode } = parsed.data;
       const graph = getGraph();
       const allNodes = graph.allNodes();
+      if (mode === "fts") {
+        if (allNodes.length !== lastFtsNodeCount) {
+          engine.buildIndex(allNodes);
+          lastFtsNodeCount = allNodes.length;
+        }
+        const searchResult = engine.search(pattern, limit);
+        let ftsResults = searchResult.results;
+        if (kind) {
+          ftsResults = ftsResults.filter((r) => r.kind === kind);
+        }
+        if (filePattern) {
+          const fp = filePattern.toLowerCase();
+          ftsResults = ftsResults.filter((r) => r.filePath.toLowerCase().includes(fp));
+        }
+        const results2 = ftsResults.slice(0, limit).map((r) => {
+          const node = graph.getNode(r.symbolId);
+          return {
+            symbolId: r.symbolId,
+            name: r.name,
+            kind: r.kind,
+            file: r.filePath,
+            startLine: node?.startLine ?? 0,
+            endLine: node?.endLine ?? 0,
+            relevanceScore: Math.round(r.relevanceScore * 1e3) / 1e3
+          };
+        });
+        const payload2 = masking.mask(JSON.stringify(wrapResponse({
+          totalMatches: ftsResults.length,
+          results: results2,
+          searchMetrics: searchResult.metrics,
+          ...searchResult.fuzzyCorrection ? { fuzzyCorrection: searchResult.fuzzyCorrection } : {}
+        })));
+        const content2 = [];
+        if (staleness) {
+          const warning = staleness.check(storage.listIndexedFiles());
+          if (warning) content2.push({ type: "text", text: `\u26A0\uFE0F ${warning.message}` });
+        }
+        content2.push({ type: "text", text: payload2 });
+        return { content: content2 };
+      }
       let matcher;
       try {
         const regex = new RegExp(pattern, "i");
@@ -2119,26 +2850,85 @@ function handleGetPrImpact(storage, git, masking, staleness, ctxoRoot = ".ctxo")
   };
 }
 
+// src/adapters/stats/with-recording.ts
+function withRecording(toolName, handler, recorder) {
+  if (!recorder) return handler;
+  return (args) => {
+    const start = performance.now();
+    const resultOrPromise = handler(args);
+    if (resultOrPromise instanceof Promise) {
+      return resultOrPromise.then((result) => {
+        recordEvent(toolName, args, result, performance.now() - start, recorder);
+        return result;
+      });
+    }
+    const latencyMs = performance.now() - start;
+    recordEvent(toolName, args, resultOrPromise, latencyMs, recorder);
+    return resultOrPromise;
+  };
+}
+function recordEvent(toolName, args, result, latencyMs, recorder) {
+  try {
+    const responseText = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+    let truncated = false;
+    try {
+      const parsed = JSON.parse(responseText);
+      truncated = parsed?._meta?.truncated ?? false;
+    } catch {
+    }
+    const responseBytes = Buffer.byteLength(responseText, "utf-8");
+    const rawLevel = args["level"];
+    let detailLevel = null;
+    if (typeof rawLevel === "number" && rawLevel >= 1 && rawLevel <= 4) {
+      detailLevel = `L${rawLevel}`;
+    }
+    const event = {
+      tool: toolName,
+      symbolId: typeof args["symbolId"] === "string" ? args["symbolId"] : null,
+      detailLevel,
+      responseTokens: Math.ceil(responseBytes / 4),
+      responseBytes,
+      latencyMs,
+      truncated
+    };
+    recorder.record(event);
+  } catch {
+  }
+}
+
 // src/index.ts
-var log = createLogger("ctxo:mcp");
+var log4 = createLogger("ctxo:mcp");
 function loadMaskingConfig(ctxoRoot) {
   const jsonConfigPath = join2(ctxoRoot, "masking.json");
   if (existsSync2(jsonConfigPath)) {
     try {
       const raw = readFileSync2(jsonConfigPath, "utf-8");
       const patterns = JSON.parse(raw);
-      log.info(`Loaded ${patterns.length} custom masking pattern(s)`);
+      log4.info(`Loaded ${patterns.length} custom masking pattern(s)`);
       return MaskingPipeline.fromConfig(patterns);
     } catch (err) {
-      log.error(`Failed to load masking config: ${err.message}`);
+      log4.error(`Failed to load masking config: ${err.message}`);
     }
   }
   return new MaskingPipeline();
 }
+function readStatsEnabled(ctxoRoot) {
+  const configPath = join2(ctxoRoot, "config.yaml");
+  if (!existsSync2(configPath)) return true;
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const match = raw.match(/stats:\s*\n\s*enabled:\s*(true|false)/);
+    if (match) return match[1] !== "false";
+    return true;
+  } catch {
+    return true;
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
-  if (args.length > 0) {
-    const { CliRouter } = await import("./cli-router-NRUGPICL.js");
+  const httpPortStr = process.env.CTXO_HTTP_PORT || (args.includes("--http") ? args[args.indexOf("--port") + 1] || "3001" : null);
+  if (!httpPortStr && args.length > 0) {
+    const { CliRouter } = await import("./cli-router-H557TJAM.js");
     const router = new CliRouter(process.cwd());
     await router.route(args);
     return;
@@ -2148,18 +2938,32 @@ async function main() {
   await storage.init();
   const masking = loadMaskingConfig(ctxoRoot);
   const git = new SimpleGitAdapter(process.cwd());
+  const recorder = readStatsEnabled(ctxoRoot) ? new SessionRecorderAdapter(storage.getDb(), () => storage.persist()) : null;
   const server = new McpServer({ name: "ctxo", version: "0.1.0" });
   const { StalenessDetector } = await import("./staleness-detector-VSDPTPX7.js");
   const staleness = new StalenessDetector(process.cwd(), ctxoRoot);
+  registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot);
+  if (httpPortStr) {
+    await startHttpTransport(async () => {
+      const s = new McpServer({ name: "ctxo", version: "0.1.0" });
+      registerTools(s, storage, masking, git, staleness, recorder, ctxoRoot);
+      return s;
+    }, parseInt(httpPortStr, 10));
+  } else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  }
+}
+function registerTools(server, storage, masking, git, staleness, recorder, ctxoRoot = ".ctxo") {
   const toolAnnotations = {
     readOnlyHint: true,
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false
   };
-  const logicSliceHandler = handleGetLogicSlice(storage, masking, staleness, ctxoRoot);
-  const whyContextHandler = handleGetWhyContext(storage, git, masking, staleness, ctxoRoot);
-  const changeIntelligenceHandler = handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot);
+  const logicSliceHandler = withRecording("get_logic_slice", handleGetLogicSlice(storage, masking, staleness, ctxoRoot), recorder);
+  const whyContextHandler = withRecording("get_why_context", handleGetWhyContext(storage, git, masking, staleness, ctxoRoot), recorder);
+  const changeIntelligenceHandler = withRecording("get_change_intelligence", handleGetChangeIntelligence(storage, git, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_logic_slice",
     {
@@ -2172,7 +2976,7 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => logicSliceHandler(args2)
+    (args) => logicSliceHandler(args)
   );
   server.registerTool(
     "get_why_context",
@@ -2184,7 +2988,7 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => whyContextHandler(args2)
+    (args) => whyContextHandler(args)
   );
   server.registerTool(
     "get_change_intelligence",
@@ -2195,9 +2999,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => changeIntelligenceHandler(args2)
+    (args) => changeIntelligenceHandler(args)
   );
-  const blastRadiusHandler = handleGetBlastRadius(storage, masking, staleness, ctxoRoot);
+  const blastRadiusHandler = withRecording("get_blast_radius", handleGetBlastRadius(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_blast_radius",
     {
@@ -2209,9 +3013,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => blastRadiusHandler(args2)
+    (args) => blastRadiusHandler(args)
   );
-  const overlayHandler = handleGetArchitecturalOverlay(storage, masking, staleness);
+  const overlayHandler = withRecording("get_architectural_overlay", handleGetArchitecturalOverlay(storage, masking, staleness), recorder);
   server.registerTool(
     "get_architectural_overlay",
     {
@@ -2221,9 +3025,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => overlayHandler(args2)
+    (args) => overlayHandler(args)
   );
-  const deadCodeHandler = handleFindDeadCode(storage, masking, staleness, ctxoRoot);
+  const deadCodeHandler = withRecording("find_dead_code", handleFindDeadCode(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "find_dead_code",
     {
@@ -2234,9 +3038,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => deadCodeHandler(args2)
+    (args) => deadCodeHandler(args)
   );
-  const contextForTaskHandler = handleGetContextForTask(storage, masking, staleness, ctxoRoot);
+  const contextForTaskHandler = withRecording("get_context_for_task", handleGetContextForTask(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_context_for_task",
     {
@@ -2248,9 +3052,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => contextForTaskHandler(args2)
+    (args) => contextForTaskHandler(args)
   );
-  const rankedContextHandler = handleGetRankedContext(storage, masking, staleness, ctxoRoot);
+  const rankedContextHandler = withRecording("get_ranked_context", handleGetRankedContext(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_ranked_context",
     {
@@ -2262,9 +3066,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => rankedContextHandler(args2)
+    (args) => rankedContextHandler(args)
   );
-  const searchSymbolsHandler = handleSearchSymbols(storage, masking, staleness, ctxoRoot);
+  const searchSymbolsHandler = withRecording("search_symbols", handleSearchSymbols(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "search_symbols",
     {
@@ -2277,9 +3081,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => searchSymbolsHandler(args2)
+    (args) => searchSymbolsHandler(args)
   );
-  const changedSymbolsHandler = handleGetChangedSymbols(storage, git, masking, staleness, ctxoRoot);
+  const changedSymbolsHandler = withRecording("get_changed_symbols", handleGetChangedSymbols(storage, git, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_changed_symbols",
     {
@@ -2290,9 +3094,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => changedSymbolsHandler(args2)
+    (args) => changedSymbolsHandler(args)
   );
-  const findImportersHandler = handleFindImporters(storage, masking, staleness, ctxoRoot);
+  const findImportersHandler = withRecording("find_importers", handleFindImporters(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "find_importers",
     {
@@ -2306,9 +3110,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => findImportersHandler(args2)
+    (args) => findImportersHandler(args)
   );
-  const classHierarchyHandler = handleGetClassHierarchy(storage, masking, staleness, ctxoRoot);
+  const classHierarchyHandler = withRecording("get_class_hierarchy", handleGetClassHierarchy(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_class_hierarchy",
     {
@@ -2319,9 +3123,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => classHierarchyHandler(args2)
+    (args) => classHierarchyHandler(args)
   );
-  const symbolImportanceHandler = handleGetSymbolImportance(storage, masking, staleness, ctxoRoot);
+  const symbolImportanceHandler = withRecording("get_symbol_importance", handleGetSymbolImportance(storage, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_symbol_importance",
     {
@@ -2334,9 +3138,9 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => symbolImportanceHandler(args2)
+    (args) => symbolImportanceHandler(args)
   );
-  const prImpactHandler = handleGetPrImpact(storage, git, masking, staleness, ctxoRoot);
+  const prImpactHandler = withRecording("get_pr_impact", handleGetPrImpact(storage, git, masking, staleness, ctxoRoot), recorder);
   server.registerTool(
     "get_pr_impact",
     {
@@ -2348,16 +3152,14 @@ async function main() {
       },
       annotations: toolAnnotations
     },
-    (args2) => prImpactHandler(args2)
+    (args) => prImpactHandler(args)
   );
   server.resource("ctxo-status", "ctxo://status", async (uri) => ({
     contents: [{ uri: uri.href, text: "Ctxo MCP server is running." }]
   }));
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
 }
 main().catch((err) => {
-  log.error("Fatal: %s", err.message);
+  log4.error("Fatal: %s", err.message);
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map