@chiway/contextweaver 1.1.0 → 1.5.0

package/dist/chunk-ISVCQFB4.js

@@ -0,0 +1,223 @@
+import {
+  commonPrefixLength
+} from "./chunk-LB42CZEB.js";
+import {
+  ChunkContentLoader
+} from "./chunk-XFIM2T6S.js";
+import {
+  getVectorStore
+} from "./chunk-3BNHQV5W.js";
+import {
+  ensureIndexed,
+  formatTextResponse
+} from "./chunk-VWBKZ6QL.js";
+import {
+  generateProjectId,
+  initDb,
+  searchChunksFts
+} from "./chunk-PPLFJGO3.js";
+import {
+  logger
+} from "./chunk-JVKVSTQ3.js";
+
+// src/mcp/tools/getSymbolDefinition.ts
+import { z } from "zod";
+var getSymbolDefinitionSchema = z.object({
+  repo_path: z.string().describe(
+    "The absolute file system path to the repository root. (e.g., '/Users/dev/my-project')"
+  ),
+  symbol: z.string().min(1).describe("The exact symbol name to resolve."),
+  hint_path: z.string().optional().describe("Optional preferred path used to disambiguate same-name definitions."),
+  max_results: z.number().int().positive().max(20).optional().describe("Maximum number of definitions to return. Defaults to 3.")
+});
+var LANGUAGE_DEFINITION_PATTERNS = {
+  typescript: [
+    "function\\s+{symbol}\\b",
+    "class\\s+{symbol}\\b",
+    "(?:const|let|var)\\s+{symbol}\\b",
+    "interface\\s+{symbol}\\b",
+    "type\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b"
+  ],
+  javascript: [
+    "function\\s+{symbol}\\b",
+    "class\\s+{symbol}\\b",
+    "(?:const|let|var)\\s+{symbol}\\b"
+  ],
+  python: ["def\\s+{symbol}\\b", "class\\s+{symbol}\\b"],
+  go: ["func\\s+{symbol}\\b", "type\\s+{symbol}\\b", "const\\s+{symbol}\\b", "var\\s+{symbol}\\b"],
+  rust: [
+    "fn\\s+{symbol}\\b",
+    "struct\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b",
+    "const\\s+{symbol}\\b"
+  ],
+  java: [
+    "class\\s+{symbol}\\b",
+    "interface\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b",
+    "\\b{symbol}\\s*\\("
+  ],
+  csharp: [
+    "class\\s+{symbol}\\b",
+    "interface\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b",
+    "\\b{symbol}\\s*\\("
+  ],
+  cpp: ["class\\s+{symbol}\\b", "struct\\s+{symbol}\\b", "\\b{symbol}\\s*\\("],
+  c: ["\\b{symbol}\\s*\\("]
+};
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function breadcrumbTail(breadcrumb) {
+  return breadcrumb.split(">").pop()?.trim() ?? "";
+}
+function countLinesBefore(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+function computeEndLine(startLine, code) {
+  const normalized = code.replace(/\n+$/u, "");
+  if (!normalized) {
+    return startLine;
+  }
+  return startLine + normalized.split("\n").length - 1;
+}
+function detectLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  const langMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    c: "c",
+    cpp: "cpp",
+    h: "c",
+    hpp: "cpp",
+    cs: "csharp",
+    md: "markdown",
+    json: "json"
+  };
+  return langMap[ext] || ext || "plaintext";
+}
+function formatDefinition(candidate) {
+  const header = `## ${candidate.chunk.file_path} (L${candidate.startLine}-L${candidate.endLine})`;
+  const breadcrumb = candidate.chunk.breadcrumb ? `> ${candidate.chunk.breadcrumb}` : "";
+  const code = `\`\`\`${detectLanguage(candidate.chunk.file_path)}
+${candidate.code}
+\`\`\``;
+  return [header, breadcrumb, code].filter(Boolean).join("\n");
+}
+function hasDefinitionPattern(language, code, symbol) {
+  const patterns = LANGUAGE_DEFINITION_PATTERNS[language] ?? LANGUAGE_DEFINITION_PATTERNS.typescript;
+  return patterns.some((pattern) => {
+    const source = pattern.replaceAll("{symbol}", escapeRegex(symbol));
+    return new RegExp(source, "u").test(code);
+  });
+}
+function rankCandidates(a, b) {
+  if (a.breadcrumbExact !== b.breadcrumbExact) {
+    return a.breadcrumbExact ? -1 : 1;
+  }
+  if (a.prefixScore !== b.prefixScore) {
+    return b.prefixScore - a.prefixScore;
+  }
+  if (a.score !== b.score) {
+    return b.score - a.score;
+  }
+  return a.chunk.file_path.localeCompare(b.chunk.file_path);
+}
+async function handleGetSymbolDefinition(args, onProgress) {
+  const { repo_path, symbol, hint_path, max_results = 3 } = args;
+  const projectId = generateProjectId(repo_path);
+  logger.info({ repo_path, symbol, hint_path, max_results }, "MCP get-symbol-definition \u8C03\u7528\u5F00\u59CB");
+  await ensureIndexed(repo_path, projectId, { onProgress });
+  const db = initDb(projectId);
+  try {
+    const hits = searchChunksFts(db, symbol, Math.max(max_results * 5, 20));
+    const uniquePaths = Array.from(new Set(hits.map((hit) => hit.filePath)));
+    const vectorStore = await getVectorStore(projectId);
+    const chunkMap = await vectorStore.getFilesChunks(uniquePaths);
+    const chunkByKey = /* @__PURE__ */ new Map();
+    for (const [filePath, chunks] of chunkMap) {
+      for (const chunk of chunks) {
+        chunkByKey.set(`${filePath}#${chunk.chunk_index}`, chunk);
+      }
+    }
+    const slices = Array.from(chunkByKey.values()).map((chunk) => ({
+      filePath: chunk.file_path,
+      start_index: chunk.start_index,
+      end_index: chunk.end_index
+    }));
+    const loader = new ChunkContentLoader(db);
+    const codeMap = loader.loadMany(slices);
+    const fileContentStmt = db.prepare("SELECT content FROM files WHERE path = ?");
+    const fullFileCache = /* @__PURE__ */ new Map();
+    const candidates = /* @__PURE__ */ new Map();
+    for (const hit of hits) {
+      const chunk = chunkByKey.get(`${hit.filePath}#${hit.chunkIndex}`);
+      if (!chunk) {
+        continue;
+      }
+      const codeKey = ChunkContentLoader.key({
+        filePath: chunk.file_path,
+        start_index: chunk.start_index,
+        end_index: chunk.end_index
+      });
+      const code = codeMap.get(codeKey) ?? "";
+      if (!code) {
+        continue;
+      }
+      const breadcrumbExact = breadcrumbTail(chunk.breadcrumb) === symbol;
+      const definitionPattern = hasDefinitionPattern(chunk.language, code, symbol);
+      if (!breadcrumbExact && !definitionPattern) {
+        continue;
+      }
+      let fullContent = fullFileCache.get(chunk.file_path);
+      if (fullContent === void 0) {
+        const row = fileContentStmt.get(chunk.file_path);
+        fullContent = row?.content ?? "";
+        fullFileCache.set(chunk.file_path, fullContent);
+      }
+      const startLine = countLinesBefore(fullContent, chunk.start_index);
+      const candidate = {
+        chunk,
+        code,
+        score: hit.score,
+        breadcrumbExact,
+        prefixScore: hint_path ? commonPrefixLength(hint_path, chunk.file_path) : 0,
+        startLine,
+        endLine: computeEndLine(startLine, code)
+      };
+      const key = `${chunk.file_path}#${chunk.chunk_index}`;
+      const existing = candidates.get(key);
+      if (!existing || rankCandidates(candidate, existing) < 0) {
+        candidates.set(key, candidate);
+      }
+    }
+    const ranked = Array.from(candidates.values()).sort(rankCandidates).slice(0, max_results);
+    const body = ranked.length > 0 ? ranked.map((candidate) => formatDefinition(candidate)).join("\n\n---\n\n") : "No likely symbol definitions found.";
+    return formatTextResponse(
+      `Found ${ranked.length} symbol definitions for "${symbol}"
+
+${body}`
+    );
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  getSymbolDefinitionSchema,
+  handleGetSymbolDefinition
+};

package/dist/chunk-IZ6IUHNN.js

@@ -0,0 +1,77 @@
+import {
+  DEFAULT_CONFIG,
+  SEARCH_CONFIG_BOUNDS
+} from "./chunk-BFCIZ52F.js";
+
+// src/search/loadConfig.ts
+import crypto from "crypto";
+var SEARCH_ENV_MAP = {
+  CW_SEARCH_WVEC: "wVec",
+  CW_SEARCH_WLEX: "wLex",
+  CW_SEARCH_RERANK_TOP_N: "rerankTopN",
+  CW_SEARCH_MAX_TOTAL_CHARS: "maxTotalChars",
+  CW_SEARCH_VECTOR_TOP_K: "vectorTopK",
+  CW_SEARCH_SMART_MAX_K: "smartMaxK",
+  CW_SEARCH_IMPORT_FILES_PER_SEED: "importFilesPerSeed"
+};
+var SEARCH_FINGERPRINT_FIELDS = Object.keys(DEFAULT_CONFIG);
+function normalizeWeight(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+function clampValue(key, rawValue) {
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  const bounds = SEARCH_CONFIG_BOUNDS[key];
+  if (!bounds) {
+    return parsed;
+  }
+  const clamped = Math.min(bounds.max, Math.max(bounds.min, parsed));
+  return bounds.integer ? Math.round(clamped) : clamped;
+}
+function getSearchConfigOverrides() {
+  const overrides = {};
+  const explicitWeights = {};
+  for (const [envKey, configKey] of Object.entries(SEARCH_ENV_MAP)) {
+    const rawValue = process.env[envKey];
+    if (rawValue === void 0 || rawValue.trim() === "") {
+      continue;
+    }
+    const parsed = clampValue(configKey, rawValue);
+    if (parsed === void 0) {
+      continue;
+    }
+    if (configKey === "wVec" || configKey === "wLex") {
+      explicitWeights[configKey] = parsed;
+      continue;
+    }
+    overrides[configKey] = parsed;
+  }
+  if (explicitWeights.wVec !== void 0 && explicitWeights.wLex === void 0) {
+    overrides.wVec = explicitWeights.wVec;
+    overrides.wLex = normalizeWeight(1 - explicitWeights.wVec);
+  } else if (explicitWeights.wLex !== void 0 && explicitWeights.wVec === void 0) {
+    overrides.wLex = explicitWeights.wLex;
+    overrides.wVec = normalizeWeight(1 - explicitWeights.wLex);
+  } else {
+    if (explicitWeights.wVec !== void 0) {
+      overrides.wVec = explicitWeights.wVec;
+    }
+    if (explicitWeights.wLex !== void 0) {
+      overrides.wLex = explicitWeights.wLex;
+    }
+  }
+  return overrides;
+}
+function createSearchConfigFingerprint(config) {
+  const payload = Object.fromEntries(
+    SEARCH_FINGERPRINT_FIELDS.map((field) => [field, config[field]])
+  );
+  return crypto.createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+
+export {
+  getSearchConfigOverrides,
+  createSearchConfigFingerprint
+};

package/dist/{chunk-AMQQK4P7.js → chunk-JVKVSTQ3.js}

@@ -1,7 +1,7 @@
 import {
   isDev,
   isMcpMode
-} from "./chunk-RJURH22T.js";
+} from "./chunk-SKBAE26T.js";
 
 // src/utils/logger.ts
 import fs from "fs";
@@ -168,4 +168,3 @@ export {
   logger,
   isDebugEnabled
 };
-//# sourceMappingURL=chunk-AMQQK4P7.js.map

package/dist/chunk-LB42CZEB.js

@@ -0,0 +1,18 @@
+// src/search/resolvers/types.ts
+function commonPrefixLength(path1, path2) {
+  const parts1 = path1.split("/");
+  const parts2 = path2.split("/");
+  let count = 0;
+  for (let i = 0; i < Math.min(parts1.length, parts2.length); i++) {
+    if (parts1[i] === parts2[i]) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
+export {
+  commonPrefixLength
+};