@alucard_24/pi-codeindex 0.0.0-stage → 1.0.0

package/src/util.js

@@ -0,0 +1,108 @@
+// Utility pure: hash, git, enumerazione file, euristiche su testo/binari.
+
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export function sha1(input) {
+  return createHash('sha1').update(input).digest('hex');
+}
+
+export function short(s, n = 60) {
+  const one = String(s).replace(/\s+/g, ' ').trim();
+  return one.length > n ? `${one.slice(0, n - 1)}…` : one;
+}
+
+export function git(cwd, args) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf8',
+      maxBuffer: 64 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return null;
+  }
+}
+
+export function repoRoot(cwd) {
+  const out = git(cwd, ['rev-parse', '--show-toplevel']);
+  return out ? out.trim() : null;
+}
+
+export function headCommit(cwd) {
+  const out = git(cwd, ['rev-parse', 'HEAD']);
+  return out ? out.trim() : null;
+}
+
+/** Elenca i file tracciati + untracked non ignorati. Null se non è un repo git. */
+export function lsFiles(root) {
+  const out = git(root, ['ls-files', '-z', '--cached', '--others', '--exclude-standard']);
+  if (out === null) return null;
+  return out.split('\0').filter(Boolean);
+}
+
+const IGNORED_DIRS = new Set([
+  '.git', 'node_modules', 'dist', 'build', 'out', '__pycache__', '.venv', 'venv',
+  'target', 'vendor', '.next', '.nuxt', '.openlore', '.pi', 'coverage', '.cache',
+]);
+
+/** Fallback quando non è un repo git: walk con esclusioni minime. */
+export async function walkFiles(root, { maxDepth = 32 } = {}) {
+  const acc = [];
+  async function rec(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith('.') && e.isDirectory()) continue;
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (IGNORED_DIRS.has(e.name)) continue;
+        await rec(p, depth + 1);
+      } else if (e.isFile()) {
+        acc.push(path.relative(root, p));
+      }
+    }
+  }
+  await rec(root, 0);
+  return acc;
+}
+
+/** Byte NUL nei primi 8 KB: binario. */
+export function isBinary(buf) {
+  const n = Math.min(buf.length, 8192);
+  for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
+  return false;
+}
+
+/** Riga più lunga > 2000 char: probabile bundle/minified. */
+export function isMinified(text) {
+  if (text.length < 4096) return false;
+  let run = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) run = 0;
+    else if (++run > 2000) return true;
+  }
+  return false;
+}
+
+export function fmtDuration(ms) {
+  if (ms < 1000) return `${Math.round(ms)} ms`;
+  const s = ms / 1000;
+  if (s < 60) return `${s.toFixed(1)} s`;
+  return `${Math.floor(s / 60)}m${String(Math.round(s % 60)).padStart(2, '0')}s`;
+}
+
+export function fmtBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(0)} KB`;
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`;
+  return `${(n / 1024 ** 3).toFixed(2)} GB`;
+}

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