@alucard_24/pi-codeindex 0.0.0-stage → 1.1.0

package/src/graph.js

@@ -0,0 +1,306 @@
+// L2 — grafo sintattico verificabile.
+//
+// Regola di precisione: un arco esiste solo se la specifica dell'import risolve
+// in **esattamente un** file indicizzato. Se il nome è ambiguo o il target non è
+// nell'indice, l'arco non viene emesso (meglio un fatto assente che uno sbagliato).
+// Niente risoluzione di package esterni, alias di build, o path di include passati
+// da flag di compilazione: sono indovinelli, non fatti.
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { langOf } from './chunker.js';
+import { lsFiles } from './util.js';
+
+export const GRAPH_VERSION = 1;
+
+const JS_EXT = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
+const JS_INDEX = JS_EXT.map((e) => `/index${e}`);
+const C_EXT = ['.h', '.hpp', '.hh', '.hxx', '.c', '.cc', '.cpp', '.cxx'];
+
+const dirOf = (p) => {
+  const i = p.lastIndexOf('/');
+  return i === -1 ? '' : p.slice(0, i);
+};
+const join = (a, b) => (a ? `${a}/${b}` : b);
+const normalize = (p) => path.posix.normalize(p);
+
+/**
+ * Indice dei suffissi per gli include C/C++: senza i flag di compilazione non
+ * conosciamo le include-dir, quindi un arco è verificato solo se la specifica
+ * corrisponde a **un solo** file dell'intero repo. È la regola che tiene la
+ * precisione sopra il gate invece di indovinare la radice giusta.
+ */
+export function makeSuffixLookup(files) {
+  const byBase = new Map();
+  for (const f of files) {
+    const b = path.posix.basename(f);
+    if (!byBase.has(b)) byBase.set(b, []);
+    byBase.get(b).push(f);
+  }
+  return (spec) => {
+    const clean = normalize(spec).replace(/^\.\//, '');
+    const list = byBase.get(path.posix.basename(clean)) ?? [];
+    return list.filter((f) => f === clean || f.endsWith(`/${clean}`));
+  };
+}
+
+/** Righe di import di un file, per famiglia. Nessun parser: solo forma sintattica. */
+export function extractImports(text, lang) {
+  const out = [];
+  const lines = String(text ?? '').split('\n');
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+
+    if (lang === 'js' || lang === 'ts') {
+      // from '...' (import/export), import('...'), require('...')
+      const m = /\b(?:from|import|require)\s*\(?\s*['"]([^'"]+)['"]/.exec(line);
+      if (m) out.push({ spec: m[1], style: 'js' });
+      continue;
+    }
+
+    if (lang === 'py') {
+      let m = /^from\s+(\.*)([A-Za-z0-9_.]*)\s+import\b/.exec(line);
+      if (m) {
+        out.push({ spec: `${m[1]}${m[2]}`, style: 'py-from' });
+        continue;
+      }
+      m = /^import\s+([A-Za-z0-9_.]+(?:\s*,\s*[A-Za-z0-9_.]+)*)/.exec(line);
+      if (m) for (const s of m[1].split(',')) out.push({ spec: s.trim(), style: 'py-import' });
+      continue;
+    }
+
+    if (lang === 'c' || lang === 'cpp' || lang === 'cs') {
+      const m = /^#\s*include\s*([<"])([^>"]+)[>"]/.exec(line);
+      if (m) out.push({ spec: m[2], style: m[1] === '"' ? 'c-quoted' : 'c-angle' });
+      continue;
+    }
+
+    if (lang === 'go') {
+      const m = /^(?:import\s+)?["']([^"']+)["']\s*$/.exec(line);
+      if (m) out.push({ spec: m[1], style: 'go' });
+    }
+  }
+  return out;
+}
+
+/**
+ * Specifica -> file target, solo se unico nell'indice.
+ * @param {string} from path relativo del file che importa
+ * @param {{spec: string, style: string}} imp
+ * @param {Set<string>} universe path indicizzati
+ */
+export function resolveImport(from, imp, universe, suffixOf = null) {
+  const fromDir = dirOf(from);
+
+  if (imp.style === 'js') {
+    const spec = imp.spec;
+    if (!spec.startsWith('./') && !spec.startsWith('../')) return null; // package esterno
+    const base = normalize(join(fromDir, spec));
+    const candidates = [base, ...JS_EXT.map((e) => base + e), ...JS_INDEX.map((e) => base + e)];
+    const hits = candidates.filter((c) => universe.has(c));
+    return hits.length === 1 ? hits[0] : null;
+  }
+
+  if (imp.style === 'py-from') {
+    const spec = imp.spec;
+    const dots = /^\.*/.exec(spec)[0].length;
+    const rest = spec.slice(dots);
+    let baseDir = fromDir;
+    for (let i = 1; i < dots; i++) baseDir = dirOf(baseDir);
+    const base = rest ? normalize(join(baseDir, rest.replace(/\./g, '/'))) : baseDir;
+    const candidates = new Set([`${base}.py`, `${base}/__init__.py`]);
+    if (!rest) candidates.add(`${fromDir}/__init__.py`);
+    const hits = [...candidates].filter((c) => universe.has(c));
+    return hits.length === 1 ? hits[0] : null;
+  }
+
+  if (imp.style === 'py-import') {
+    const spec = imp.spec;
+    if (!spec || spec.startsWith('.')) return null;
+    const base = spec.replace(/\./g, '/');
+    const candidates = [`${base}.py`, `${base}/__init__.py`];
+    const hits = candidates.filter((c) => universe.has(c));
+    return hits.length === 1 ? hits[0] : null;
+  }
+
+  if (imp.style === 'c-quoted' || imp.style === 'c-angle') {
+    const spec = imp.spec.replace(/\\/g, '/');
+    // Per `"..."` la semantica C cerca prima nella directory dell'includer:
+    // se lì c'è esattamente un file, l'arco è verificato senza indovinare.
+    if (imp.style === 'c-quoted') {
+      const local = normalize(join(fromDir, spec));
+      if (universe.has(local)) return local;
+      if (!spec.startsWith('../') && universe.has(normalize(spec))) return normalize(spec);
+    }
+    // Altrimenti: solo suffisso unico nell'intero repo.
+    if (!suffixOf) return null;
+    const hits = suffixOf(spec);
+    return hits.length === 1 ? hits[0] : null;
+  }
+
+  if (imp.style === 'go') {
+    // Senza il module path del go.mod una specifica Go non è verificabile.
+    return null;
+  }
+
+  return null;
+}
+
+/** Aggiunge un arco, scartando self-loop e target fuori dall'indice. */
+function addEdge(map, from, to) {
+  if (!to || to === from) return false;
+  if (!map.has(from)) map.set(from, new Set());
+  map.get(from).add(to);
+  return true;
+}
+
+/**
+ * Costruisce i due versi del grafo leggendo i file indicizzati dal disco.
+ * @returns {Promise<{edges: Map<string, Set<string>>, reverse: Map<string, Set<string>>, stats: object}>}
+ */
+export async function buildGraph(root, index, { signal = null, allFiles = null } = {}) {
+  // Universo = file tracciati dal repo, non solo quelli indicizzati: un header
+  // fuori dal cap è comunque un target legittimo di un import.
+  const tracked = allFiles ?? lsFiles(root) ?? index.chunks.map((c) => c.path);
+  const universe = new Set(tracked);
+  const suffixOf = makeSuffixLookup(tracked);
+  const edges = new Map();
+  const reverse = new Map();
+  const stats = { files: 0, filesRead: 0, imports: 0, resolved: 0, ambiguous: 0, external: 0 };
+
+  for (const rel of universe) {
+    signal?.throwIfAborted();
+    stats.files++;
+    const lang = langOf(rel);
+    if (!['js', 'ts', 'py', 'c', 'cpp', 'cs', 'go'].includes(lang)) continue;
+    let text;
+    try {
+      text = await fs.readFile(path.join(root, rel), 'utf8');
+    } catch {
+      continue;
+    }
+    stats.filesRead++;
+    for (const imp of extractImports(text, lang)) {
+      stats.imports++;
+      const target = resolveImport(rel, imp, universe, suffixOf);
+      if (!target) {
+        if (imp.style === 'js' && !/^\.\.?\//.test(imp.spec)) stats.external++;
+        else stats.ambiguous++;
+        continue;
+      }
+      if (addEdge(edges, rel, target)) {
+        addEdge(reverse, target, rel);
+        stats.resolved++;
+      }
+    }
+  }
+
+  return { edges, reverse, stats, version: GRAPH_VERSION };
+}
+
+/** Import diretti di un file (ordinati, stabili). */
+const DEF_KINDS = new Set(['function', 'method', 'class', 'type', 'struct', 'interface', 'enum', 'impl', 'event']);
+
+/**
+ * Bundle di contesto (Fase 4.5): ai primi `top` risultati aggiunge import,
+ * importatori e chiamanti euristici del simbolo. Un round-trip invece di una
+ * catena grep+read. I chiamanti restano etichettati come euristici.
+ */
+export async function buildBundle(root, index, results, graph, {
+  top = 3,
+  maxImports = 6,
+  maxImporters = 4,
+  maxCallers = 5,
+  signal = null,
+} = {}) {
+  for (const r of results.slice(0, top)) {
+    const ctx = {
+      imports: importsOf(graph, r.path).slice(0, maxImports),
+      importers: importersOf(graph, r.path).slice(0, maxImporters),
+      callers: [],
+      callersTruncated: false,
+    };
+    if (r.symbol && DEF_KINDS.has(r.kind)) {
+      const found = await findCallers(root, index, r.symbol, { limit: maxCallers + 1, signal });
+      // La definizione stessa non è un chiamante.
+      ctx.callers = found.callers
+        .filter((c) => !(c.path === r.path && c.container === r.symbol))
+        .slice(0, maxCallers);
+      ctx.callersTruncated = found.truncated;
+    }
+    r.context = ctx;
+  }
+  return results;
+}
+
+export function importsOf(graph, rel) {
+  return [...(graph.edges.get(rel) ?? [])].sort();
+}
+
+/** Chi importa questo file. */
+export function importersOf(graph, rel) {
+  return [...(graph.reverse.get(rel) ?? [])].sort();
+}
+
+/**
+ * L3 — chiamanti euristici: occorrenze dell'identificatore nei file indicizzati,
+ * raggruppate per simbolo contenitore. Etichettate `heuristic` perché è grep
+ * con il raggruppamento, non un call graph: commenti e stringhe non sono distinti.
+ */
+const COMMENT_LINE = /^\s*(?:\/\/|#(?!include)|\*|\/\*|--|;)/;
+// Un import non è un chiamante: gli archi import sono già il livello 2.
+const IMPORT_LINE = /^\s*(?:import\b|from\b|export\b.*\bfrom\b|const\b.*\brequire\()/;
+// Nemmeno una lista di re-export (`AREAS, TITLE_RE, parseSections, …`) è un chiamante.
+const BARE_LIST_LINE = /^[\w$]+(?:\s*,\s*[\w$]+)*,?$/;
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+export async function findCallers(root, index, symbol, { limit = 20, signal = null } = {}) {
+  if (!symbol || !/^[A-Za-z_$][\w$]*$/.test(symbol)) return { callers: [], scanned: 0 };
+  const re = new RegExp(`(?<![\\w$])${escapeRe(symbol)}(?![\\w$])`);
+  // Indice per path: range dei chunk, così una riga si mappa al simbolo contenitore.
+  const byPath = new Map();
+  for (const c of index.chunks) {
+    if (!byPath.has(c.path)) byPath.set(c.path, []);
+    byPath.get(c.path).push(c);
+  }
+  const callers = [];
+  let scanned = 0;
+  let files = 0;
+
+  for (const [rel, chunks] of byPath) {
+    if (chunks[0].lang === 'md') continue;
+    signal?.throwIfAborted();
+    let text;
+    try {
+      text = await fs.readFile(path.join(root, rel), 'utf8');
+    } catch {
+      continue;
+    }
+    files++;
+    const lines = text.split('\n');
+    scanned += lines.length;
+    let lastKey = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!re.test(line) || COMMENT_LINE.test(line) || IMPORT_LINE.test(line)) continue;
+      if (BARE_LIST_LINE.test(line.trim())) continue;
+      const lineNo = i + 1;
+      const holder = chunks.find((c) => lineNo >= c.start && lineNo <= c.end);
+      // La definizione stessa non è un chiamante.
+      if (holder && holder.symbol === symbol && lineNo === holder.start) continue;
+      const key = `${rel}\0${holder?.symbol ?? ''}`;
+      if (key === lastKey) continue;
+      lastKey = key;
+      callers.push({
+        path: rel,
+        line: lineNo,
+        container: holder?.symbol ?? null,
+        containerKind: holder?.kind ?? null,
+        text: line.trim().slice(0, 120),
+      });
+      if (callers.length >= limit) return { callers, scanned, files, truncated: true };
+    }
+  }
+  return { callers, scanned, files, truncated: false };
+}

package/src/indexer.js

@@ -0,0 +1,302 @@
+// Indicizzatore incrementale: scan -> chunk -> embed solo del delta -> save atomico.
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  CHUNKER_VERSION, LANG_BY_EXT, chunkCode, chunkLines, chunkPayload, langOf,
+} from './chunker.js';
+import { embed, docPrefix, DIMS, MODEL_ID, getEmbeddingProfile } from './embed.js';
+import {
+  clearEmbedCache, loadEmbedCache, loadIndex, saveEmbedCache, saveIndex, STORE_VERSION,
+} from './store.js';
+import {
+  fmtBytes, fmtDuration, headCommit, isBinary, isMinified, lsFiles, repoRoot, sha1, short, walkFiles,
+} from './util.js';
+
+export const PROVIDER = 'transformers.js';
+const MAX_FILE_BYTES = 1024 * 1024;
+const LOCKFILES = new Set([
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'Cargo.lock', 'poetry.lock',
+  'go.sum', 'composer.lock', 'Gemfile.lock', 'bun.lockb',
+]);
+
+export function chunkIdentity(filePath, fileHash, model = MODEL_ID, dtype = 'q8', device = 'cpu', webgpuBackend = null) {
+  return sha1([filePath, fileHash, CHUNKER_VERSION, model, dtype, DIMS, device,
+    ...(device === 'webgpu' ? [webgpuBackend ?? 'auto'] : [])].join('\0'));
+}
+
+function extOf(p) {
+  const m = /\.[^./]+$/.exec(p);
+  return m ? m[0].toLowerCase() : '';
+}
+
+/** Filtro di enumerazione (§3.2): solo linguaggi supportati, niente binari/lock/minified. */
+export async function collectFiles(root, { maxFiles, maxBytes }) {
+  const listed = lsFiles(root) ?? (await walkFiles(root));
+  const sorted = listed.sort();
+  const picked = [];
+  let bytes = 0;
+  let skipped = { ext: 0, big: 0, cap: 0 };
+
+  for (const rel of sorted) {
+    if (picked.length >= maxFiles) {
+      skipped.cap = sorted.length - picked.length;
+      break;
+    }
+    const base = path.basename(rel);
+    if (LOCKFILES.has(base)) {
+      skipped.ext++;
+      continue;
+    }
+    if (!(extOf(rel) in LANG_BY_EXT)) {
+      skipped.ext++;
+      continue;
+    }
+    let st;
+    try {
+      st = await fs.stat(path.join(root, rel));
+    } catch {
+      continue;
+    }
+    if (!st.isFile() || st.size === 0 || st.size > MAX_FILE_BYTES) {
+      skipped.big++;
+      continue;
+    }
+    if (bytes + st.size > maxBytes) {
+      skipped.cap = sorted.length - picked.length;
+      break;
+    }
+    bytes += st.size;
+    picked.push({ path: rel, size: st.size });
+  }
+  return { files: picked, bytes, skipped };
+}
+
+// Batch per budget di token (stima ~3,5 char/token): l'attenzione è quadratica
+// nella lunghezza, un batch di 16 documenti da 4000 char può saturare la VRAM.
+const MAX_BATCH_TOKENS = 6000;
+const estTokens = (doc) => Math.ceil(doc.length / 3.5);
+
+/** Batch greedy: lunghezze già ordinate, si chiude quando il budget token è pieno. */
+export function makeBatches(pending, batchSize, maxTokens = MAX_BATCH_TOKENS) {
+  const out = [];
+  let cur = [];
+  let tokens = 0;
+  for (const p of pending) {
+    const t = estTokens(p.doc);
+    if (cur.length >= batchSize || (cur.length > 0 && tokens + t > maxTokens)) {
+      out.push(cur);
+      cur = [];
+      tokens = 0;
+    }
+    cur.push(p);
+    tokens += t;
+  }
+  if (cur.length) out.push(cur);
+  return out;
+}
+
+const isOom = (e) => /allocate memory|out of memory|outofmemory|cuda_error_out_of_memory|failed to allocate/i.test(e.message ?? '');
+
+/** Embed con split-retry: se un batch esaurisce la memoria, si dimezza. */
+async function embedSafe(docs, log, embedFn) {
+  try {
+    return await embedFn(docs);
+  } catch (e) {
+    if (!isOom(e)) throw e;
+    if (docs.length > 1) {
+      const mid = Math.floor(docs.length / 2);
+      log(`[codeindex] batch di ${docs.length} troppo grande (${e.message.slice(0, 60)}…): lo divido`);
+      return [...(await embedSafe(docs.slice(0, mid), log, embedFn)), ...(await embedSafe(docs.slice(mid), log, embedFn))];
+    }
+    const shorter = docs[0].slice(0, Math.max(600, Math.floor(docs[0].length / 2)));
+    if (shorter.length < docs[0].length) {
+      log(`[codeindex] documento troppo lungo anche da solo (${docs[0].length} char): tronco a ${shorter.length}`);
+      return embedSafe([shorter], log, embedFn);
+    }
+    throw e;
+  }
+}
+
+/**
+ * Indicizza il repo. Riusa i vettori dei chunk la cui identità (path+contenuto+
+ * versione chunker+modello+dtype+provider+backend WebGPU) non è cambiata.
+ */
+export async function indexRepo({
+  root,
+  maxFiles = 5000,
+  maxBytes = 200 * 1024 * 1024,
+  batchSize = 16,
+  force = false,
+  signal = null,
+  onProgress = null,
+  embedding = { embed, getProfile: getEmbeddingProfile },
+  log = (msg) => process.stderr.write(`${msg}\n`),
+} = {}) {
+  const t0 = performance.now();
+  const repo = path.resolve(root ?? repoRoot(process.cwd()) ?? process.cwd());
+  signal?.throwIfAborted();
+  const { files, bytes, skipped } = await collectFiles(repo, { maxFiles, maxBytes });
+  // Fissa il profilo DOPO eventuali fallback e PRIMA di calcolare identità/cache.
+  const profile = await embedding.getProfile();
+  signal?.throwIfAborted();
+
+  const { index: oldIndex, vectors: oldVectors } = force
+    ? { index: null, vectors: null }
+    : await loadIndex(repo);
+
+  const reusable = new Map(); // identity -> row index nel vecchio vettore
+  if (oldIndex?.chunks && oldVectors) {
+    oldIndex.chunks.forEach((c, i) => reusable.set(c.hash, i));
+    if (oldIndex.chunkerVersion !== CHUNKER_VERSION || oldIndex.dims !== DIMS) reusable.clear();
+  }
+  // Ripresa: i vettori già calcolati in un run interrotto non si ricalcolano.
+  const cached = force ? new Map() : await loadEmbedCache(repo);
+  const cacheHit = cached.size > 0;
+
+  log(`[codeindex] ${files.length} file (${fmtBytes(bytes)}), ${skipped.ext} esclusi per estensione, ${skipped.big} per dimensione`);
+
+  const chunks = [];
+  const pending = []; // { row, doc }
+  let skippedBinary = 0;
+  let skippedMinified = 0;
+  let unchanged = 0;
+  const oldByPath = new Map((oldIndex?.chunks ?? []).map((c) => [c.path, c.fileHash]));
+
+  for (const f of files) {
+    signal?.throwIfAborted();
+    let buf;
+    try {
+      buf = await fs.readFile(path.join(repo, f.path));
+    } catch {
+      continue;
+    }
+    if (isBinary(buf)) {
+      skippedBinary++;
+      continue;
+    }
+    const text = buf.toString('utf8');
+    const lang = langOf(f.path);
+    // I Markdown hanno righe lunghe legittime (tabelle, link): non sono bundle.
+    if (lang !== 'md' && isMinified(text)) {
+      skippedMinified++;
+      continue;
+    }
+    const fileHash = sha1(buf);
+    if (oldByPath.get(f.path) === fileHash) unchanged++;
+
+    const lines = text.split('\n');
+    if (lines.length && lines[lines.length - 1] === '') lines.pop();
+    for (const c of chunkLines(lines, lang)) {
+      const code = chunkCode(lines, c);
+      const hash = chunkIdentity(f.path, `${fileHash}:${c.start}-${c.end}`, profile.model, profile.dtype, profile.device, profile.webgpuBackend);
+      const row = chunks.length;
+      chunks.push({
+        path: f.path,
+        start: c.start,
+        end: c.end,
+        symbol: c.symbol ?? null,
+        kind: c.kind,
+        lang,
+        fileHash,
+        hash,
+        preview: short(code, 200),
+      });
+      if (reusable.has(hash) || cached.has(hash)) continue;
+      pending.push({ row, hash, doc: docPrefix(f.path) + chunkPayload(c, code) });
+    }
+  }
+
+  const total = chunks.length;
+  onProgress?.({ phase: 'scan', done: 0, total });
+  const rows = new Float32Array(total * DIMS);
+  let reused = 0;
+  for (let i = 0; i < total; i++) {
+    const idx = reusable.get(chunks[i].hash);
+    if (idx !== undefined && oldVectors) {
+      rows.set(oldVectors.subarray(idx * DIMS, idx * DIMS + DIMS), i * DIMS);
+      reused++;
+    } else {
+      const v = cached.get(chunks[i].hash);
+      if (v) {
+        rows.set(v, i * DIMS);
+        reused++;
+      }
+    }
+  }
+
+  log(`[codeindex] ${total} chunk, ${reused} riusati${cacheHit ? ' (di cui da cache di ripresa)' : ''}, ${pending.length} da embeddare`);
+  // Batch omogenei per lunghezza: meno padding, ~2x di throughput misurato.
+  pending.sort((a, b) => a.doc.length - b.doc.length);
+  const batches = makeBatches(pending, batchSize);
+  let embedded = 0;
+  let sinceFlush = 0;
+  const tEmbed = performance.now();
+  for (const slice of batches) {
+    signal?.throwIfAborted();
+    let vecs;
+    let lastErr;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        vecs = await embedSafe(slice.map((p) => p.doc), log, embedding.embed);
+        slice.forEach((p, k) => {
+          rows.set(vecs[k], p.row * DIMS);
+          cached.set(p.hash, vecs[k]);
+        });
+        lastErr = null;
+        break;
+      } catch (e) {
+        lastErr = e;
+        await new Promise((r) => setTimeout(r, 250 * attempt));
+      }
+    }
+    if (lastErr) throw new Error(`embedding fallito su ${slice[0].doc.slice(0, 60)}: ${lastErr.message}`);
+    embedded += slice.length;
+    sinceFlush += slice.length;
+    onProgress?.({ phase: 'embed', done: embedded, total: pending.length });
+    if (sinceFlush >= 2000) {
+      await saveEmbedCache(repo, cached);
+      sinceFlush = 0;
+    }
+    if (pending.length > batchSize) {
+      const elapsed = performance.now() - tEmbed;
+      const rate = embedded / (elapsed / 1000);
+      const eta = (pending.length - embedded) / rate;
+      if (embedded % (batchSize * 8) === 0 || embedded === pending.length) {
+        log(`[codeindex] embed ${embedded}/${pending.length} · ${rate.toFixed(1)} chunk/s · ETA ${fmtDuration(eta * 1000)}`);
+      }
+    }
+  }
+
+  const now = new Date().toISOString();
+  const index = {
+    version: STORE_VERSION,
+    repoRoot: repo,
+    provider: PROVIDER,
+    model: profile.model,
+    dtype: profile.dtype,
+    device: profile.device,
+    webgpuBackend: profile.webgpuBackend ?? (profile.device === 'webgpu' ? 'auto' : null),
+    dims: DIMS,
+    chunkerVersion: CHUNKER_VERSION,
+    head: headCommit(repo),
+    createdAt: oldIndex?.createdAt ?? now,
+    updatedAt: now,
+    caps: { maxFiles, maxBytes },
+    stats: { files: files.length, bytes, chunks: total, reused, embedded, unchanged },
+    skipped: { ...skipped, binary: skippedBinary, minified: skippedMinified },
+    chunks,
+  };
+  await saveIndex(repo, index, rows);
+  await clearEmbedCache(repo);
+  onProgress?.({ phase: 'done', done: total, total });
+
+  const duration = performance.now() - t0;
+  return { index, repo, duration, embedded, reused, total, unchanged };
+}
+
+export async function statusOf(root) {
+  const repo = path.resolve(root ?? repoRoot(process.cwd()) ?? process.cwd());
+  const { index, vectors } = await loadIndex(repo);
+  return { repo, index, hasVectors: Boolean(vectors && vectors.length) };
+}

package/src/local-embed.js

@@ -0,0 +1,51 @@
+// Solo nel servizio e nei probe esplicitamente isolati. I client pi non
+// importano Transformers/ORT e non possiedono una pipeline nativa.
+import { createEmbeddingRuntime, nativeBackends, validateEmbeddings, QUERY_PREFIX } from './backend.js';
+import { ensureTextModel } from './model.js';
+
+export function createLocalEmbedder(config) {
+  const runtime = createEmbeddingRuntime({
+    settings: () => ({ config }),
+    inventory: async () => nativeBackends().backends,
+    log: (s) => process.stderr.write(`${s}\n`),
+    initialize: async (profile, settings) => {
+      const sessionOptions = {};
+      if (profile.webgpuBackend === 'vulkan') {
+        const { registerVulkanBackend } = await import('./vulkan.js');
+        sessionOptions.executionProviders = [await registerVulkanBackend()];
+      }
+      const dir = await ensureTextModel(profile, settings);
+      const { pipeline } = await import('@huggingface/transformers');
+      if (settings.cpuThreads) sessionOptions.intraOpNumThreads = settings.cpuThreads;
+      if (profile.device === 'dml') {
+        sessionOptions.executionMode = 'sequential';
+        sessionOptions.enableMemPattern = false;
+      }
+      let pipe;
+      try {
+        pipe = await pipeline('feature-extraction', dir, {
+          dtype: profile.dtype, device: profile.device, local_files_only: true, session_options: sessionOptions,
+        });
+        const out = await pipe([QUERY_PREFIX + 'code retrieval smoke test'], { pooling: 'mean', normalize: true });
+        validateEmbeddings(out.tolist(), 1);
+        return pipe;
+      } catch (e) {
+        try { await pipe?.dispose(); } catch { /* conserva l'errore originale */ }
+        throw e;
+      }
+    },
+  });
+  return {
+    getProfile: async () => (await runtime.get()).profile,
+    info: () => runtime.info(),
+    embed: async (texts, { normalize = true } = {}) => {
+      const { pipe } = await runtime.get();
+      // Non cambiare provider dopo la prima inferenza riuscita.
+      const out = await pipe(texts, { pooling: 'mean', normalize });
+      return validateEmbeddings(out.tolist(), texts.length);
+    },
+    dispose: async () => {
+      if (runtime.info().profile) await (await runtime.get()).pipe.dispose();
+    },
+  };
+}