@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/{chunk-NQZUSEAR.js → chunk-GS7LIT34.js}

@@ -7,10 +7,11 @@ import {
 import {
   connectEmbedDaemon,
   embedBatchViaClient
-} from "./chunk-UQUUNGTP.js";
+} from "./chunk-NUK7EEN5.js";
 import {
-  EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+  EXE_AI_DIR,
+  loadConfigSync
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/code-context-index.ts
 import crypto from "crypto";
@@ -38,6 +39,14 @@ function loadVectorStore(projectRoot) {
 function saveVectorStore(projectRoot, store) {
   writeFileSync(vectorStorePath(projectRoot), JSON.stringify(store));
 }
+function currentEmbeddingModelId() {
+  try {
+    const cfg = loadConfigSync();
+    return process.env.EXE_EMBED_MODEL ?? cfg.modelFile ?? "unknown";
+  } catch {
+    return process.env.EXE_EMBED_MODEL ?? "unknown";
+  }
+}
 function cosineSimilarity(a, b) {
   let dot = 0, normA = 0, normB = 0;
   for (let i = 0; i < a.length; i++) {
@@ -51,6 +60,15 @@ function cosineSimilarity(a, b) {
 async function embedSymbols(index) {
   const rootHash = hashText(index.projectRoot).slice(0, 16);
   const existing = loadVectorStore(index.projectRoot);
+  const currentModel = currentEmbeddingModelId();
+  const existingModel = existing?.model;
+  let reusedExisting = false;
+  const resolveStoreModel = () => (
+    // If we reused vectors from a synced store whose model differs from the local
+    // model, the store carries FOREIGN vectors — preserve the original stamp so the
+    // search guard rejects them (lexical fallback) instead of trusting relabeled-local vectors.
+    reusedExisting && existingModel && existingModel !== currentModel ? existingModel : currentModel
+  );
   const store = {
     version: VECTOR_STORE_VERSION,
     projectRootHash: rootHash,
@@ -61,12 +79,16 @@ async function embedSymbols(index) {
     for (const symbol of file.symbols) {
       if (existing?.vectors[symbol.id]) {
         store.vectors[symbol.id] = existing.vectors[symbol.id];
+        reusedExisting = true;
       } else {
         allSymbols.push({ id: symbol.id, text: symbol.summary || `${symbol.kind} ${symbol.name} in ${symbol.filePath}` });
       }
     }
   }
   if (allSymbols.length === 0) {
+    const firstVec2 = Object.values(store.vectors)[0];
+    if (firstVec2) store.dim = firstVec2.length;
+    store.model = resolveStoreModel();
     saveVectorStore(index.projectRoot, store);
     return store;
   }
@@ -88,12 +110,16 @@ async function embedSymbols(index) {
     } catch {
     }
   }
+  const firstVec = Object.values(store.vectors)[0];
+  if (firstVec) store.dim = firstVec.length;
+  store.model = resolveStoreModel();
   saveVectorStore(index.projectRoot, store);
   return store;
 }
 var INDEX_VERSION = 2;
 var DEFAULT_MAX_FILES = 5e3;
 var INDEX_YIELD_EVERY_FILES = 25;
+var GIT_PATHSPEC_BATCH = 200;
 var DEFAULT_STALE_AFTER_DAYS = 7;
 var STALE_AFTER_MS = Number(process.env.EXE_CODE_CONTEXT_STALE_AFTER_DAYS) > 0 ? Math.floor(Number(process.env.EXE_CODE_CONTEXT_STALE_AFTER_DAYS)) * 24 * 60 * 60 * 1e3 : DEFAULT_STALE_AFTER_DAYS * 24 * 60 * 60 * 1e3;
 var IGNORE_SEGMENTS = /* @__PURE__ */ new Set([
@@ -215,17 +241,117 @@ function parseImportPaths(importText) {
   }
   return paths;
 }
-function resolveImport(fromFile, importPath, allFiles) {
-  if (!importPath.startsWith(".")) return null;
-  const base = path.posix.normalize(path.posix.join(path.posix.dirname(fromFile.replaceAll(path.sep, "/")), importPath));
-  const withoutKnownExt = base.replace(/\.(?:[a-z0-9]+)$/i, "");
-  const candidates = [base];
-  for (const ext of ["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "cs", "cpp", "c", "rb", "php", "swift", "kt", "scala", "sql", "md", "json", "yaml", "yml"]) {
-    candidates.push(`${withoutKnownExt}.${ext}`, `${base}.${ext}`);
+var MODULE_EXTENSIONS = ["ts", "tsx", "js", "jsx", "py", "rs", "go", "java", "cs", "cpp", "c", "rb", "php", "swift", "kt", "scala", "sql", "md", "json", "yaml", "yml"];
+var MODULE_INDEX_NAMES = ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"];
+var tsconfigAliasCache = /* @__PURE__ */ new Map();
+function tsconfigStamp(projectRoot) {
+  try {
+    const stat = statSync(path.join(projectRoot, "tsconfig.json"));
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return { mtimeMs: -1, size: -1 };
+  }
+}
+function stripJsonComments(text) {
+  let out = text.replace(/\/\*[\s\S]*?\*\//g, "");
+  out = out.replace(/(^|[^:"'\\])\/\/[^\n\r]*/g, "$1");
+  out = out.replace(/,(\s*[}\]])/g, "$1");
+  return out;
+}
+function loadTsconfigAliases(projectRoot) {
+  const stamp = tsconfigStamp(projectRoot);
+  const cached = tsconfigAliasCache.get(projectRoot);
+  if (cached && cached.mtimeMs === stamp.mtimeMs && cached.size === stamp.size) return cached.aliases;
+  let result = null;
+  try {
+    const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+      const parsed = JSON.parse(stripJsonComments(readFileSync(tsconfigPath, "utf8")));
+      const co = parsed.compilerOptions ?? {};
+      const hasBaseUrl = typeof co.baseUrl === "string";
+      const baseUrl = hasBaseUrl ? path.posix.normalize(co.baseUrl.replaceAll(path.sep, "/")).replace(/^\.\/?/, "").replace(/\/+$/, "") : "";
+      const paths = [];
+      if (co.paths && typeof co.paths === "object") {
+        for (const [pattern, targets] of Object.entries(co.paths)) {
+          if (Array.isArray(targets)) {
+            const strs = targets.filter((t) => typeof t === "string");
+            if (strs.length > 0) paths.push({ pattern, targets: strs });
+          }
+        }
+      }
+      if (hasBaseUrl || paths.length > 0) result = { baseUrl: baseUrl === "." ? "" : baseUrl, hasBaseUrl, paths };
+    }
+  } catch {
+    result = null;
   }
-  for (const indexName of ["index.ts", "index.tsx", "index.js", "mod.rs", "__init__.py"]) candidates.push(path.posix.join(base, indexName));
+  tsconfigAliasCache.set(projectRoot, { ...stamp, aliases: result });
+  return result;
+}
+function tsconfigAliasFingerprint(aliases) {
+  if (!aliases) return "none";
+  const normalized = {
+    baseUrl: aliases.baseUrl,
+    hasBaseUrl: aliases.hasBaseUrl,
+    paths: [...aliases.paths].sort((a, b) => a.pattern.localeCompare(b.pattern)).map((p) => ({ pattern: p.pattern, targets: p.targets }))
+  };
+  return hashText(JSON.stringify(normalized)).slice(0, 16);
+}
+function resolveModuleFile(base, allFiles) {
+  const normBase = path.posix.normalize(base);
+  const withoutKnownExt = normBase.replace(/\.(?:[a-z0-9]+)$/i, "");
+  const candidates = [normBase];
+  for (const ext of MODULE_EXTENSIONS) candidates.push(`${withoutKnownExt}.${ext}`, `${normBase}.${ext}`);
+  for (const indexName of MODULE_INDEX_NAMES) candidates.push(path.posix.join(normBase, indexName));
   return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
 }
+function resolveViaAliases(importPath, aliases, allFiles) {
+  for (const { pattern, targets } of aliases.paths) {
+    const starIdx = pattern.indexOf("*");
+    let captured = null;
+    if (starIdx === -1) {
+      if (pattern === importPath) captured = "";
+      else continue;
+    } else {
+      const prefix = pattern.slice(0, starIdx);
+      const suffix = pattern.slice(starIdx + 1);
+      if (importPath.length >= prefix.length + suffix.length && importPath.startsWith(prefix) && importPath.endsWith(suffix)) {
+        captured = importPath.slice(prefix.length, importPath.length - suffix.length);
+      } else continue;
+    }
+    for (const target of targets) {
+      const substituted = target.includes("*") ? target.replace("*", captured ?? "") : target;
+      const base = path.posix.join(aliases.baseUrl, substituted.replaceAll(path.sep, "/"));
+      const hit = resolveModuleFile(base, allFiles);
+      if (hit) return hit;
+    }
+  }
+  if (aliases.hasBaseUrl) {
+    const hit = resolveModuleFile(path.posix.join(aliases.baseUrl, importPath.replaceAll(path.sep, "/")), allFiles);
+    if (hit) return hit;
+  }
+  return null;
+}
+function resolveImport(fromFile, importPath, allFiles, aliases) {
+  if (importPath.startsWith(".")) {
+    const base = path.posix.join(path.posix.dirname(fromFile.replaceAll(path.sep, "/")), importPath);
+    return resolveModuleFile(base, allFiles);
+  }
+  if (aliases) return resolveViaAliases(importPath, aliases, allFiles);
+  return null;
+}
+function resolveImportsFor(fromFile, imports, allFiles, aliases) {
+  return imports.map((importPath) => resolveImport(fromFile, importPath, allFiles, aliases)).filter((file) => Boolean(file));
+}
+function reconcileResolvedImports(files, allFiles, aliases) {
+  let mutated = false;
+  for (const [rel, record] of Object.entries(files)) {
+    const next = resolveImportsFor(rel, record.imports, allFiles, aliases);
+    if (next.length === record.resolvedImports.length && next.every((value, i) => value === record.resolvedImports[i])) continue;
+    files[rel] = { ...record, resolvedImports: next };
+    mutated = true;
+  }
+  return mutated;
+}
 function symbolId(filePath, chunk) {
   return hashText(`${filePath}:${chunk.kind}:${chunk.name}:${chunk.startLine}:${chunk.endLine}`).slice(0, 24);
 }
@@ -258,7 +384,7 @@ function stalenessFor(indexedAt) {
 function yieldToEventLoop() {
   return new Promise((resolve) => setImmediate(resolve));
 }
-function buildFileRecord(projectRoot, relPath, allFiles, previous) {
+function buildFileRecord(projectRoot, relPath, allFiles, previous, aliases) {
   const absPath = path.join(projectRoot, relPath);
   let stat;
   try {
@@ -276,7 +402,7 @@ function buildFileRecord(projectRoot, relPath, allFiles, previous) {
   }
   const chunks = chunkSourceFile(source, relPath);
   const imports = chunks.filter((chunk) => chunk.kind === "import").flatMap((chunk) => parseImportPaths(chunk.text));
-  const resolvedImports = imports.map((importPath) => resolveImport(relPath, importPath, allFiles)).filter((file) => Boolean(file));
+  const resolvedImports = resolveImportsFor(relPath, imports, allFiles, aliases);
   const symbols = chunks.filter((chunk) => chunk.name !== "(unknown)").map((chunk) => ({
     id: symbolId(relPath, chunk),
     name: chunk.name,
@@ -298,19 +424,23 @@ function buildCodeContextIndex(options = {}) {
   const previous = options.force ? null : loadIndex(projectRoot);
   const files = listCodeFiles(projectRoot, maxFiles);
   const allFiles = new Set(files.map((file) => file.replaceAll(path.sep, "/")));
+  const aliases = loadTsconfigAliases(projectRoot);
+  const aliasFingerprint = tsconfigAliasFingerprint(aliases);
+  const reusable = previous && previous.aliasFingerprint === aliasFingerprint ? previous : null;
   const fileRecords = {};
   let rebuiltFiles = 0;
   let reusedFiles = 0;
   let skippedFiles = 0;
   for (const rel of files) {
     const normalized = rel.replaceAll(path.sep, "/");
-    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
+    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, reusable?.files[normalized], aliases);
     if (record) {
       fileRecords[normalized] = record;
       if (reused) reusedFiles++;
       else rebuiltFiles++;
     } else skippedFiles++;
   }
+  if (reusedFiles > 0) reconcileResolvedImports(fileRecords, allFiles, aliases);
   const languageBreakdown = {};
   for (const file of Object.values(fileRecords)) languageBreakdown[file.language] = (languageBreakdown[file.language] ?? 0) + 1;
   const index = {
@@ -318,6 +448,7 @@ function buildCodeContextIndex(options = {}) {
     projectRoot,
     rootHash: hashText(projectRoot).slice(0, 16),
     branch,
+    aliasFingerprint,
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
     stats: { filesSeen: files.length, filesIndexed: Object.keys(fileRecords).length, rebuiltFiles, reusedFiles, skippedFiles, languageBreakdown },
     files: fileRecords
@@ -332,6 +463,9 @@ async function buildCodeContextIndexAsync(options = {}) {
   const previous = options.force ? null : loadIndex(projectRoot);
   const files = listCodeFiles(projectRoot, maxFiles);
   const allFiles = new Set(files.map((file) => file.replaceAll(path.sep, "/")));
+  const aliases = loadTsconfigAliases(projectRoot);
+  const aliasFingerprint = tsconfigAliasFingerprint(aliases);
+  const reusable = previous && previous.aliasFingerprint === aliasFingerprint ? previous : null;
   const fileRecords = {};
   let rebuiltFiles = 0;
   let reusedFiles = 0;
@@ -341,13 +475,14 @@ async function buildCodeContextIndexAsync(options = {}) {
       await yieldToEventLoop();
     }
     const normalized = files[i].replaceAll(path.sep, "/");
-    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
+    const { record, reused } = buildFileRecord(projectRoot, normalized, allFiles, reusable?.files[normalized], aliases);
     if (record) {
       fileRecords[normalized] = record;
       if (reused) reusedFiles++;
       else rebuiltFiles++;
     } else skippedFiles++;
   }
+  if (reusedFiles > 0) reconcileResolvedImports(fileRecords, allFiles, aliases);
   const languageBreakdown = {};
   for (const file of Object.values(fileRecords)) languageBreakdown[file.language] = (languageBreakdown[file.language] ?? 0) + 1;
   const index = {
@@ -355,6 +490,7 @@ async function buildCodeContextIndexAsync(options = {}) {
     projectRoot,
     rootHash: hashText(projectRoot).slice(0, 16),
     branch,
+    aliasFingerprint,
     indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
     stats: { filesSeen: files.length, filesIndexed: Object.keys(fileRecords).length, rebuiltFiles, reusedFiles, skippedFiles, languageBreakdown },
     files: fileRecords
@@ -366,7 +502,8 @@ function loadOrBuildCodeContextIndex(options = {}) {
   const projectRoot = normalizeProjectRoot(options.projectRoot);
   if (!options.force) {
     const loaded = loadIndex(projectRoot);
-    if (loaded) {
+    const aliasFresh = loaded ? (loaded.aliasFingerprint ?? "none") === tsconfigAliasFingerprint(loadTsconfigAliases(projectRoot)) : false;
+    if (loaded && aliasFresh) {
       const currentFiles = listCodeFiles(projectRoot, options.maxFiles ?? DEFAULT_MAX_FILES);
       const unchanged = currentFiles.every((rel) => {
         const normalized = rel.replaceAll(path.sep, "/");
@@ -384,6 +521,93 @@ function loadOrBuildCodeContextIndex(options = {}) {
   }
   return buildCodeContextIndex(options);
 }
+function isCodeContextCandidatePath(relPath) {
+  const normalized = relPath.replaceAll(path.sep, "/");
+  return isChunkable(normalized) && !shouldIgnore(normalized);
+}
+function gitTrackedAmong(projectRoot, relPaths) {
+  if (relPaths.length === 0) return /* @__PURE__ */ new Set();
+  const tracked = /* @__PURE__ */ new Set();
+  for (let i = 0; i < relPaths.length; i += GIT_PATHSPEC_BATCH) {
+    const batch = relPaths.slice(i, i + GIT_PATHSPEC_BATCH);
+    const result = spawnSync("git", ["--literal-pathspecs", "ls-files", "-z", "--", ...batch], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      timeout: 5e3,
+      maxBuffer: 1024 * 1024
+    });
+    if (result.status !== 0) return null;
+    for (const line of result.stdout.split("\0")) {
+      const rel = line.trim().replaceAll(path.sep, "/");
+      if (rel) tracked.add(rel);
+    }
+  }
+  return tracked;
+}
+function applyCodeContextChanges(projectRoot, changedRelPaths, options = {}) {
+  void options;
+  const root = normalizeProjectRoot(projectRoot);
+  const index = loadIndex(root);
+  if (!index) return null;
+  const aliases = loadTsconfigAliases(root);
+  const aliasFingerprint = tsconfigAliasFingerprint(aliases);
+  const aliasChanged = (index.aliasFingerprint ?? "none") !== aliasFingerprint;
+  const allFiles = new Set(Object.keys(index.files));
+  const normalizedChanges = [...new Set(changedRelPaths.map((rel) => rel.replaceAll(path.sep, "/")))];
+  const candidates = normalizedChanges.filter((rel) => isCodeContextCandidatePath(rel));
+  const tracked = gitTrackedAmong(root, candidates);
+  const admits = (rel) => isCodeContextCandidatePath(rel) && (tracked ? tracked.has(rel) : existsSync(path.join(root, rel)));
+  let changed = false;
+  let membershipChanged = false;
+  for (const rel of normalizedChanges) {
+    if (!admits(rel)) {
+      if (index.files[rel]) {
+        delete index.files[rel];
+        changed = true;
+      }
+      if (allFiles.delete(rel)) membershipChanged = true;
+      continue;
+    }
+    if (!allFiles.has(rel) && existsSync(path.join(root, rel))) {
+      allFiles.add(rel);
+      membershipChanged = true;
+    }
+  }
+  for (const rel of normalizedChanges) {
+    if (!admits(rel)) continue;
+    const known = Boolean(index.files[rel]);
+    const { record } = buildFileRecord(root, rel, allFiles, index.files[rel], aliases);
+    if (record) {
+      index.files[rel] = record;
+      changed = true;
+      if (!known) membershipChanged = true;
+    } else if (known) {
+      delete index.files[rel];
+      allFiles.delete(rel);
+      changed = true;
+      membershipChanged = true;
+    } else {
+      if (allFiles.delete(rel)) membershipChanged = true;
+    }
+  }
+  if (membershipChanged || aliasChanged) {
+    if (reconcileResolvedImports(index.files, allFiles, aliases)) changed = true;
+  }
+  if (aliasChanged) {
+    index.aliasFingerprint = aliasFingerprint;
+    changed = true;
+  }
+  if (!changed) return index;
+  const languageBreakdown = {};
+  for (const file of Object.values(index.files)) {
+    languageBreakdown[file.language] = (languageBreakdown[file.language] ?? 0) + 1;
+  }
+  index.stats.filesIndexed = Object.keys(index.files).length;
+  index.stats.languageBreakdown = languageBreakdown;
+  index.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveIndex(index);
+  return index;
+}
 function normalizeLanguage(language) {
   return language.toLowerCase().replace(/^c\+\+$/, "cpp").replace(/^c#$/, "csharp").replace(/^js$/, "javascript").replace(/^ts$/, "typescript");
 }
@@ -536,13 +760,16 @@ async function searchCodeContextSemantic(query, options = {}) {
   } catch {
   }
   if (!queryVector) return lexicalSearch(query, options);
+  if (vectorStore.model && vectorStore.model !== currentEmbeddingModelId()) {
+    return lexicalSearch(query, options);
+  }
   const files = filteredFiles(index, options);
   const candidates = [];
   for (const file of files) {
     for (const symbol of file.symbols) {
       const lexical = scoreSymbol(symbol, terms);
       const vec = vectorStore.vectors[symbol.id];
-      const vectorScore = vec ? cosineSimilarity(queryVector, vec) : 0;
+      const vectorScore = vec && vec.length === queryVector.length ? cosineSimilarity(queryVector, vec) : 0;
       if (lexical.score > 0 || vectorScore > 0.3) {
         candidates.push({
           symbol,
@@ -699,6 +926,8 @@ export {
   buildCodeContextIndex,
   buildCodeContextIndexAsync,
   loadOrBuildCodeContextIndex,
+  isCodeContextCandidatePath,
+  applyCodeContextChanges,
   searchCodeContext,
   searchCodeContextSemantic,
   buildCodeContextIndexWithEmbeddings,

package/dist/{chunk-XTWHNLGD.js → chunk-GZOG2MAX.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-WNBZJSQT.js";
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 import {
   atomicWriteJsonSync,
   ensurePrivateDirSync

package/dist/{chunk-E5HAY3DQ.js → chunk-HDLAB7W3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4QCFFW2H.js";
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/local-secret-inventory.ts
 import {