@jsonstudio/llms 0.6.1399 → 0.6.1402

package/dist/conversion/hub/pipeline/thought-signature/thought-signature-center.js

@@ -1,289 +0,0 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-export const SKIP_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
-const MEMORY_TTL_MS = 12 * 60 * 60 * 1000;
-const DISK_TTL_MS = 12 * 60 * 60 * 1000;
-const WRITE_INTERVAL_MS = 60 * 1000;
-const MAX_ENTRIES_PER_SESSION = 50;
-const MAX_SESSIONS = 200;
-const TEXT_HASH_HEX_LEN = 16;
-const sessionStores = new Map();
-const sessionLast = new Map();
-const diskEntries = new Map();
-let dirty = false;
-let writeTimer;
-let cleanupTimer;
-const stats = {
-    memoryHits: 0,
-    diskHits: 0,
-    misses: 0,
-    writes: 0,
-    lastWrite: 0
-};
-function resolveDefaultCachePath() {
-    const env = (process.env.ROUTECODEX_THOUGHT_SIGNATURE_CACHE_PATH ||
-        process.env.RCC_THOUGHT_SIGNATURE_CACHE_PATH ||
-        '').trim();
-    if (env)
-        return env;
-    const home = process.env.HOME || os.homedir() || '';
-    return path.join(home, '.routecodex', 'antigravity-signature-cache.json');
-}
-const persistencePath = resolveDefaultCachePath();
-function now() {
-    return Date.now();
-}
-function normalizeText(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length ? trimmed : undefined;
-}
-function normalizeSignature(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length ? trimmed : undefined;
-}
-function hashText(text) {
-    return createHash('sha256').update(text, 'utf8').digest('hex').slice(0, TEXT_HASH_HEX_LEN);
-}
-function makeDiskKey(sessionKey, textHash) {
-    return `${sessionKey}:${textHash}`;
-}
-function ensureSession(sessionKey) {
-    let store = sessionStores.get(sessionKey);
-    if (!store) {
-        pruneSessionsIfNeeded();
-        store = new Map();
-        sessionStores.set(sessionKey, store);
-    }
-    return store;
-}
-function pruneSession(store) {
-    const cutoff = now() - MEMORY_TTL_MS;
-    for (const [key, entry] of store) {
-        if (entry.timestamp < cutoff) {
-            store.delete(key);
-        }
-    }
-    if (store.size < MAX_ENTRIES_PER_SESSION)
-        return;
-    const entries = Array.from(store.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
-    const toRemove = entries.slice(0, Math.floor(MAX_ENTRIES_PER_SESSION / 4));
-    for (const [key] of toRemove) {
-        store.delete(key);
-    }
-}
-function ensureCacheDir(filePath) {
-    try {
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    }
-    catch {
-        // best-effort
-    }
-}
-function loadPersistedCache() {
-    try {
-        if (!fs.existsSync(persistencePath))
-            return;
-        const raw = fs.readFileSync(persistencePath, 'utf-8');
-        if (!raw.trim())
-            return;
-        const parsed = JSON.parse(raw);
-        if (!parsed || parsed.version !== '1.0')
-            return;
-        const cutoff = now() - DISK_TTL_MS;
-        for (const [key, entry] of Object.entries(parsed.entries || {})) {
-            if (!entry || typeof entry.signature !== 'string')
-                continue;
-            const ts = typeof entry.timestamp === 'number' ? entry.timestamp : now();
-            if (ts < cutoff)
-                continue;
-            diskEntries.set(key, { signature: entry.signature, timestamp: ts });
-        }
-    }
-    catch {
-        // best-effort
-    }
-}
-function schedulePersist() {
-    if (writeTimer)
-        return;
-    writeTimer = setInterval(() => {
-        if (dirty) {
-            persistCache();
-        }
-    }, WRITE_INTERVAL_MS);
-    if (typeof writeTimer.unref === 'function') {
-        writeTimer.unref();
-    }
-}
-function scheduleCleanup() {
-    if (cleanupTimer)
-        return;
-    cleanupTimer = setInterval(() => {
-        const cutoff = now() - MEMORY_TTL_MS;
-        for (const store of sessionStores.values()) {
-            for (const [key, entry] of store.entries()) {
-                if (entry.timestamp < cutoff) {
-                    store.delete(key);
-                }
-            }
-        }
-    }, 30 * 60 * 1000);
-    if (typeof cleanupTimer.unref === 'function') {
-        cleanupTimer.unref();
-    }
-}
-function pruneSessionsIfNeeded() {
-    if (sessionStores.size < MAX_SESSIONS)
-        return;
-    const entries = [];
-    for (const key of sessionStores.keys()) {
-        const last = sessionLast.get(key);
-        entries.push({ key, ts: last?.timestamp ?? 0 });
-    }
-    entries.sort((a, b) => a.ts - b.ts);
-    const removeCount = Math.max(1, sessionStores.size - (MAX_SESSIONS - 1));
-    for (const entry of entries.slice(0, removeCount)) {
-        sessionStores.delete(entry.key);
-        sessionLast.delete(entry.key);
-        for (const diskKey of diskEntries.keys()) {
-            if (diskKey.startsWith(`${entry.key}:`)) {
-                diskEntries.delete(diskKey);
-            }
-        }
-    }
-}
-function persistCache() {
-    try {
-        ensureCacheDir(persistencePath);
-        const nowTs = now();
-        const validDisk = {};
-        for (const [key, entry] of diskEntries.entries()) {
-            if (nowTs - entry.timestamp <= DISK_TTL_MS) {
-                validDisk[key] = entry;
-            }
-        }
-        const merged = { ...validDisk };
-        for (const [sessionKey, store] of sessionStores.entries()) {
-            for (const [textHash, entry] of store.entries()) {
-                const diskKey = makeDiskKey(sessionKey, textHash);
-                merged[diskKey] = { signature: entry.signature, timestamp: entry.timestamp };
-            }
-        }
-        const data = {
-            version: '1.0',
-            memory_ttl_seconds: MEMORY_TTL_MS / 1000,
-            disk_ttl_seconds: DISK_TTL_MS / 1000,
-            entries: merged,
-            statistics: {
-                memory_hits: stats.memoryHits,
-                disk_hits: stats.diskHits,
-                misses: stats.misses,
-                writes: stats.writes + 1,
-                last_write: nowTs
-            }
-        };
-        const tmpPath = path.join(os.tmpdir(), `antigravity-cache-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
-        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
-        try {
-            fs.renameSync(tmpPath, persistencePath);
-        }
-        catch {
-            fs.writeFileSync(persistencePath, fs.readFileSync(tmpPath));
-            try {
-                fs.unlinkSync(tmpPath);
-            }
-            catch {
-                // ignore cleanup errors
-            }
-        }
-        stats.writes += 1;
-        stats.lastWrite = nowTs;
-        dirty = false;
-    }
-    catch {
-        // best-effort
-    }
-}
-loadPersistedCache();
-schedulePersist();
-scheduleCleanup();
-export function buildThoughtSignatureSessionKey(ctx, payload) {
-    const sessionId = typeof ctx.sessionId === 'string'
-        ? String(ctx.sessionId).trim()
-        : typeof ctx.conversationId === 'string'
-            ? String(ctx.conversationId).trim()
-            : typeof ctx.requestId === 'string'
-                ? String(ctx.requestId).trim()
-                : '';
-    if (!sessionId)
-        return undefined;
-    const model = (payload && typeof payload.model === 'string' && String(payload.model).trim()) ||
-        (typeof ctx.clientModelId === 'string' ? String(ctx.clientModelId).trim() : '') ||
-        (typeof ctx.originalModelId === 'string' ? String(ctx.originalModelId).trim() : '');
-    const protocol = typeof ctx.providerProtocol === 'string' && ctx.providerProtocol.trim()
-        ? ctx.providerProtocol.trim()
-        : 'unknown';
-    const modelKey = model || 'unknown';
-    return `${protocol}:${modelKey}:${sessionId}`;
-}
-export function cacheThoughtSignature(sessionKey, text, signature) {
-    const normalizedText = normalizeText(text);
-    const normalizedSignature = normalizeSignature(signature);
-    if (!sessionKey || !normalizedText || !normalizedSignature)
-        return;
-    const textHash = hashText(normalizedText);
-    const store = ensureSession(sessionKey);
-    if (store.size >= MAX_ENTRIES_PER_SESSION) {
-        pruneSession(store);
-    }
-    store.set(textHash, { signature: normalizedSignature, timestamp: now() });
-    sessionLast.set(sessionKey, { text: normalizedText, signature: normalizedSignature, timestamp: now() });
-    dirty = true;
-}
-export function getCachedThoughtSignature(sessionKey, text) {
-    if (!sessionKey)
-        return undefined;
-    const normalizedText = normalizeText(text);
-    if (!normalizedText)
-        return undefined;
-    const textHash = hashText(normalizedText);
-    const store = sessionStores.get(sessionKey);
-    if (store) {
-        const entry = store.get(textHash);
-        if (entry) {
-            if (now() - entry.timestamp <= MEMORY_TTL_MS) {
-                stats.memoryHits += 1;
-                return entry.signature;
-            }
-            store.delete(textHash);
-        }
-    }
-    const diskKey = makeDiskKey(sessionKey, textHash);
-    const diskEntry = diskEntries.get(diskKey);
-    if (diskEntry && now() - diskEntry.timestamp <= DISK_TTL_MS) {
-        stats.diskHits += 1;
-        const mem = ensureSession(sessionKey);
-        mem.set(textHash, { signature: diskEntry.signature, timestamp: now() });
-        return diskEntry.signature;
-    }
-    stats.misses += 1;
-    return undefined;
-}
-export function getLastThoughtSignature(sessionKey) {
-    if (!sessionKey)
-        return undefined;
-    return sessionLast.get(sessionKey);
-}
-export function shouldHandleThoughtSignature(ctx) {
-    const provider = typeof ctx.providerId === 'string' ? ctx.providerId.toLowerCase() : '';
-    if (provider === 'antigravity')
-        return true;
-    const profile = typeof ctx.profileId === 'string' ? ctx.profileId.toLowerCase() : '';
-    return profile.includes('antigravity');
-}