progmune-runtime 2.1.5 → 3.2.0

package/dist/identifier-parser.js

@@ -0,0 +1,260 @@
+"use strict";
+/**
+ * Identifier Parser — decompose compound identifiers into semantic tokens.
+ *
+ * The \b boundary in regex fails on compound names:
+ *   registerNewUser → \bregister\b doesn't match
+ *   doLogin → \blogin\b doesn't match
+ *   performAuthentication → \bauthenticate\b doesn't match
+ *
+ * This parser splits camelCase/snake_case identifiers and
+ * extracts verbs, entities, and actions from compound names.
+ *
+ * Not AST. Just smarter string splitting.
+ *
+ * Examples:
+ *   registerNewUser      → tokens: [register, new, user]       → verb: register
+ *   doLogin              → tokens: [do, login]                 → verb: login
+ *   performAuthentication → tokens: [perform, authentication]  → verb: authenticate
+ *   verifyTokenSignature → tokens: [verify, token, signature]  → verb: verify
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = tokenize;
+exports.stripCPrefix = stripCPrefix;
+exports.isCNaming = isCNaming;
+exports.parseIdentifier = parseIdentifier;
+exports.enrichCalls = enrichCalls;
+// ═══════════════════════════════════════════════════════════════
+// Tokenizer
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Split a camelCase or PascalCase identifier into lowercase tokens.
+ * Optionally strips C project prefixes before tokenizing.
+ */
+function tokenize(identifier, options) {
+    let name = identifier;
+    if (options?.stripCPrefix) {
+        name = stripCPrefix(identifier);
+    }
+    // Split on camelCase boundaries
+    const tokens = [];
+    let current = "";
+    for (let i = 0; i < name.length; i++) {
+        const ch = name[i];
+        if (ch >= "A" && ch <= "Z" && current.length > 0) {
+            tokens.push(current.toLowerCase());
+            current = ch;
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.length > 0) {
+        tokens.push(current.toLowerCase());
+    }
+    // Also split on underscores
+    const flat = [];
+    for (const t of tokens) {
+        flat.push(...t.split("_").filter(Boolean));
+    }
+    return flat.filter(t => t.length >= 2);
+}
+// ═══════════════════════════════════════════════════════════════
+// Verb Database
+// ═══════════════════════════════════════════════════════════════
+const VERB_SYNONYMS = {
+    // Registration / Auth
+    register: "register", signup: "register", signUp: "register", createAccount: "register",
+    login: "login", signin: "login", signIn: "login", logon: "login", authenticate: "login",
+    logout: "logout", signout: "logout", signOut: "logout", logoff: "logout",
+    // CRUD
+    create: "create", add: "create", insert: "create", new: "create", make: "create", build: "create",
+    delete: "delete", remove: "delete", destroy: "delete", drop: "delete", clear: "delete", erase: "delete",
+    update: "update", edit: "update", modify: "update", change: "update", set: "update", put: "update",
+    get: "get", fetch: "get", retrieve: "get", read: "get", load: "get", find: "get", query: "get",
+    list: "list", search: "list", all: "list", browse: "list", enumerate: "list",
+    // Actions
+    assign: "assign", transfer: "transfer", share: "share", schedule: "schedule",
+    upload: "upload", download: "download", send: "send", post: "post", publish: "post",
+    process: "process", verify: "verify", validate: "validate", check: "verify",
+    authorize: "authorize", permit: "authorize", allow: "authorize",
+    toggle: "toggle", lock: "lock", unlock: "unlock", enable: "enable", disable: "disable",
+    perform: "perform", execute: "execute", run: "execute", do: "do",
+    start: "start", begin: "start", stop: "stop", end: "stop", cancel: "cancel", abort: "cancel",
+    // ── C Verbs (additive only — no duplicates with entries above) ──
+    init: "init", initialize: "init", initialise: "init",
+    config: "config", configure: "config", cfg: "config", setup: "config",
+    handshake: "connect", negotiate: "connect",
+    free: "free", cleanup: "free", dispose: "free",
+    alloc: "alloc", allocate: "alloc", malloc: "alloc", calloc: "alloc", realloc: "alloc",
+    kex: "kex", ecdh: "ecdh", dh: "dh", curve: "curve", derive: "derive",
+    bind: "bind", listen: "listen", accept: "accept",
+    recv: "recv", write: "write",
+    open: "open", close: "close", shutdown: "close",
+    pin: "pin", cert: "cert", certificate: "cert",
+    poll: "poll",
+    parse: "parse", decode: "decode", encode: "encode",
+    copy: "copy", move: "move", rename: "rename",
+    hash: "hash", sign: "sign", encrypt: "encrypt", decrypt: "decrypt",
+    seed: "seed", random: "random", generate: "generate",
+    finish: "finish", complete: "finish", done: "finish",
+    reset: "reset", restart: "reset", reload: "reset",
+    flush: "flush", sync: "sync", commit: "commit", rollback: "rollback",
+};
+/**
+ * Map a token to its canonical verb form.
+ * Handles common suffixes: authentication→authenticate, verification→verify, etc.
+ */
+function canonicalVerb(token) {
+    // Direct match
+    if (VERB_SYNONYMS[token])
+        return VERB_SYNONYMS[token];
+    // Stemming: authentication → authenticate, registration → register
+    const stemMap = {
+        authentication: "authenticate", registration: "register",
+        verification: "verify", validation: "validate",
+        authorization: "authorize", creation: "create",
+        deletion: "delete", modification: "modify", updation: "update",
+        assignment: "assign", transfer: "transfer",
+        execution: "execute", cancellation: "cancel",
+        notification: "notify", publication: "publish",
+        // C-style stems
+        initialization: "init", initialisation: "init",
+        configuration: "config", allocation: "alloc",
+        negotiation: "negotiate", connection: "connect",
+        derivation: "derive", generation: "generate",
+        encryption: "encrypt", decryption: "decrypt",
+        completion: "finish", destruction: "destroy",
+    };
+    if (stemMap[token])
+        return stemMap[token];
+    // -ize / -ise suffix: finalize→final, synchronize→sync, sanitize→sanitize
+    if (token.endsWith("ize") || token.endsWith("ise")) {
+        const base = token.slice(0, token.endsWith("ize") ? -3 : -3);
+        if (VERB_SYNONYMS[base])
+            return VERB_SYNONYMS[base];
+        return base; // finalize → final, sanitize → sanitize
+    }
+    // Common suffixes: -ing, -ed, -ion
+    if (token.endsWith("ing")) {
+        const base = token.slice(0, -3);
+        if (VERB_SYNONYMS[base])
+            return VERB_SYNONYMS[base];
+        // running → run, stopping → stop
+        if (base.endsWith("nn"))
+            return base.slice(0, -1); // running → run
+        if (base.endsWith("pp"))
+            return base.slice(0, -1); // stopping → stop
+        return base; // creating → create
+    }
+    if (token.endsWith("ed")) {
+        const base = token.slice(0, -2);
+        if (VERB_SYNONYMS[base])
+            return VERB_SYNONYMS[base];
+        if (base.endsWith("i"))
+            return base.slice(0, -1) + "y"; // verified → verify
+        return base; // created → create
+    }
+    return null;
+}
+// ═══════════════════════════════════════════════════════════════
+// C Prefix Stripping
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Known C project/library prefixes that hide semantic verbs.
+ * Curl_conn_connect → after stripping: conn_connect
+ * ssh_userauth_agent → after stripping: userauth_agent
+ */
+const C_PROJECT_PREFIXES = [
+    "Curl_", "curl_", "mbedtls_", "mbed_", "ngx_", "ossl_",
+    "SSL_", "ssh_", "EC_", "EC_KEY_", "EVP_", "DH_", "BN_",
+    "BIO_", "X509_", "SSL_CTX_", "wolfSSL_", "gtls_", "gcry_",
+    "OSSL_PARAM_", "OPENSSL_", "CONF_",
+];
+/**
+ * Strip known C project prefixes from a function name.
+ * For example: Curl_auth_create_ntlm_type1_message → auth_create_ntlm_type1_message
+ */
+function stripCPrefix(name) {
+    for (const prefix of C_PROJECT_PREFIXES) {
+        if (name.startsWith(prefix))
+            return name.slice(prefix.length);
+    }
+    return name;
+}
+/**
+ * Detect if an identifier looks like C naming (has known C prefix or is all snake_case).
+ */
+function isCNaming(name) {
+    // Check known C prefixes
+    for (const prefix of C_PROJECT_PREFIXES) {
+        if (name.startsWith(prefix))
+            return true;
+    }
+    // Check if it's pure snake_case with no camelCase boundaries
+    if (name.includes("_") && !/[a-z][A-Z]/.test(name))
+        return true;
+    return false;
+}
+/**
+ * Parse a function name into semantic components.
+ *
+ * registerNewUser → { verb: "register", entity: "user", isMutate: true }
+ * getContact     → { verb: "get", entity: "contact", isRead: true }
+ * doLogin        → { verb: "login", entity: null, isMutate: true }
+ */
+function parseIdentifier(functionName, options) {
+    const tokens = tokenize(functionName, options);
+    let verb = null;
+    let entity = null;
+    // Find the first meaningful verb token
+    // Skip helper prefixes: do, perform, execute, run
+    for (let i = 0; i < tokens.length; i++) {
+        // If this is a helper prefix and there's a next token, use the next token as verb
+        if (["do", "perform", "execute", "run"].includes(tokens[i]) && i + 1 < tokens.length) {
+            const nextCv = canonicalVerb(tokens[i + 1]);
+            if (nextCv) {
+                verb = nextCv;
+                entity = tokens.slice(i + 2).filter(t => t.length >= 2 && !["new", "the", "for", "by", "to", "of", "in", "on", "at"].includes(t)).join("_") || null;
+                break;
+            }
+            // Even without canonical form, use the next token as verb
+            verb = tokens[i + 1];
+            entity = tokens.slice(i + 2).filter(t => t.length >= 2).join("_") || null;
+            break;
+        }
+        const cv = canonicalVerb(tokens[i]);
+        if (cv) {
+            verb = cv;
+            // Entity = remaining tokens after the verb
+            const remaining = tokens.slice(i + 1).filter(t => t.length >= 2 && !["new", "the", "for", "by", "to", "of", "in", "on", "at", "my", "our", "all", "one"].includes(t));
+            if (remaining.length > 0) {
+                entity = remaining.join("_");
+            }
+            break;
+        }
+    }
+    // If no canonical verb found, use the first token as-is
+    if (!verb && tokens.length > 0) {
+        verb = tokens[0];
+        if (tokens.length > 1) {
+            entity = tokens.slice(1).join("_");
+        }
+    }
+    const readVerbs = new Set(["get", "fetch", "retrieve", "read", "load", "find", "query", "list", "search", "browse", "view"]);
+    const mutateVerbs = new Set(["create", "add", "insert", "delete", "remove", "destroy", "update", "edit", "modify", "set", "register", "login", "logout", "assign", "transfer", "share", "upload", "send", "post", "process", "toggle", "lock", "unlock", "execute", "perform", "cancel"]);
+    return {
+        original: functionName,
+        tokens,
+        verb,
+        entity,
+        isRead: verb !== null && readVerbs.has(verb),
+        isMutate: verb !== null && mutateVerbs.has(verb),
+    };
+}
+/**
+ * Parse all function names in a call list and return enriched call data.
+ */
+function enrichCalls(calls) {
+    return calls.map(c => parseIdentifier(c));
+}

package/dist/immune-metrics.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Immune Metrics — real-time tracking of immune system efficacy.
+ *
+ * Tracks:
+ *   1. Immune repair success rate (antibody hits → successful repairs)
+ *   2. Token savings from L1 hints + L2 fast paths
+ *   3. Credit-weighted vs unweighted planning success delta
+ *
+ * These metrics answer: "Is the knowledge layer actually improving outcomes?"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeImmuneMetrics = computeImmuneMetrics;
+exports.formatImmuneMetrics = formatImmuneMetrics;
+exports.reportImmuneMetrics = reportImmuneMetrics;
+const failure_corpus_1 = require("./failure-corpus");
+const feedback_1 = require("./feedback");
+/**
+ * Compute live immune metrics from the current corpus.
+ */
+function computeImmuneMetrics() {
+    const stats = (0, failure_corpus_1.getAntibodyStats)();
+    const genome = (0, failure_corpus_1.getFailureGenome)();
+    const learned = (0, failure_corpus_1.getLearnedPatterns)();
+    // Estimate token savings: L2 fast path = full prompt saved, L1 hint = ~200 tokens overhead
+    const TOKENS_PER_LLM_CALL = 800;
+    const tokensSaved = stats.fastPathHits * TOKENS_PER_LLM_CALL + stats.injectedHintHits * 200;
+    // Immune repair rate: what fraction of sessions with antibody hits resolved?
+    const immuneRepairRate = stats.totalHits > 0
+        ? (stats.fastPathHits + stats.injectedHintHits * 0.7) / stats.totalHits
+        : 0;
+    // Count functions with non-Laplace credit scores
+    let functionsWithHistory = 0;
+    let creditSum = 0;
+    let creditCount = 0;
+    for (const p of learned.failureToFix) {
+        for (const fn of (p.fixPath || [])) {
+            const credit = (0, feedback_1.getFailureAdjustedCredit)(fn);
+            if (credit !== 0.5)
+                functionsWithHistory++;
+            creditSum += credit;
+            creditCount++;
+        }
+    }
+    const avgCreditScore = creditCount > 0 ? creditSum / creditCount : 0.5;
+    return {
+        totalAntibodyHits: stats.totalHits,
+        fastPathHits: stats.fastPathHits,
+        injectedHints: stats.injectedHintHits,
+        llmCallsSaved: stats.totalLLMCallsSaved,
+        tokensSaved: stats.totalTokensSaved + tokensSaved,
+        immuneRepairRate: Math.round(immuneRepairRate * 100) / 100,
+        avgCreditScore: Math.round(avgCreditScore * 100) / 100,
+        functionsWithHistory,
+        totalFailures: genome.totalFailures,
+        avgRetriesToSuccess: genome.averageRetriesToSuccess,
+        learnedPatternCount: learned.failureToFix.length,
+    };
+}
+/**
+ * Format immune metrics as a human-readable report.
+ */
+function formatImmuneMetrics(m) {
+    const lines = [
+        "═══════ Immune System Metrics ═══════",
+        "",
+        "── Efficacy ──",
+        `  Total antibody hits:       ${m.totalAntibodyHits}`,
+        `  ACL-4 fast paths (0 LLM):  ${m.fastPathHits}`,
+        `  ACL-3 injected hints:      ${m.injectedHints}`,
+        `  LLM calls saved:           ${m.llmCallsSaved}`,
+        `  Est. tokens saved:         ${m.tokensSaved.toLocaleString()}`,
+        `  Immune repair rate:        ${(m.immuneRepairRate * 100).toFixed(0)}%`,
+        "",
+        "── Knowledge ROI ──",
+        `  Avg credit score:          ${m.avgCreditScore}`,
+        `  Functions with history:    ${m.functionsWithHistory}`,
+        `  Learned patterns:          ${m.learnedPatternCount}`,
+        "",
+        "── Failure Landscape ──",
+        `  Total failures:            ${m.totalFailures}`,
+        `  Avg retries to success:    ${m.avgRetriesToSuccess.toFixed(1)}`,
+        "",
+        "══════════════════════════════════════",
+    ];
+    return lines.join("\n");
+}
+/** Print current immune metrics to stderr. */
+function reportImmuneMetrics() {
+    const m = computeImmuneMetrics();
+    console.error(formatImmuneMetrics(m));
+    return m;
+}

package/dist/immune-receiver.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Immune Network Receiver — the missing half of the global immune network.
+ *
+ * Accepts external failure fingerprints (from remote instances or file imports),
+ * deduplicates against local records, and merges them into the local corpus.
+ *
+ * This closes the "send-only" gap: immune-reporter.ts pushes out, this pulls in.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importFingerprints = importFingerprints;
+exports.importFromFile = importFromFile;
+exports.getReceiverStats = getReceiverStats;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const CORPUS_DIR = path.resolve(__dirname, "..", ".progmune_corpus");
+const RECEIVED_FILE = path.resolve(__dirname, "..", ".progmune_memory", "received_fingerprints.json");
+/** Hash a fingerprint for deduplication. */
+function hashFingerprint(fp) {
+    const key = `${fp.instance_id}:${fp.timestamp}:${fp.violatedSVL}:${fp.constraintType}:${(fp.functionSequence || []).join(",")}`;
+    return crypto.createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+/** Load the set of previously received fingerprint hashes. */
+function getReceivedHashes() {
+    try {
+        if (fs.existsSync(RECEIVED_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(RECEIVED_FILE, "utf-8"));
+            return new Set(raw.hashes || []);
+        }
+    }
+    catch { /* receiver log may be unavailable */ }
+    return new Set();
+}
+/** Save received fingerprint hashes. */
+function saveReceivedHashes(hashes) {
+    const dir = path.dirname(RECEIVED_FILE);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(RECEIVED_FILE, JSON.stringify({
+        hashes: [...hashes],
+        updatedAt: new Date().toISOString(),
+        total: hashes.size,
+    }, null, 2));
+}
+/**
+ * Import external fingerprints into the local failure corpus.
+ * Deduplicates: each fingerprint is only imported once.
+ *
+ * @returns count of imported and skipped fingerprints.
+ */
+function importFingerprints(fingerprints) {
+    const received = getReceivedHashes();
+    let imported = 0;
+    let skipped = 0;
+    for (const fp of fingerprints) {
+        const hash = hashFingerprint(fp);
+        if (received.has(hash)) {
+            skipped++;
+            continue;
+        }
+        // Write fingerprint into the corpus as a failure record
+        const today = new Date().toISOString().slice(0, 10);
+        const dateDir = path.join(CORPUS_DIR, today);
+        if (!fs.existsSync(dateDir))
+            fs.mkdirSync(dateDir, { recursive: true });
+        // Get next sequence number
+        const seqFile = path.join(CORPUS_DIR, ".seq");
+        let seq = 1;
+        try {
+            if (fs.existsSync(seqFile)) {
+                seq = parseInt(fs.readFileSync(seqFile, "utf-8"), 10) + 1;
+            }
+        }
+        catch { /* best-effort */ }
+        const record = {
+            intent: `[remote:${fp.instance_id}] ${fp.constraintType}`,
+            functionPath: fp.functionSequence,
+            violatedSVL: fp.violatedSVL,
+            constraintType: fp.constraintType,
+            preState: fp.preState,
+            postState: fp.postState,
+            fingerprintHash: hash,
+            sourceInstance: fp.instance_id,
+            sourceTimestamp: fp.timestamp,
+            importedAt: new Date().toISOString(),
+        };
+        const fileName = `fail_${Date.now()}_${seq}.json`;
+        fs.writeFileSync(path.join(dateDir, fileName), JSON.stringify(record, null, 2));
+        // Update sequence
+        fs.writeFileSync(seqFile, String(seq));
+        received.add(hash);
+        imported++;
+    }
+    saveReceivedHashes(received);
+    return { imported, skipped, total: fingerprints.length };
+}
+/**
+ * Import fingerprints from a JSON file (e.g., downloaded from the Hub).
+ */
+function importFromFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return { imported: 0, skipped: 0, total: 0 };
+    }
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const fingerprints = Array.isArray(raw)
+        ? raw
+        : (raw.fingerprints || []);
+    return importFingerprints(fingerprints);
+}
+/**
+ * Get import statistics: how many external fingerprints have been received.
+ */
+function getReceiverStats() {
+    const hashes = getReceivedHashes();
+    let lastUpdated = null;
+    try {
+        if (fs.existsSync(RECEIVED_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(RECEIVED_FILE, "utf-8"));
+            lastUpdated = raw.updatedAt || null;
+        }
+    }
+    catch { /* best-effort */ }
+    return { totalReceived: hashes.size, lastUpdated };
+}

package/dist/immune-reporter.js

@@ -53,7 +53,7 @@ function getReportCursor() {
         if (fs.existsSync(CURSOR_FILE))
             return JSON.parse(fs.readFileSync(CURSOR_FILE, "utf-8"));
     }
-    catch { }
+    catch { /* report may be unavailable */ }
     return { lastTimestamp: null, reportedCount: 0 };
 }
 function saveReportCursor(timestamp, count) {