@alucard_24/pi-codeindex 0.0.0-stage → 1.1.0

package/src/vulkan.js

@@ -0,0 +1,151 @@
+// Backend opzionale: WebGPU/Dawn con selettore Vulkan effettivamente applicato.
+// Binding e copia di ORT isolati nella cache; nessun provider standard sostituito.
+import fs from 'node:fs/promises';
+import { readFileSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { isMainThread } from 'node:worker_threads';
+
+export const ORT_VERSION = '1.30.0';
+export const ORT_SOURCE = 'f2c39fe2f838cf35ce7da92824f5a5e3ee6e88a7';
+export const VULKAN_REVISION = 1;
+export const VULKAN_EP = 'pi-codeindex-vulkan-r1';
+// Un solo Identity float32, anche per verificare il rifiuto di un backend invalido.
+export const SMOKE_MODEL = Buffer.from('08083a370a100a015812015922084964656e746974791201675a0f0a0158120a0a08080112040a020801620f0a0159120a0a08080112040a0208014202100d', 'hex');
+
+const require = createRequire(import.meta.url);
+export function ortLibrary() {
+  const dir = path.dirname(require.resolve('onnxruntime-node/package.json'));
+  return path.join(dir, 'bin', 'napi-v6', process.platform, process.arch, 'libonnxruntime.so.1');
+}
+
+export function vulkanCacheDir({ home = os.homedir(), platform = process.platform, arch = process.arch } = {}) {
+  return path.join(home, '.cache', 'pi-codeindex', 'native', `vulkan-ort-${ORT_VERSION}-r${VULKAN_REVISION}`, `${platform}-${arch}`);
+}
+
+export function validateVulkanManifest(m, { platform = process.platform, arch = process.arch } = {}) {
+  if (!m || m.runtimeVersion !== ORT_VERSION || m.sourceRevision !== ORT_SOURCE ||
+      m.revision !== VULKAN_REVISION || m.platform !== platform || m.arch !== arch) {
+    throw new Error('manifest Vulkan incompatibile: riesegui npm run setup-vulkan');
+  }
+  for (const key of ['artifact', 'sourceLibraryHash', 'bindingHash', 'libraryHash']) {
+    if (typeof m[key] !== 'string' || !/^[a-f0-9]{64}$/.test(m[key])) throw new Error(`manifest Vulkan: ${key} invalido`);
+  }
+  if (m.library !== `libpi-codeindex-ort-vulkan-${m.sourceLibraryHash.slice(0, 16)}.so.1`) {
+    throw new Error('manifest Vulkan: nome libreria invalido');
+  }
+  return m;
+}
+
+// Inventario leggero: non carica addon, driver o modelli. Gli hash vengono
+// verificati prima del dlopen, non ad ogni richiesta di status/doctor.
+export function vulkanStatus(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const dir = vulkanCacheDir(options);
+  if (platform !== 'linux' || arch !== 'x64') return { available: false, dir,
+    reason: 'setup Vulkan forzato disponibile inizialmente solo su Linux x64; questa piattaforma non è verificata' };
+  try {
+    const manifest = validateVulkanManifest(JSON.parse(readFileSync(path.join(dir, 'manifest.json'), 'utf8')), { platform, arch });
+    const artifactDir = path.join(dir, manifest.artifact);
+    const binding = path.join(artifactDir, 'onnxruntime_binding.node');
+    const library = path.join(artifactDir, manifest.library);
+    if (!existsSync(binding) || !existsSync(library)) throw new Error('artefatti Vulkan mancanti');
+    return { available: true, dir, binding, library, manifest, reason: 'binding isolato presente; integrità e inferenza da verificare' };
+  } catch (e) {
+    return { available: false, dir, reason: e.code === 'ENOENT' ? 'binding opzionale assente: esegui npm run setup-vulkan' : e.message };
+  }
+}
+
+export async function fileHash(file) {
+  return createHash('sha256').update(await fs.readFile(file)).digest('hex');
+}
+
+export async function verifyVulkanArtifacts(status, sourceLibrary = ortLibrary()) {
+  if (!status.available) throw new Error(status.reason);
+  const version = require('onnxruntime-node/package.json').version;
+  if (version !== ORT_VERSION) throw new Error(`binding Vulkan richiede onnxruntime-node ${ORT_VERSION}, trovato ${version}`);
+  for (const [file, expected] of [[sourceLibrary, status.manifest.sourceLibraryHash],
+    [status.binding, status.manifest.bindingHash], [status.library, status.manifest.libraryHash]]) {
+    if (await fileHash(file) !== expected) throw new Error(`integrità/runtime Vulkan cambiato (${path.basename(file)}): riesegui npm run setup-vulkan`);
+  }
+}
+
+// Prova negativa obbligatoria: impedisce di dichiarare Vulkan quando il binding
+// ignora il selettore. Deve fallire PRIMA di inizializzare un device Dawn.
+export function assertVulkanSelector(binding) {
+  const session = new binding.InferenceSession();
+  let rejected = false;
+  try {
+    session.loadModel(SMOKE_MODEL.buffer, SMOKE_MODEL.byteOffset, SMOKE_MODEL.byteLength,
+      { executionProviders: [{ name: 'webgpu', dawnBackendType: '__codeindex_invalid_backend__' }] });
+  } catch (e) {
+    if (!/Invalid Dawn backend type/.test(e.message)) throw new Error(`selettore Vulkan non verificato: ${e.message}`);
+    rejected = true;
+  } finally {
+    try { session.dispose(); } catch { /* loadModel può non avere creato la sessione */ }
+  }
+  if (!rejected) throw new Error('il binding ignora dawnBackendType: Vulkan non può essere garantito');
+}
+
+const TYPES = [null, 'float32', 'uint8', 'int8', 'uint16', 'int16', 'int32', 'int64', 'string', 'bool',
+  'float16', 'float64', 'uint32', 'uint64', null, null, null, null, null, null, null, 'uint4', 'int4'];
+const defer = (fn) => new Promise((resolve, reject) => setImmediate(() => { try { resolve(fn()); } catch (e) { reject(e); } }));
+function metadata(entries) {
+  return entries.map((m) => {
+    if (!m.isTensor) return { name: m.name, isTensor: false };
+    const type = TYPES[m.type];
+    if (!type) throw new Error(`tipo ONNX non supportato: ${m.type}`);
+    return { name: m.name, isTensor: true, type, shape: m.shape.map((dim, i) => {
+      if (dim < -1) throw new Error(`dimensione ONNX invalida: ${dim}`);
+      return dim === -1 ? m.symbolicDimensions[i] : dim;
+    }) };
+  });
+}
+
+// Adattatore dell'interfaccia pubblica Backend di onnxruntime-common. Registrato
+// con nome unico e priorità negativa: non entra mai nella selezione automatica
+// di altri utenti di ONNX Runtime nello stesso processo.
+export function createVulkanBackend(binding) {
+  return {
+    init: async () => {},
+    createInferenceSessionHandler: (model, options) => defer(() => {
+      const native = new binding.InferenceSession();
+      try {
+        const opts = { ...options, executionProviders: [{ name: 'webgpu', dawnBackendType: 'Vulkan' }] };
+        if (typeof model === 'string') native.loadModel(model, opts);
+        else native.loadModel(model.buffer, model.byteOffset, model.byteLength, opts);
+        const inputMetadata = metadata(native.inputMetadata);
+        const outputMetadata = metadata(native.outputMetadata);
+        return { inputNames: inputMetadata.map((m) => m.name), outputNames: outputMetadata.map((m) => m.name),
+          inputMetadata, outputMetadata,
+          run: (feeds, fetches, runOptions) => defer(() => native.run(feeds, fetches, runOptions)),
+          dispose: async () => native.dispose(), startProfiling: () => {}, endProfiling: () => native.endProfiling() };
+      } catch (e) {
+        try { native.dispose(); } catch { /* conserva l'errore originale */ }
+        throw e;
+      }
+    }),
+  };
+}
+
+let registration;
+export async function registerVulkanBackend() {
+  if (!registration) registration = (async () => {
+    const status = vulkanStatus();
+    await verifyVulkanArtifacts(status);
+    // Stessa policy dell'adapter Transformers.js, prima di caricare la copia
+    // privata di ORT. Non modifica env/backends di Transformers.js.
+    process.env.ORT_DISABLE_TELEMETRY = '1';
+    const ort = require('onnxruntime-node');
+    const binding = require(status.binding);
+    const levels = { verbose: 0, info: 1, warning: 2, error: 3, fatal: 4 };
+    binding.initOrtOnce(levels[ort.env.logLevel] ?? 2, ort.Tensor, isMainThread);
+    assertVulkanSelector(binding);
+    ort.registerBackend(VULKAN_EP, createVulkanBackend(binding), -10);
+    return VULKAN_EP;
+  })();
+  try { return await registration; } catch (e) { registration = undefined; throw e; }
+}

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 };
+}