@antodevs/groundtruth 0.1.0

package/src/env.js

@@ -0,0 +1,120 @@
+/**
+ * @module env
+ * @description Scrive config automagica in files dot rc zsh/fish/bash sessione auth.
+ */
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { chalk, ts, LOG_WARN, LOG_OK, log } from './logger.js';
+import { atomicWrite } from './utils/atomic-write.js';
+
+// ─── Setup shell environment ─────────────────────────
+
+/**
+ * @description Applica environment variables a vari rc profile bash fish unix
+ * @param {number} p - HTTP default porta su local instance target
+ * @returns {Promise<void>} Operazione asincrona
+ */
+export async function autoSetEnv(p) {
+    if (process.platform === 'win32') return;
+    try {
+        const targetUrl = `http://localhost:${p}`;
+        if (process.env.ANTHROPIC_BASE_URL === targetUrl) return;
+
+        const homeDir = os.homedir();
+        // Test exist pattern specifico shell config di fish locale
+        const isFish = process.env.SHELL?.includes('fish') || existsSync(`${homeDir}/.config/fish/config.fish`);
+        let foundAny = false;
+        const modifiedFiles = [];
+
+        if (isFish) {
+            const fishConfigFile = path.join(homeDir, '.config', 'fish', 'config.fish');
+            await fs.mkdir(path.dirname(fishConfigFile), { recursive: true });
+            foundAny = true;
+            try {
+                let content = existsSync(fishConfigFile) ? await fs.readFile(fishConfigFile, 'utf8') : '';
+                const lines = content ? content.split('\n') : [];
+                let modified = false, foundExport = false;
+
+                const newLines = lines.map(line => {
+                    if (line.trim().startsWith('set -gx ANTHROPIC_BASE_URL')) {
+                        foundExport = true;
+                        if (line.trim() !== `set -gx ANTHROPIC_BASE_URL ${targetUrl}`) { modified = true; return `set -gx ANTHROPIC_BASE_URL ${targetUrl}`; }
+                    }
+                    return line;
+                });
+
+                if (!foundExport) {
+                    if (newLines.length > 0 && newLines[newLines.length - 1] === '') {
+                        newLines[newLines.length - 1] = `set -gx ANTHROPIC_BASE_URL ${targetUrl}`;
+                        newLines.push('');
+                    } else {
+                        newLines.push(`set -gx ANTHROPIC_BASE_URL ${targetUrl}`);
+                    }
+                    modified = true;
+                }
+
+                if (modified) {
+                    await atomicWrite(fishConfigFile, newLines.join('\n'));
+                    modifiedFiles.push(fishConfigFile);
+                }
+            } catch (e) {
+                log(LOG_WARN, chalk.yellow, chalk.white('cannot write fish config') + `  →  ${chalk.yellow(e.message)}`);
+            }
+        } else {
+            const shellFiles = ['.zshrc', '.bashrc', '.bash_profile', '.profile'].map(f => path.join(homeDir, f));
+            for (const file of shellFiles) {
+                if (!existsSync(file)) continue;
+                foundAny = true;
+                try {
+                    const content = await fs.readFile(file, 'utf8');
+                    const lines = content.split('\n');
+                    let modified = false, foundExport = false;
+
+                    const newLines = lines.map(line => {
+                        if (line.trim().startsWith('export ANTHROPIC_BASE_URL=')) {
+                            foundExport = true;
+                            if (line.trim() !== `export ANTHROPIC_BASE_URL=${targetUrl}`) { modified = true; return `export ANTHROPIC_BASE_URL=${targetUrl}`; }
+                        }
+                        return line;
+                    });
+
+                    if (!foundExport) {
+                        if (newLines.length > 0 && newLines[newLines.length - 1] === '') {
+                            newLines[newLines.length - 1] = `export ANTHROPIC_BASE_URL=${targetUrl}`;
+                            newLines.push('');
+                        } else {
+                            newLines.push(`export ANTHROPIC_BASE_URL=${targetUrl}`);
+                        }
+                        modified = true;
+                    }
+
+                    if (modified) {
+                        await atomicWrite(file, newLines.join('\n'));
+                        modifiedFiles.push(file);
+                    }
+                } catch (e) {
+                    log(LOG_WARN, chalk.yellow, chalk.white(`cannot write ${path.basename(file)}`) + `  →  ${chalk.yellow(e.message)}`);
+                }
+            }
+        }
+
+        if (!foundAny) {
+            const hint = isFish
+                ? `set -gx ANTHROPIC_BASE_URL ${targetUrl}`
+                : `export ANTHROPIC_BASE_URL=${targetUrl}`;
+            log(LOG_WARN, chalk.yellow, chalk.white('no shell config found') + `  →  ${chalk.yellow('add manually: ' + hint)}`);
+        } else if (modifiedFiles.length > 0) {
+            // Segnala write su standard node path a console utente post process
+            modifiedFiles.forEach(file => {
+                const rel = file.replace(homeDir, '~');
+                log(LOG_OK, chalk.green, chalk.white('ANTHROPIC_BASE_URL written to') + ' ' + chalk.white(rel));
+            });
+        }
+
+        process.env.ANTHROPIC_BASE_URL = targetUrl;
+    } catch (err) {
+        log(LOG_WARN, chalk.yellow, chalk.white('env setup error') + `  →  ${chalk.yellow(err.message)}`);
+    }
+}

package/src/http-agent.js

@@ -0,0 +1,21 @@
+/**
+ * @module http-agent
+ * @description Pool manager per connessioni API http e requests HTTPS in proxy context.
+ */
+import { Agent as HttpsAgent } from 'https';
+import { Agent as HttpAgent } from 'http';
+
+// Evita timeout TCP handshakes costanti per network node-fetch requests proxy target
+export const httpsAgent = new HttpsAgent({
+    keepAlive: true,
+    maxSockets: 10,
+    maxFreeSockets: 5,
+    timeout: 5000,
+});
+
+export const httpAgent = new HttpAgent({
+    keepAlive: true,
+    maxSockets: 10,
+    maxFreeSockets: 5,
+    timeout: 5000,
+});

package/src/inject.js

@@ -0,0 +1,93 @@
+/**
+ * @module inject
+ * @description Gestisce l'aggiunta o check dei file skills GEMINI.md system.
+ */
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { chalk, log, LOG_WARN, LOG_REFRESH } from './logger.js';
+import { atomicWrite } from './utils/atomic-write.js';
+
+// ─── Document injection rules ────────────────────────
+
+/**
+ * @description Aggiorna block target per block id customizzati in hash
+ * @param {string} filePath - Absolute path write operation target rule doc file
+ * @param {string} content  - Content plain formattato markdown text raw update
+ * @param {string} blockId  - identificativo 8 char associato
+ * @returns {Promise<void>}
+ */
+export async function injectBlock(filePath, content, blockId) {
+    let fileContent = '';
+    if (existsSync(filePath)) {
+        fileContent = await fs.readFile(filePath, 'utf8');
+    }
+    const startTag = `<!-- groundtruth:block-${blockId}:start -->`;
+    const endTag = `<!-- groundtruth:block-${blockId}:end -->`;
+    const block = `${startTag}\n${content.trim()}\n${endTag}`;
+
+    const startIndex = fileContent.indexOf(startTag);
+    const endIndex = fileContent.indexOf(endTag);
+
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+        fileContent = fileContent.slice(0, startIndex) + block + fileContent.slice(endIndex + endTag.length);
+    } else {
+    }
+
+    await atomicWrite(filePath, fileContent);
+}
+
+/**
+ * @description Identifica blocchi dipendenze vecchi invalidati e li cancella dal file
+ * @param {string} filePath       - File path workspace markdown context rules locale
+ * @param {Set}    activeBlockIds - ids attivi elaborati nel watcher logic timer task loop cycle
+ * @returns {Promise<void>}
+ */
+export async function removeStaleBlocks(filePath, activeBlockIds) {
+    if (!existsSync(filePath)) return;
+    let fileContent = await fs.readFile(filePath, 'utf8');
+    const regex = /<!-- groundtruth:block-(\w+):start -->[\s\S]*?<!-- groundtruth:block-\w+:end -->/g;
+
+    let modified = false;
+    fileContent = fileContent.replace(regex, (match, blockId) => {
+        if (!activeBlockIds.has(blockId)) {
+            log(LOG_REFRESH, chalk.yellow, chalk.white(`removed stale block ${blockId} from GEMINI.md`));
+            modified = true;
+            return '';
+        }
+        return match;
+    });
+
+    if (modified) {
+        fileContent = fileContent.replace(/\n{3,}/g, '\n\n').trim() + '\n';
+        await atomicWrite(filePath, fileContent);
+    }
+}
+
+/**
+ * @description Interfaccia logic per sincronizzare multiple blocks local workspace skill context
+ * @param {Array} blocks  - Blocchi aggiornati
+ * @returns {Promise<void>}
+ */
+export async function updateGeminiFiles(blocks) {
+    const homeDir = os.homedir();
+    const rulesDir = path.join(process.cwd(), '.gemini');
+    await fs.mkdir(rulesDir, { recursive: true });
+    const skillFile = path.join(rulesDir, 'GEMINI.md');
+
+    const globalRulesDir = path.join(homeDir, '.gemini');
+    await fs.mkdir(globalRulesDir, { recursive: true });
+    const globalSkillFile = path.join(globalRulesDir, 'GEMINI.md');
+
+    const samePath = path.resolve(globalSkillFile) === path.resolve(skillFile);
+
+    for (const b of blocks) {
+        if (samePath) {
+            await injectBlock(skillFile, b.workspaceContent, b.blockId);
+        } else {
+            await injectBlock(globalSkillFile, b.globalContent, b.blockId);
+            await injectBlock(skillFile, b.workspaceContent, b.blockId);
+        }
+    }
+}

package/src/logger.js

@@ -0,0 +1,47 @@
+/**
+ * @module logger
+ * @description Utilities per log formattati con chalk e timestamp.
+ */
+import chalk from 'chalk';
+
+// ─── Constants ───────────────────────────────────────
+
+export const LOG_OK = '✓';
+export const LOG_WARN = '⚠';
+export const LOG_BOLT = '⚡';
+export const LOG_REFRESH = '↻';
+export const LOG_DOT = '◆';
+export const LOG_STAR = '✻';
+
+// ─── Formattazione ───────────────────────────────────
+
+/**
+ * @description Genera timestamp corrente per i log in formato loc-IT.
+ * @returns {string} Timestamp grigio
+ */
+export function ts() {
+    return chalk.gray(new Date().toLocaleTimeString('it-IT'));
+}
+
+/**
+ * @description Crea una label allineata per l'output CLI di startup.
+ * @param   {string} sym   - Simbolo bullet
+ * @param   {string} name  - Nome del campo label
+ * @param   {string} value - Valore associato
+ * @returns {string} Stringa interpolata e colorata
+ */
+export function label(sym, name, value) {
+    return `  ${chalk.cyan(sym)} ${chalk.gray(name.padEnd(9))} ${chalk.white(value)}`;
+}
+
+/**
+ * @description Stampa un messaggio log standardizzato con timestamp.
+ * @param {string}   symbol  - Simbolo costante da prefissare
+ * @param {Function} colorFn - Funzione chalk per colorare il prefisso
+ * @param {...any}   parts   - Testo del log iterabile
+ */
+export function log(symbol, colorFn, ...parts) {
+    console.log(`  ${colorFn(symbol)} ${ts()}  ${parts.join(' ')}`);
+}
+
+export { chalk }; // Centralizziamo chalk per evitare import duplicati altrove

package/src/packages.js

@@ -0,0 +1,87 @@
+/**
+ * @module packages
+ * @description Utilita per estrarre il package array e generare queries LLM a blocchi.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { createHash } from 'crypto';
+
+// ─── Logica Dipendenze ───────────────────────────────
+
+/**
+ * @description Analizza deps di system locali escludendo packages non rilevanti
+ * @returns {Promise<Array|null>} Array strings stack locale o null in fallback error
+ */
+export async function readPackageDeps() {
+    try {
+        const pkgPath = path.resolve(process.cwd(), 'package.json');
+        try {
+            await fs.access(pkgPath);
+        } catch (_) {
+            return null;
+        }
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+
+        const excludeList = ["plugin", "adapter", "check", "eslint", "prettier", "vite", "rollup", "webpack", "babel"];
+
+        const filterAndFormat = (depsObj) => {
+            if (!depsObj) return [];
+            return Object.entries(depsObj)
+                .filter(([n]) => !excludeList.some(ex => n.toLowerCase().includes(ex)))
+                .map(([n, v]) => {
+                    let cleanName = n;
+                    if (n === '@sveltejs/kit') cleanName = 'sveltekit';
+                    else if (n.startsWith('@')) cleanName = n.split('/')[1];
+                    let cleanVersion = String(v).replace(/[\^~>=<]/g, '').split('.').slice(0, 2).join('.');
+                    return `${cleanName} ${cleanVersion}`;
+                });
+        };
+
+        let selected = filterAndFormat(pkg.dependencies);
+        selected = selected.concat(filterAndFormat(pkg.devDependencies));
+
+        return selected.length > 0 ? selected : null;
+    } catch (_) {
+        return null;
+    }
+}
+
+/**
+ * @description Raggruppa l'array delle dipendenze in chunk di dimensione fissa.
+ * @param {Array}  deps      - Array completo formattato
+ * @param {number} batchSize - Dimensione forzata dei chuncks
+ * @returns {Array<Array>} Array bidimensionale aggregato a batches 
+ */
+export function groupIntoBatches(deps, batchSize = 3) {
+    if (!deps || !deps.length) return [];
+    const batches = [];
+    for (let i = 0; i < deps.length; i += batchSize) {
+        batches.push(deps.slice(i, i + batchSize));
+    }
+    return batches;
+}
+
+/**
+ * @description Genera crypto hash string id da chunk object signature elements array
+ * @param {Array} batch - chunk elements content package string names 
+ * @returns {string} short 8 character identifier digest
+ */
+export function batchHash(batch) {
+    return createHash('md5')
+        .update(batch.join(','))
+        .digest('hex')
+        .slice(0, 8);
+}
+
+/**
+ * @description Costruisce logica query concats DDG su input array e hardcoded filter.
+ * @param   {Array} deps   - Array validato input dipendenze system
+ * @returns {string} Target string duck duck query
+ */
+export function buildQuery(deps) {
+    const year = new Date().getFullYear();
+    if (deps && deps.length > 0) {
+        return `${deps.join(' ')} latest ${year}`;
+    }
+    return `javascript web development best practices ${year}`;
+}

package/src/proxy.js

@@ -0,0 +1,164 @@
+/**
+ * @module proxy
+ * @description Proxy node routing Anthropic/Gemini http server streaming protocol.
+ */
+import http from 'http';
+import https from 'https';
+import { webSearch } from './search.js';
+import { readPackageDeps, buildQuery } from './packages.js';
+import { chalk, log, LOG_WARN, LOG_BOLT } from './logger.js';
+import { httpsAgent } from './http-agent.js';
+
+// ─── HTTP Node server daemon ─────────────────────────
+
+/**
+ * @description Main listener Anthropic port interceptor content system stream 
+ * @param   {boolean} usePackageJson - Overrides per fallback module args
+ * @returns {Promise<http.Server>} Istanza server network configurata listen loop
+ */
+export async function createServer(usePackageJson) {
+    let packageQueryCache = null;
+    if (usePackageJson) {
+        const depEntries = await readPackageDeps();
+        if (depEntries) packageQueryCache = buildQuery(depEntries);
+    }
+
+    const server = http.createServer(async (req, res) => {
+        if (req.method !== 'POST') { res.writeHead(404); res.end(); return; }
+
+        let protocol = null;
+        if (req.url.startsWith('/v1/messages')) {
+            protocol = 'ANTHROPIC';
+        } else if (req.url.startsWith('/v1beta/models/') && (req.url.includes('generateContent') || req.url.includes('streamGenerateContent'))) {
+            protocol = 'GEMINI';
+        } else {
+            res.writeHead(404); res.end(); return;
+        }
+
+        try {
+            const MAX_PAYLOAD_SIZE = 10 * 1024 * 1024; // 10MB limit
+            let bodyChunks = [];
+            let bodyLength = 0;
+            for await (const chunk of req) {
+                bodyLength += chunk.length;
+                if (bodyLength > MAX_PAYLOAD_SIZE) {
+                    res.writeHead(413, { 'Content-Type': 'text/plain' });
+                    res.end('Payload Too Large');
+                    return;
+                }
+                bodyChunks.push(chunk);
+            }
+            const rawBody = Buffer.concat(bodyChunks);
+
+            let parsedBody;
+            try {
+                parsedBody = JSON.parse(rawBody.toString('utf8'));
+            } catch (_) {
+                res.writeHead(400); res.end('Bad Request - Invalid JSON'); return;
+            }
+
+            // Estrai query last context check iter logic object
+            let lastUserMessage = '';
+            if (protocol === 'ANTHROPIC') {
+                const lastUserM = (parsedBody.messages || []).slice().reverse().find(m => m.role === 'user');
+                if (lastUserM) {
+                    lastUserMessage = typeof lastUserM.content === 'string'
+                        ? lastUserM.content
+                        : (Array.isArray(lastUserM.content) ? lastUserM.content.map(c => c.text || '').join(' ') : '');
+                }
+            } else if (protocol === 'GEMINI') {
+                const lastUserM = (parsedBody.contents || []).slice().reverse().find(m => m.role === 'user');
+                if (lastUserM && Array.isArray(lastUserM.parts)) {
+                    lastUserMessage = lastUserM.parts.map(p => p.text || '').join(' ');
+                }
+            }
+
+            let query, shortMsg;
+            if (packageQueryCache) {
+                query = packageQueryCache;
+                shortMsg = 'package.json deps';
+            } else {
+                const text = lastUserMessage || '';
+                shortMsg = text.replace(/\s+/g, ' ').trim().slice(0, 50);
+                query = text.slice(0, 120).replace(/[^\w\s]/g, ' ').replace(/\s+/g, ' ').trim();
+                const year = new Date().getFullYear();
+                query = `${query} ${year}`.trim();
+            }
+
+            const t0 = Date.now();
+            let contextBlock = '';
+            let didInject = false;
+            let resultsCount = 0;
+
+            try {
+                if (!query || query.trim() === String(new Date().getFullYear())) throw new Error('Empty query');
+                // parallel load in proxy app process to boost response load
+                const { results, pageText } = await webSearch(query, true);
+                resultsCount = results.length;
+
+                contextBlock = `\n\n--- WEB CONTEXT (live, ${new Date().toISOString()}) ---\n`;
+                results.forEach((r, i) => {
+                    contextBlock += `${i + 1}. ${r.title}: ${r.snippet} (${r.url})\n`;
+                });
+                if (pageText) contextBlock += `\nFULL TEXT:\n${pageText}\n`;
+                contextBlock += `--- END WEB CONTEXT ---\n`;
+                didInject = true;
+            } catch (_) {
+                log(LOG_WARN, chalk.yellow, chalk.white('web fetch failed') + `  →  ${chalk.yellow('forwarding clean')}`);
+            }
+
+            const ms = Date.now() - t0;
+
+            if (didInject) {
+                log(LOG_BOLT, chalk.cyan, chalk.white(shortMsg.slice(0, 50) + (shortMsg.length > 50 ? '…' : '')) + `  →  ${chalk.cyan.bold(String(resultsCount))} ${chalk.cyan('results')}  ${chalk.gray(ms + 'ms')}`);
+
+                if (protocol === 'ANTHROPIC') {
+                    if (parsedBody.system) {
+                        if (typeof parsedBody.system === 'string') parsedBody.system += contextBlock;
+                        else if (Array.isArray(parsedBody.system)) parsedBody.system.push({ type: 'text', text: contextBlock });
+                    } else {
+                        parsedBody.system = contextBlock;
+                    }
+                } else if (protocol === 'GEMINI') {
+                    if (!parsedBody.systemInstruction) {
+                        parsedBody.systemInstruction = { role: 'system', parts: [] };
+                    }
+                    const sys = parsedBody.systemInstruction;
+                    if (!Array.isArray(sys.parts)) {
+                        if (typeof sys.parts === 'object' && sys.parts !== null) {
+                            sys.parts = [sys.parts];
+                        } else if (typeof sys.parts === 'string') {
+                            sys.parts = [{ text: sys.parts }];
+                        } else {
+                            sys.parts = [];
+                        }
+                    }
+                    sys.parts.push({ text: contextBlock });
+                }
+            }
+
+            const reqBodyStr = JSON.stringify(parsedBody);
+            const targetUrlStr = protocol === 'ANTHROPIC'
+                ? `https://api.anthropic.com${req.url}`
+                : `https://generativelanguage.googleapis.com${req.url}`;
+
+            const targetUrl = new URL(targetUrlStr);
+            const headers = { ...req.headers };
+            delete headers['host'];
+            headers['content-length'] = Buffer.byteLength(reqBodyStr);
+
+            const proxyReq = https.request(targetUrl, { method: req.method, headers, agent: httpsAgent }, (proxyRes) => {
+                res.writeHead(proxyRes.statusCode, proxyRes.headers);
+                proxyRes.pipe(res);
+            });
+            proxyReq.on('error', () => { if (!res.headersSent) { res.writeHead(502); res.end('Bad Gateway'); } });
+            proxyReq.write(reqBodyStr);
+            proxyReq.end();
+
+        } catch (err) {
+            if (!res.headersSent) { res.writeHead(500); res.end('Internal Server Proxy Error'); }
+        }
+    });
+
+    return server;
+}