@alucard_24/pi-codeindex 1.0.0 → 1.1.0

package/src/service.js

@@ -0,0 +1,172 @@
+// Un listener esclusivo per directory/utente, un modello, una coda seriale.
+import net from 'node:net';
+import fs from 'node:fs/promises';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { PROTOCOL, HOST, prepareServiceDirectory, readServiceRecord, writeServiceRecord, readFrame, writeFrame, serviceAddress, serviceError } from './service-protocol.js';
+import { validateServiceConfig, assertServiceCompatible, validateTexts } from './service-policy.js';
+
+export async function startEmbeddingService({ directory, port, maxQueue = 16, createRuntime = async (config) => {
+  const { createLocalEmbedder } = await import('./local-embed.js');
+  return createLocalEmbedder(config);
+} }) {
+  const address = serviceAddress({ serviceDir: directory, servicePort: port });
+  await prepareServiceDirectory(address);
+  const token = randomBytes(32).toString('hex');
+  const record = { protocol: PROTOCOL, pid: process.pid, port: address.port, token };
+  const sockets = new Set();
+  const startedAt = Date.now();
+  let lastUsedAt = startedAt;
+  let idleMs = 300_000;
+  let timer, runtime = null, activeConfig = null;
+  let pending = 0, initializing = false, stopping = false, shutdownStarted = false, tail = Promise.resolve();
+  let resolveStopped;
+  const stopped = new Promise((resolve) => { resolveStopped = resolve; });
+
+  function info() {
+    return { running: !stopping, stopping, shared: true, pid: process.pid, protocol: PROTOCOL, port: address.port,
+      pending, initializing, startedAt, lastUsedAt, idleMs, rssBytes: process.memoryUsage().rss,
+      ...(runtime?.info() ?? { profile: null, attempts: [], error: null }) };
+  }
+  function reply(socket, value) {
+    if (socket.destroyed) return;
+    try { writeFrame(socket, { protocol: PROTOCOL, ...value }); socket.end(); }
+    catch { socket.destroy(); }
+  }
+  function armIdle() {
+    clearTimeout(timer);
+    if (!stopping && pending === 0) timer = setTimeout(() => { void stop(); }, Math.max(1, idleMs - (Date.now() - lastUsedAt)));
+  }
+  async function stop() {
+    if (shutdownStarted) return stopped;
+    shutdownStarted = true;
+    stopping = true;
+    clearTimeout(timer);
+    // L'inferenza attiva termina; quelle in coda ricevono un errore esplicito.
+    await tail;
+    for (const socket of sockets) socket.destroy();
+    if (runtime) {
+      let timeout;
+      try { await Promise.race([runtime.dispose(), new Promise((resolve) => { timeout = setTimeout(resolve, 3000); })]); }
+      catch { /* l'uscita del processo libera comunque le risorse native */ }
+      finally { clearTimeout(timeout); }
+    }
+    try {
+      const current = await readServiceRecord(address);
+      if (current?.token === token) await fs.rm(address.file, { force: true });
+    } catch { /* non cancellare record sostituiti/non sicuri */ }
+    // Chiudi anche connessioni arrivate durante dispose, prima di rilasciare
+    // la porta: nessun client incompleto deve trattenere il worker nativo.
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+    resolveStopped();
+  }
+  async function modelFor(config, expectedProfile) {
+    if (!runtime) {
+      activeConfig = config;
+      idleMs = config.serviceIdleMs;
+      initializing = true;
+      try {
+        runtime = await createRuntime(config);
+        await runtime.getProfile();
+      } catch (e) {
+        // Dopo un'inizializzazione fallita si esce: nessuna risorsa nativa
+        // residua viene riusata per avviare un altro profilo.
+        e.initializationFailed = true;
+        throw e;
+      } finally { initializing = false; }
+    }
+    const profile = await runtime.getProfile();
+    assertServiceCompatible(config, activeConfig, profile, expectedProfile);
+    return { runtime, profile };
+  }
+
+  const server = net.createServer((socket) => {
+    socket.on('error', () => {});
+    sockets.add(socket);
+    socket.once('close', () => sockets.delete(socket));
+    if (sockets.size > maxQueue + 16) { socket.destroy(); return; }
+    void (async () => {
+      let authenticated = false;
+      try {
+        const request = await readFrame(socket, { timeoutMs: 3000 });
+        if (typeof request?.token !== 'string' || !/^[a-f0-9]{64}$/.test(request.token) ||
+            !timingSafeEqual(Buffer.from(request.token), Buffer.from(token))) throw serviceError('UNAUTHORIZED', 'autenticazione del servizio locale fallita');
+        authenticated = true;
+        if (request.protocol !== PROTOCOL) throw serviceError('PROTOCOL_MISMATCH', 'protocollo del servizio incompatibile; arresta il servizio e riavvia pi');
+        if (request.op === 'status') { reply(socket, { ok: true, result: info() }); return; }
+        if (request.op === 'stop') {
+          if (stopping) { reply(socket, { ok: true, result: { stopping: true, pid: process.pid } }); return; }
+          if (pending) throw serviceError('SERVICE_BUSY', `servizio occupato (${pending} richieste): stop rifiutato per non interrompere altre sessioni`);
+          reply(socket, { ok: true, result: { stopping: true, pid: process.pid } });
+          // Blocca subito nuove operazioni, poi lascia uscire la risposta.
+          stopping = true;
+          setImmediate(() => { void stop(); });
+          return;
+        }
+        if (stopping) throw serviceError('SERVICE_STOPPING', 'servizio locale in arresto; riprova tra poco');
+        if (!['profile', 'embed'].includes(request.op)) throw serviceError('BAD_OPERATION', 'operazione del servizio sconosciuta');
+        const config = validateServiceConfig(request.config);
+        const requestedAddress = serviceAddress(config);
+        if (requestedAddress.directory !== address.directory || requestedAddress.port !== address.port) throw serviceError('BAD_CONFIG', 'endpoint client diverso da quello del servizio');
+        if (request.op === 'embed') validateTexts(request.texts, request.normalize);
+        if (pending >= maxQueue) throw serviceError('QUEUE_FULL', `coda del servizio piena (massimo ${maxQueue}); riprova senza avviare altri modelli`);
+        pending++;
+        clearTimeout(timer);
+        const task = tail.then(async () => {
+          try {
+            if (socket.destroyed) return;
+            if (stopping) throw serviceError('SERVICE_STOPPING', 'servizio locale in arresto');
+            const { runtime: model, profile } = await modelFor(config, request.expectedProfile);
+            const result = request.op === 'embed' ? await model.embed(request.texts, { normalize: request.normalize }) : profile;
+            reply(socket, { ok: true, result, info: info() });
+          } catch (e) {
+            reply(socket, { ok: false, code: e.code ?? 'INFERENCE_FAILED', error: String(e.message ?? e).slice(0, 4000), info: info() });
+            if (e.initializationFailed) {
+              stopping = true;
+              setImmediate(() => { void stop(); });
+            }
+          } finally {
+            pending--;
+            lastUsedAt = Date.now();
+            armIdle();
+          }
+        });
+        // La coda non viene avvelenata da richieste fallite/disconnesse.
+        tail = task.catch(() => {});
+      } catch (e) {
+        reply(socket, { ok: false, code: e.code ?? 'BAD_REQUEST', error: String(e.message ?? e).slice(0, 4000), ...(authenticated ? { info: info() } : {}) });
+      }
+    })();
+  });
+  server.on('error', () => {});
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen({ host: HOST, port: address.port, exclusive: true }, () => { server.off('error', reject); resolve(); });
+  });
+  try { await writeServiceRecord(address, record); }
+  catch (e) { server.close(); throw e; }
+  armIdle();
+  return { info, stop, stopped };
+}
+
+// Entry point condiviso dal worker reale e da fixture senza modello.
+export async function runServiceWorker(options = {}) {
+  let service;
+  try {
+    const directory = process.argv[2];
+    const port = Number(process.argv[3]);
+    if (!directory || !Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('argomenti interni del servizio non validi');
+    service = await startEmbeddingService({ ...options, directory, port });
+    process.once('SIGTERM', () => { void service.stop(); });
+    process.once('SIGINT', () => { void service.stop(); });
+    if (process.connected) process.send({ ready: true, pid: process.pid }, () => { if (process.connected) process.disconnect(); });
+    await service.stopped;
+    // Necessario anche se ORT/Dawn trattiene handle dopo dispose: l'OS libera
+    // l'intero processo. Non si scarica/ricarica un modello nello stesso worker.
+    process.exit(0);
+  } catch (e) {
+    const exit = () => process.exit(e.code === 'EADDRINUSE' ? 0 : 1);
+    if (process.connected) process.send({ ready: false, code: e.code, error: e.message }, exit);
+    else exit();
+  }
+}

package/src/sync.js

@@ -19,8 +19,12 @@ const extOf = (p) => {
   return m ? m[0].toLowerCase() : '';
 };
 
-/** Path relativo al repo -> normalizzato con '/', o null se non è indicizzabile. */
-export function watchablePath(rel, root) {
+/**
+ * Path relativo -> normalizzato con '/', o null se fuori scope.
+ * Su rename, includeDirectories accetta anche directory/nomi senza estensione
+ * supportata: un evento sulla directory può rappresentare molti file rimossi.
+ */
+export function watchablePath(rel, root, { includeDirectories = false } = {}) {
   if (!rel) return null;
   let p = String(rel).replace(/\\/g, '/');
   if (path.isAbsolute(p)) {
@@ -33,15 +37,15 @@ export function watchablePath(rel, root) {
   if (segments.length === 0 || segments[0] === '..') return null;
   p = segments.join('/');
   if (segments.some((s) => IGNORED_DIRS.has(s))) return null;
-  if (!(extOf(p) in LANG_BY_EXT)) return null;
+  if (!includeDirectories && !(extOf(p) in LANG_BY_EXT)) return null;
   return segments.join('/');
 }
 
 /** Filtra e deduplica una lista di path (watcher, hook dei tool, git status). */
-export function filterDirty(paths, root) {
+export function filterDirty(paths, root, options) {
   const out = new Set();
   for (const p of paths ?? []) {
-    const w = watchablePath(p, root);
+    const w = watchablePath(p, root, options);
     if (w) out.add(w);
   }
   return out;

package/src/workspace.js

@@ -0,0 +1,18 @@
+// Radice del progetto: Git quando disponibile, altrimenti la cartella corrente.
+// Nessuna configurazione di progetto viene letta e nessun repository viene creato.
+import os from 'node:os';
+import path from 'node:path';
+import { repoRoot } from './util.js';
+
+export function resolveWorkspace(cwd = process.cwd(), {
+  findRepoRoot = repoRoot,
+  home = os.homedir(),
+} = {}) {
+  const gitRoot = findRepoRoot(cwd);
+  const root = path.resolve(gitRoot ?? cwd);
+  const mode = gitRoot ? 'git' : 'folder';
+  // Un avvio dalla home o dalla radice del disco non deve scandire l'intera
+  // macchina per errore. /codeindex enable resta un consenso esplicito.
+  const broadFolder = root === path.parse(root).root || root === path.resolve(home);
+  return { root, mode, autoIndex: mode === 'git' || !broadFolder };
+}