progmune-runtime 2.1.6 → 3.2.0

package/dist/experimental/unsupervised-physics.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * P6.3: Unsupervised Physics Discovery
+ *
+ * Discovers protocol patterns WITHOUT hand-crafted keywords.
+ * Input: raw call sequences. Output: structural clusters.
+ *
+ * The test: if the system clusters [open,read,close] with
+ * [connect,query,disconnect] WITHOUT knowing the function names,
+ * it has genuinely learned the Acquire→Use→Release pattern.
+ *
+ * Algorithm:
+ *   1. Extract structural fingerprints from call sequences
+ *   2. Cluster by structural similarity (no keyword matching)
+ *   3. Compare discovered clusters to known physics patterns
+ *   4. Measure: are Acquire/Release clusters emergent?
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CROSS_REPO_SEQUENCES = void 0;
+exports.fingerprint = fingerprint;
+exports.fingerprintSequences = fingerprintSequences;
+exports.clusterByStructure = clusterByStructure;
+exports.evaluateUnsupervisedDiscovery = evaluateUnsupervisedDiscovery;
+exports.runUnsupervisedDiscovery = runUnsupervisedDiscovery;
+exports.printUnsupervisedReport = printUnsupervisedReport;
+/**
+ * Extract structural fingerprint from a function in context.
+ * Uses ONLY positional and structural features — NO function names.
+ */
+function fingerprint(fn, index, sequence) {
+    const uniqueFns = new Set(sequence);
+    // Check if sequence forms a closed loop: first and last functions
+    // have structural similarity (both are single-occurrence "boundary" functions)
+    const firstFn = sequence[0];
+    const lastFn = sequence[sequence.length - 1];
+    const firstCount = sequence.filter(f => f === firstFn).length;
+    const lastCount = sequence.filter(f => f === lastFn).length;
+    // Closed loop: first and last are "boundary" functions (appear only once)
+    const isClosedLoop = firstCount === 1 && lastCount === 1 && sequence.length >= 2;
+    return {
+        seqId: sequence.join("→"),
+        length: sequence.length,
+        position: index / Math.max(1, sequence.length - 1),
+        isFirst: index === 0,
+        isLast: index === sequence.length - 1,
+        isClosedLoop,
+        uniqueCount: uniqueFns.size,
+        phase: index === 0 ? 0 : index === sequence.length - 1 ? 2 : 1,
+    };
+}
+/**
+ * Build fingerprints for all functions in a set of sequences.
+ */
+function fingerprintSequences(sequences) {
+    const fps = new Map();
+    for (const seq of sequences) {
+        for (let i = 0; i < seq.length; i++) {
+            const fp = fingerprint(seq[i], i, seq);
+            fps.set(`${seq[i]}@${i}`, fp);
+        }
+    }
+    return fps;
+}
+/**
+ * Cluster sequences by structural similarity ONLY.
+ * No function names. No keywords. Pure topology.
+ */
+function clusterByStructure(sequences) {
+    const features = sequences.map(seq => {
+        const uniqueFns = new Set(seq);
+        const firstFn = seq[0];
+        const lastFn = seq[seq.length - 1];
+        const firstCount = seq.filter(f => f === firstFn).length;
+        const lastCount = seq.filter(f => f === lastFn).length;
+        const closedLoop = firstCount === 1 && lastCount === 1 && seq.length >= 2;
+        // Phase profile: how many functions are at each phase
+        const profile = [0, 0, 0];
+        for (let i = 0; i < seq.length; i++) {
+            const phase = i === 0 ? 0 : i === seq.length - 1 ? 2 : 1;
+            profile[phase]++;
+        }
+        return { seq, length: seq.length, closedLoop, uniqueCount: uniqueFns.size, phaseProfile: profile };
+    });
+    // Clustering: group by [length bucket, closedLoop, uniqueCount]
+    const clusters = new Map();
+    for (const f of features) {
+        const lenBucket = f.length <= 2 ? "short" : f.length <= 4 ? "medium" : "long";
+        const loopKey = f.closedLoop ? "closed" : "open";
+        const key = `${lenBucket}-${loopKey}-${f.uniqueCount}`;
+        if (!clusters.has(key))
+            clusters.set(key, []);
+        clusters.get(key).push(f);
+    }
+    // Convert to DiscoveredCluster
+    const results = [];
+    let id = 0;
+    for (const [key, members] of clusters) {
+        if (members.length < 1)
+            continue;
+        const avgLen = members.reduce((s, m) => s + m.length, 0) / members.length;
+        const closedRate = members.filter(m => m.closedLoop).length / members.length;
+        // Infer physics pattern based on STRUCTURE, not names
+        let inferredPattern;
+        if (closedRate > 0.5 && avgLen >= 3) {
+            inferredPattern = "RESOURCE_ACQUIRE"; // Acquire-Use-Release structure
+        }
+        else if (closedRate > 0.5 && avgLen === 2) {
+            inferredPattern = "LOCK_ACQUIRE"; // Lock-Unlock structure
+        }
+        results.push({
+            id: `C${id++}`,
+            sequences: members.map(m => m.seq),
+            avgLength: avgLen,
+            closedLoopRate: closedRate,
+            signature: key,
+            inferredPattern,
+        });
+    }
+    return results.sort((a, b) => b.sequences.length - a.sequences.length);
+}
+/**
+ * Evaluate whether structural clustering discovers physics patterns.
+ *
+ * This is the KEY test: input raw sequences, output clusters.
+ * If Acquire-Use-Release clusters emerge WITHOUT keyword matching,
+ * the system has genuinely learned protocol structure.
+ */
+function evaluateUnsupervisedDiscovery(sequences) {
+    const clusters = clusterByStructure(sequences);
+    // Check: do clusters match known physics patterns by STRUCTURE alone?
+    let structuralMatches = 0;
+    let sequencesInMatches = 0;
+    for (const c of clusters) {
+        if (c.inferredPattern) {
+            structuralMatches++;
+            sequencesInMatches += c.sequences.length;
+        }
+    }
+    const total = sequences.length;
+    const emergent = structuralMatches > 0 && sequencesInMatches / total > 0.5;
+    return {
+        totalSequences: total,
+        clusters,
+        structuralCoverage: clusters.length > 0 ? structuralMatches / clusters.length : 0,
+        sequenceCoverage: total > 0 ? sequencesInMatches / total : 0,
+        emergent,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Cross-Repo Unsupervised Benchmark
+// ═══════════════════════════════════════════════════════════════
+exports.CROSS_REPO_SEQUENCES = {
+    Redis: [
+        ["createClient", "sendCommand", "closeClient"],
+        ["selectDB", "getKey"],
+        ["createClient", "sendCommand", "readReply", "closeClient"],
+    ],
+    SQLite: [
+        ["sqlite3_open", "sqlite3_exec", "sqlite3_close"],
+        ["sqlite3_prepare", "sqlite3_step", "sqlite3_finalize"],
+        ["sqlite3_open", "sqlite3_prepare", "sqlite3_step", "sqlite3_finalize", "sqlite3_close"],
+    ],
+    nginx: [
+        ["ngx_accept_connection", "ngx_read_request", "ngx_close_connection"],
+        ["ngx_parse_headers", "ngx_send_response"],
+        ["ngx_accept_connection", "ngx_process_request", "ngx_send_response", "ngx_close_connection"],
+    ],
+    PostgreSQL: [
+        ["PQconnectdb", "PQexec", "PQfinish"],
+        ["begin_transaction", "execute_query", "commit_transaction"],
+        ["PQconnectdb", "begin_transaction", "execute_query", "commit_transaction", "PQfinish"],
+    ],
+    LevelDB: [
+        ["DB_Open", "DB_Get", "DB_Close"],
+        ["DB_Open", "DB_Put", "DB_Close"],
+        ["DB_Open", "DB_Write", "DB_Compact", "DB_Close"],
+    ],
+};
+/**
+ * Full unsupervised discovery across all known repos.
+ */
+function runUnsupervisedDiscovery() {
+    const perRepo = {};
+    const allSeqs = [];
+    for (const [repo, seqs] of Object.entries(exports.CROSS_REPO_SEQUENCES)) {
+        const eval_ = evaluateUnsupervisedDiscovery(seqs);
+        perRepo[repo] = eval_;
+        allSeqs.push(...seqs);
+    }
+    const allEval = evaluateUnsupervisedDiscovery(allSeqs);
+    const emergent = Object.values(perRepo).every(e => e.emergent);
+    return {
+        perRepo,
+        allSequences: allEval,
+        emergent,
+        summary: emergent
+            ? "ACQUIRE→USE→RELEASE clusters emerged WITHOUT keyword matching. Software Physics is REAL."
+            : "Structural clustering found some patterns, but not consistently across repos. More data needed.",
+    };
+}
+function printUnsupervisedReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P6.3 Unsupervised Physics Discovery              ║");
+    console.log("║   (NO keywords. NO function names. Pure topology.) ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Emergent Physics: ${report.emergent ? "✅ YES" : "❌ NO"}`);
+    console.log(`Summary: ${report.summary}`);
+    console.log();
+    console.log("─── Per-Repo Discovery ───");
+    console.log("Repo           Seqs  Clusters  StructCov  Emergent");
+    console.log("──────────────────────────────────────────────────");
+    for (const [repo, eval_] of Object.entries(report.perRepo)) {
+        const sc = (eval_.structuralCoverage * 100).toFixed(0).padStart(4);
+        const icon = eval_.emergent ? "✅" : "❌";
+        console.log(`  ${repo.padEnd(12)} ${String(eval_.totalSequences).padStart(4)}  ${String(eval_.clusters.length).padStart(8)}  ${sc}%      ${icon}`);
+    }
+    console.log();
+    console.log("─── Discovered Clusters ───");
+    for (const c of report.allSequences.clusters.slice(0, 10)) {
+        const pattern = c.inferredPattern || "unknown";
+        const closed = c.closedLoopRate > 0.5 ? "closed-loop" : "open";
+        console.log(`  ${c.id}: ${c.sequences.length} seqs, avgLen=${c.avgLength.toFixed(1)}, ${closed}, → ${pattern}`);
+        if (c.sequences.length <= 3) {
+            for (const s of c.sequences) {
+                console.log(`    ${s.join(" → ")}`);
+            }
+        }
+    }
+    console.log();
+}

package/dist/extract-ir-python.js

@@ -1,4 +1,17 @@
 "use strict";
+/**
+ * Python IR Extractor — Bridge to tools/extract_ir.py
+ *
+ * V5: Python IR now matches TypeScript FunctionInfo interface
+ * and feeds directly into the SSG validator and protocol discovery pipeline.
+ *
+ * Protocol annotations via Python decorators:
+ *   @progmune(namespace="auth", pre=["UNAUTHENTICATED"], post=["PASSWORD_VERIFIED"])
+ *   def verify_password(...): ...
+ *
+ * Docstring-based metadata:
+ *   @purpose, @requires, @produces, @tags, @inputs, @outputs
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -34,22 +47,56 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractIRPython = extractIRPython;
+exports.isPythonProject = isPythonProject;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function extractIRPython(projectRoot) {
-    const scriptPath = path.resolve(__dirname, "../tools/extract_ir.py");
-    const cmd = `python3 "${scriptPath}" "${projectRoot}"`;
+    const scriptPath = path.resolve(__dirname, "..", "tools", "extract_ir.py");
+    const irPath = path.resolve(projectRoot, "ir.json");
+    const cmd = `python3 "${scriptPath}" "${projectRoot}" "${irPath}"`;
     try {
         (0, child_process_1.execSync)(cmd, { encoding: "utf-8", stdio: "pipe" });
     }
     catch (e) {
-        console.error("Python IR 提取失败:", e.stderr?.toString() || e.toString());
+        console.error("Python IR extraction failed:", e.stderr?.toString() || String(e));
         return [];
     }
-    const irPath = path.resolve("ir.json");
-    if (fs.existsSync(irPath)) {
-        return JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    if (!fs.existsSync(irPath))
+        return [];
+    const raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
+    if (!Array.isArray(raw))
+        return [];
+    // Map Python IR records to FunctionInfo
+    return raw.map((r) => ({
+        name: r.name || "",
+        params: (r.params || []).map((p) => ({
+            name: p.name || "",
+            type: p.type || "any",
+        })),
+        returnType: r.returnType || "any",
+        file: r.file || "",
+        calls: r.calls || [],
+        exported: r.exported !== false,
+        external: r.external || false,
+        description: r.description || r.purpose || "",
+        purpose: r.purpose || "",
+        tags: r.tags || (r.language ? [r.language] : []),
+        inputs: r.inputs || [],
+        outputs: r.outputs || [],
+        requires: r.requires || "",
+        produces: r.produces || "",
+        useWhen: r.useWhen || "",
+        protocol: r.protocol || undefined,
+    }));
+}
+/** Auto-detect whether a project is Python (looks for .py files). */
+function isPythonProject(projectRoot) {
+    try {
+        const files = fs.readdirSync(projectRoot);
+        return files.some(f => f.endsWith(".py"));
+    }
+    catch {
+        return false;
     }
-    return [];
 }