progmune-runtime 2.1.6 → 3.2.0

package/dist/unsupervised-physics.test.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * P6.3: Unsupervised Physics Discovery Tests
+ *
+ * Verifying: does structural clustering discover Acquire/Release
+ * patterns WITHOUT any keyword matching or function names?
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const unsupervised_physics_1 = require("./experimental/unsupervised-physics");
+(0, vitest_1.describe)("Structural Fingerprint (no function names)", () => {
+    (0, vitest_1.it)("assigns phase 0/1/2 based on position only", () => {
+        const fp0 = (0, unsupervised_physics_1.fingerprint)("fopen", 0, ["fopen", "fread", "fclose"]);
+        (0, vitest_1.expect)(fp0.phase).toBe(0);
+        (0, vitest_1.expect)(fp0.isFirst).toBe(true);
+        (0, vitest_1.expect)(fp0.isLast).toBe(false);
+        const fp1 = (0, unsupervised_physics_1.fingerprint)("fread", 1, ["fopen", "fread", "fclose"]);
+        (0, vitest_1.expect)(fp1.phase).toBe(1);
+        const fp2 = (0, unsupervised_physics_1.fingerprint)("fclose", 2, ["fopen", "fread", "fclose"]);
+        (0, vitest_1.expect)(fp2.phase).toBe(2);
+        (0, vitest_1.expect)(fp2.isLast).toBe(true);
+    });
+    (0, vitest_1.it)("detects closed loops (first and last appear only once)", () => {
+        const fp = (0, unsupervised_physics_1.fingerprint)("fopen", 0, ["fopen", "fread", "fclose"]);
+        // The SEQUENCE [fopen, fread, fclose] is a closed loop
+        // because fopen and fclose each appear once
+        (0, vitest_1.expect)(fp.isClosedLoop).toBe(true);
+    });
+    (0, vitest_1.it)("does NOT consider repeated functions as closed loops", () => {
+        const fp = (0, unsupervised_physics_1.fingerprint)("fread", 0, ["fread", "fread", "fread"]);
+        (0, vitest_1.expect)(fp.isClosedLoop).toBe(false);
+    });
+});
+(0, vitest_1.describe)("Unsupervised Clustering", () => {
+    (0, vitest_1.it)("groups sequences by structure, not by name", () => {
+        // [A,B,C] and [X,Y,Z] should cluster together — same structure (length=3, closed loop)
+        const seqs = [
+            ["fopen", "fread", "fclose"],
+            ["sqlite3_open", "sqlite3_exec", "sqlite3_close"],
+            ["DB_Open", "DB_Get", "DB_Close"],
+            ["PQconnectdb", "PQexec", "PQfinish"],
+            ["ngx_accept", "ngx_process", "ngx_close"],
+        ];
+        const clusters = (0, unsupervised_physics_1.clusterByStructure)(seqs);
+        (0, vitest_1.expect)(clusters.length).toBeGreaterThan(0);
+        // All 5 sequences have length=3 and are closed-loop → same cluster
+        const mainCluster = clusters.find(c => c.avgLength === 3 && c.closedLoopRate === 1);
+        (0, vitest_1.expect)(mainCluster).toBeDefined();
+        (0, vitest_1.expect)(mainCluster.sequences.length).toBe(5);
+    });
+    (0, vitest_1.it)("separates Acquire-Release from Lock-Unlock by length", () => {
+        const seqs = [
+            ["open", "read", "close"], // len=3, closed → Acquire
+            ["connect", "query", "disconnect"], // len=3, closed → Acquire
+            ["lock", "unlock"], // len=2, closed → Lock
+            ["mutex_lock", "mutex_unlock"], // len=2, closed → Lock
+        ];
+        const clusters = (0, unsupervised_physics_1.clusterByStructure)(seqs);
+        (0, vitest_1.expect)(clusters.length).toBeGreaterThanOrEqual(2);
+        const acquireCluster = clusters.find(c => c.avgLength === 3);
+        (0, vitest_1.expect)(acquireCluster).toBeDefined();
+        (0, vitest_1.expect)(acquireCluster.inferredPattern).toBe("RESOURCE_ACQUIRE");
+        const lockCluster = clusters.find(c => c.avgLength === 2);
+        (0, vitest_1.expect)(lockCluster).toBeDefined();
+        (0, vitest_1.expect)(lockCluster.inferredPattern).toBe("LOCK_ACQUIRE");
+    });
+});
+(0, vitest_1.describe)("Unsupervised Discovery Evaluation", () => {
+    (0, vitest_1.it)("discovers physics patterns across all repos", () => {
+        const allSeqs = [];
+        for (const seqs of Object.values(unsupervised_physics_1.CROSS_REPO_SEQUENCES)) {
+            allSeqs.push(...seqs);
+        }
+        const eval_ = (0, unsupervised_physics_1.evaluateUnsupervisedDiscovery)(allSeqs);
+        (0, vitest_1.expect)(eval_.totalSequences).toBeGreaterThanOrEqual(10);
+        (0, vitest_1.expect)(eval_.clusters.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(eval_.sequenceCoverage).toBeGreaterThan(0.5);
+        (0, vitest_1.expect)(eval_.emergent).toBe(true);
+    });
+    (0, vitest_1.it)("each repo independently shows emergent physics", () => {
+        for (const [repo, seqs] of Object.entries(unsupervised_physics_1.CROSS_REPO_SEQUENCES)) {
+            const eval_ = (0, unsupervised_physics_1.evaluateUnsupervisedDiscovery)(seqs);
+            // Each repo has at least one Acquire-Use-Release sequence
+            (0, vitest_1.expect)(eval_.sequenceCoverage).toBeGreaterThan(0);
+        }
+    });
+    (0, vitest_1.it)("full unsupervised report", () => {
+        const report = (0, unsupervised_physics_1.runUnsupervisedDiscovery)();
+        (0, vitest_1.expect)(report.perRepo).toBeDefined();
+        (0, vitest_1.expect)(report.allSequences.clusters.length).toBeGreaterThan(0);
+        // At minimum, the 3-element closed-loop cluster should emerge
+        (0, vitest_1.expect)(report.emergent).toBe(true);
+        (0, unsupervised_physics_1.printUnsupervisedReport)(report);
+    });
+});

package/dist/utils.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for utility functions and pure-logic modules.
+ * Demonstrates the Vitest pattern for Progmune.
+ */
+const vitest_1 = require("vitest");
+const utils_1 = require("./utils");
+// ── jaccardSimilarity ──
+(0, vitest_1.describe)("jaccardSimilarity", () => {
+    (0, vitest_1.it)("returns 1 for identical strings", () => {
+        (0, vitest_1.expect)((0, utils_1.jaccardSimilarity)("hello", "hello")).toBeCloseTo(1, 1);
+    });
+    (0, vitest_1.it)("returns 0 for strings with no common characters", () => {
+        (0, vitest_1.expect)((0, utils_1.jaccardSimilarity)("abc", "xyz")).toBe(0);
+    });
+    (0, vitest_1.it)("returns a value between 0 and 1 for partially overlapping strings", () => {
+        const score = (0, utils_1.jaccardSimilarity)("loginUser", "userLogin");
+        (0, vitest_1.expect)(score).toBeGreaterThan(0);
+        (0, vitest_1.expect)(score).toBeLessThanOrEqual(1);
+    });
+});
+// ── extractKeywords ──
+(0, vitest_1.describe)("extractKeywords", () => {
+    (0, vitest_1.it)("extracts Chinese words", () => {
+        const kw = (0, utils_1.extractKeywords)("验证用户密码并生成JWT令牌");
+        (0, vitest_1.expect)(kw.some(k => k.includes("验证") || k.includes("用户"))).toBe(true);
+    });
+    (0, vitest_1.it)("extracts English words and camelCase tokens", () => {
+        const kw = (0, utils_1.extractKeywords)("authenticate user and generateToken");
+        (0, vitest_1.expect)(kw.some(k => k.toLowerCase().includes("authenticate"))).toBe(true);
+    });
+    (0, vitest_1.it)("returns non-empty array for any input", () => {
+        const kw = (0, utils_1.extractKeywords)("hello world");
+        (0, vitest_1.expect)(kw.length).toBeGreaterThan(0);
+    });
+});

package/dist/validator.js

@@ -35,15 +35,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAction = validateAction;
 exports.validateActionSequence = validateActionSequence;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-function loadIR() {
-    const irPath = path.resolve(__dirname, "../ir.json");
-    if (!fs.existsSync(irPath))
-        return [];
-    const raw = JSON.parse(fs.readFileSync(irPath, "utf-8"));
-    return Array.isArray(raw) ? raw : (raw.functions || []);
-}
+exports.validateActionResult = validateActionResult;
+exports.validateWithGoal = validateWithGoal;
+exports.validateWithRepair = validateWithRepair;
+const ir_utils_1 = require("./ir-utils");
+const runtime_types_1 = require("./runtime-types");
+const failure_corpus_1 = require("./failure-corpus");
 const BUILTIN_WHITELIST = new Set([
     "console.log", "setTimeout", "setInterval", "clearTimeout",
     "JSON.stringify", "JSON.parse", "fetch"
@@ -152,7 +149,7 @@ function checkVariableFlow(actions) {
  */
 /** @requires ACTION @produces VALIDATION_RESULT */
 function validateAction(action, actionIndex) {
-    const functions = loadIR();
+    const functions = (0, ir_utils_1.loadIR)();
     const errors = [];
     const violations = [];
     const idx = actionIndex ?? 0;
@@ -250,5 +247,185 @@ function validateActionSequence(actions) {
             }
         }
     }
+    // ── P0: Trajectory auto-collection — record ALL outcomes ──
+    const actionNames = actions.map(a => a.function || a.kind || "?");
+    const ctx = {
+        nestingDepth: 0,
+        exceptionHandled: false,
+        insideLoop: false,
+        branchCount: 0,
+        asyncContext: false,
+    };
+    if (violations.length > 0) {
+        // Record violation trajectories
+        for (const v of violations) {
+            try {
+                (0, failure_corpus_1.recordTrajectory)({
+                    protocol: v.namespace || "default",
+                    initialState: v.currentStates || [],
+                    finalState: v.requiredStates || [],
+                    trajectory: actionNames,
+                    result: "violation",
+                    violationType: svlToViolationType(v.svl, v.description),
+                    violationDesc: v.description,
+                    failingStepIndex: v.actionIndex,
+                    fixPath: v.fixPath,
+                    context: ctx,
+                    successRate: 0,
+                    intent: v.description,
+                });
+            }
+            catch { /* auto-collection must never crash validation */ }
+        }
+    }
+    else {
+        // Record success trajectory — positive sample for reward learning
+        try {
+            (0, failure_corpus_1.recordSuccess)({
+                protocol: "default",
+                initialState: ["INIT"],
+                finalState: ["COMPLETED"],
+                trajectory: actionNames,
+                context: ctx,
+                source: "planner",
+            });
+        }
+        catch { /* auto-collection must never crash validation */ }
+    }
     return { valid: errors.length === 0, errors, violations };
 }
+/** Map SVL level to ViolationType for auto-collection. */
+function svlToViolationType(svl, desc) {
+    if (svl === 4)
+        return "protocol_violation";
+    if (svl === 1)
+        return "undefined_variable";
+    if (desc.includes("type"))
+        return "wrong_arg_type";
+    if (desc.includes("import") || desc.includes("module"))
+        return "wrong_import_path";
+    if (desc.includes("arg") || desc.includes("parameter"))
+        return "wrong_arg_count";
+    return "other";
+}
+/**
+ * Result-typed variant of validateActionSequence.
+ * Returns Ok<Action[]> on success, Err<ValidationError[]> on failure.
+ * Use this for new code; the legacy {valid, errors} API remains for backward compat.
+ */
+function validateActionResult(actions) {
+    const legacy = validateActionSequence(actions);
+    if (legacy.valid)
+        return (0, runtime_types_1.ok)(actions);
+    const mapped = legacy.errors.map((msg, i) => {
+        const v = legacy.violations[i];
+        return {
+            message: msg,
+            code: v?.violatedConstraint || "unknown",
+            index: v?.actionIndex,
+        };
+    });
+    return (0, runtime_types_1.err)(mapped);
+}
+// ═══════════════════════════════════════════════════════════════
+// P1: Validation with Goal Skeleton annotation
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Validate actions with an associated goal. The goal is annotated asynchronously
+ * (best-effort, non-blocking) and attached to the trajectory record.
+ *
+ * This is the P1 entry point — use this when the user provides a natural language goal.
+ */
+async function validateWithGoal(actions, goalText, params) {
+    // Run validation first (never block on goal annotation)
+    const result = validateActionSequence(actions);
+    // Fire-and-forget: annotate the goal and write trajectory with goal attached
+    const { annotateGoal } = await Promise.resolve().then(() => __importStar(require("./goal-annotator")));
+    const actionNames = actions.map(a => a.function || a.kind || "?");
+    const ctx = {
+        nestingDepth: 0, exceptionHandled: false, insideLoop: false, branchCount: 0, asyncContext: false,
+    };
+    annotateGoal(goalText).then(goalRecord => {
+        const { recordTrajectory } = require("./failure-corpus");
+        if (result.valid) {
+            recordTrajectory({
+                protocol: goalRecord.protocol,
+                initialState: [goalRecord.initial_state],
+                finalState: [goalRecord.target_state],
+                trajectory: actionNames,
+                result: "success",
+                context: ctx,
+                source: "llm",
+                intent: goalText,
+                goal: goalRecord,
+            });
+        }
+        else {
+            for (const v of result.violations) {
+                recordTrajectory({
+                    protocol: goalRecord.protocol,
+                    initialState: [goalRecord.initial_state],
+                    finalState: [goalRecord.target_state],
+                    trajectory: actionNames,
+                    result: "violation",
+                    violationType: svlToViolationType(v.svl, v.description),
+                    violationDesc: v.description,
+                    failingStepIndex: v.actionIndex,
+                    fixPath: v.fixPath,
+                    context: ctx,
+                    intent: goalText,
+                    goal: goalRecord,
+                });
+            }
+        }
+    }).catch(() => { });
+    // Enrich with repair alternatives
+    const enriched = await validateWithRepair(actions, params);
+    return enriched;
+}
+// ═══════════════════════════════════════════════════════════════
+// P2 V3: Validation with Counterfactual Repair
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Validate an action sequence and enrich any violations with
+ * counterfactual repair alternatives (top-3).
+ *
+ * This is the async V3 entry point — use this instead of
+ * validateActionSequence when you want repair suggestions.
+ */
+async function validateWithRepair(actions, params) {
+    // Run the sync validation first
+    const result = validateActionSequence(actions);
+    if (result.valid || result.violations.length === 0)
+        return result;
+    // Enrich each violation with counterfactual alternatives
+    const { suggestAlternatives } = await Promise.resolve().then(() => __importStar(require("./counterfactual-engine")));
+    const enrichedViolations = [...result.violations];
+    for (let i = 0; i < enrichedViolations.length; i++) {
+        const v = enrichedViolations[i];
+        try {
+            const alts = await suggestAlternatives({
+                violation: v,
+                protocol: params?.protocol || v.namespace || "default",
+                currentState: v.currentStates || [],
+                targetState: params?.targetState || v.requiredStates || ["COMPLETED"],
+                rules: params?.rules || new Map(),
+            });
+            enrichedViolations[i] = {
+                ...v,
+                repairAlternatives: alts.map(a => ({
+                    rank: a.rank,
+                    description: a.description,
+                    fixPath: a.fixPath,
+                    source: a.source,
+                    score: a.score,
+                    historicalSuccessRate: a.historicalSuccessRate,
+                })),
+            };
+        }
+        catch {
+            // repair suggestion failure must never invalidate the base validation
+        }
+    }
+    return { valid: false, errors: result.errors, violations: enrichedViolations };
+}