progmune-runtime 2.1.1 → 2.1.2

package/dist/emitter.js

@@ -152,13 +152,19 @@ function emitCode(actions, meta) {
         else if (action.kind === "assign" && action.target) {
             declared.add(action.target);
         }
-        // Collect arg value references
+        // Collect arg value references AND empty-default params
         if (action.kind === "call" && action.args) {
             for (const arg of action.args) {
                 const v = typeof arg === "object" ? arg?.value : arg;
                 if (typeof v === "string" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(v) && v !== "") {
                     referenced.add(v);
                 }
+                // Also detect empty defaults: these should become function params
+                const isDefault = v === "" || v === 0 || v === false || v === null
+                    || (Array.isArray(v) && v.length === 0);
+                if (isDefault && typeof arg === "object" && arg.name) {
+                    referenced.add(arg.name);
+                }
             }
         }
     }
@@ -169,10 +175,40 @@ function emitCode(actions, meta) {
         if (action.kind === "call" && action.args) {
             for (const arg of action.args) {
                 const v = typeof arg === "object" ? arg?.value : arg;
+                const n = typeof arg === "object" ? arg?.name : undefined;
                 const t = typeof arg === "object" ? arg?.type : "string";
+                // Variable reference: value matches input name
                 if (typeof v === "string" && inputs.includes(v) && t && t !== "any") {
                     inputTypes.set(v, t);
                 }
+                // Empty default: param name matches input name
+                const isDefault = v === "" || v === 0 || v === false || v === null
+                    || (Array.isArray(v) && v.length === 0);
+                if (isDefault && n && inputs.includes(n)) {
+                    const cleanType = (t || "string").replace(/\[\]$/, "");
+                    if (!inputTypes.has(n))
+                        inputTypes.set(n, cleanType);
+                }
+            }
+        }
+    }
+    // If no inputs detected but functions have params with empty defaults,
+    // create parameters from function signatures
+    if (inputs.length === 0) {
+        for (const action of actions) {
+            if (action.kind === "call" && action.args && action.args.length > 0) {
+                for (const arg of action.args) {
+                    const name = typeof arg === "object" ? arg.name : "param";
+                    const type = typeof arg === "object" ? (arg.type || "string") : "string";
+                    const val = typeof arg === "object" ? arg.value : arg;
+                    // Only add if value is empty default (not a real value)
+                    if (val === "" || val === 0 || val === false || val === null || (Array.isArray(val) && val.length === 0)) {
+                        if (!inputTypes.has(name)) {
+                            inputs.push(name);
+                            inputTypes.set(name, type.replace(/\[\]$/, ""));
+                        }
+                    }
+                }
             }
         }
     }
@@ -192,11 +228,17 @@ function emitCode(actions, meta) {
                 const val = a?.value;
                 if (typeof val === "string" && declared.has(val))
                     return val;
-                // If value looks like a variable name (valid JS identifier), pass it through
                 if (typeof val === "string" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(val) && val !== "") {
                     declared.add(val);
                     return val;
                 }
+                // Empty default value → use function's parameter name (input parameter)
+                const isDefault = val === "" || val === 0 || val === false || val === null
+                    || (Array.isArray(val) && val.length === 0);
+                if (isDefault && a?.name && inputs.includes(a.name)) {
+                    declared.add(a.name);
+                    return a.name;
+                }
                 const paramType = meta?.params?.[i]?.type || "any";
                 if (BASIC_TYPES.has(paramType)) {
                     if (paramType === "string" || paramType === "str")

package/dist/health-utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHealthScore = computeHealthScore;
+exports.formatHealthLevel = formatHealthLevel;
+exports.countSessionLedgers = countSessionLedgers;
+/** Compute overall immune health score from failure and antibody data.
+ * @requires FAILURE_GENOME @produces HEALTH_SCORE
+ * @tags health, score, immune
+ */
+function computeHealthScore(failureGenome, antibodyStats) {
+    const totalFailures = failureGenome?.totalFailures || 0;
+    const totalHits = antibodyStats?.totalHits || 0;
+    const base = 100;
+    const failurePenalty = Math.min(totalFailures * 2, 40);
+    const antibodyBonus = Math.min(totalHits * 3, 20);
+    return Math.max(0, Math.min(100, base - failurePenalty + antibodyBonus));
+}
+/** Format a health score as a status level.
+ * @requires HEALTH_SCORE @produces HEALTH_STATUS
+ * @tags health, format
+ */
+function formatHealthLevel(score) {
+    if (score >= 90)
+        return "Excellent";
+    if (score >= 70)
+        return "Good";
+    if (score >= 50)
+        return "Fair";
+    return "Poor";
+}
+/** Validate a ledger and return pass/fail counts.
+ * @requires SESSION_LIST @produces VALIDATION_COUNTS
+ * @tags ledger, validation, audit
+ */
+function countSessionLedgers(sessions) {
+    const withLedger = sessions.filter((s) => {
+        return s.attempts?.some((a) => a.transitions?.length > 0);
+    }).length;
+    return { total: sessions.length, withLedger };
+}

package/dist/ledger-utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countTotalTransitions = countTotalTransitions;
+exports.formatTransitionCount = formatTransitionCount;
+exports.hasViolations = hasViolations;
+exports.countSessionsWithViolations = countSessionsWithViolations;
+/** Count total transitions across all session ledgers.
+ * @requires SESSION_LIST @produces TRANSITION_COUNT
+ * @tags ledger, count, statistics
+ */
+function countTotalTransitions(sessions) {
+    let count = 0;
+    for (const s of sessions) {
+        for (const a of (s.attempts || [])) {
+            count += (a.transitions || []).length;
+        }
+    }
+    return count;
+}
+/** Format a transition count as a summary string.
+ * @requires TRANSITION_COUNT @produces FORMATTED_COUNT
+ * @tags ledger, format
+ */
+function formatTransitionCount(count) {
+    return `${count} total transitions across all sessions`;
+}
+/** Check if a session has any protocol violations in its attempts.
+ * @requires SESSION_DATA @produces VIOLATION_CHECK
+ * @tags ledger, validation
+ */
+function hasViolations(session) {
+    return (session.attempts || []).some((a) => (a.violations || []).length > 0);
+}
+/** Count sessions that have violations.
+ * @requires SESSION_LIST @produces VIOLATION_COUNT
+ * @tags ledger, validation, statistics
+ */
+function countSessionsWithViolations(sessions) {
+    return sessions.filter(s => hasViolations(s)).length;
+}

package/dist/stdlib.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Progmune Standard Library — general-purpose utilities for external tasks.
+ * Each function has @requires/@produces for Capability Graph integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmail = isValidEmail;
+exports.truncate = truncate;
+exports.camelToSnake = camelToSnake;
+exports.capitalizeWords = capitalizeWords;
+exports.countSubstring = countSubstring;
+exports.removeWhitespace = removeWhitespace;
+exports.mostFrequent = mostFrequent;
+exports.unique = unique;
+exports.chunk = chunk;
+exports.arrayDiff = arrayDiff;
+exports.average = average;
+exports.median = median;
+exports.roundTo = roundTo;
+exports.isPrime = isPrime;
+exports.randomInt = randomInt;
+exports.deepClone = deepClone;
+exports.pick = pick;
+exports.deepMerge = deepMerge;
+exports.hasRequiredFields = hasRequiredFields;
+exports.isPlainObject = isPlainObject;
+exports.parseSemver = parseSemver;
+exports.formatDuration = formatDuration;
+exports.formatFileSize = formatFileSize;
+exports.toQueryString = toQueryString;
+exports.retry = retry;
+exports.debounce = debounce;
+// ── String ──
+/** @requires STRING @produces VALIDATION_RESULT @tags string, email, validation */
+function isValidEmail(str) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
+}
+/** @requires STRING @produces TRUNCATED_STRING @tags string, format */
+function truncate(str, maxLen, ellipsis = "...") {
+    return str.length <= maxLen ? str : str.slice(0, maxLen - ellipsis.length) + ellipsis;
+}
+/** @requires STRING @produces FORMATTED_STRING @tags string, case, format */
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+}
+/** @requires STRING @produces FORMATTED_STRING @tags string, case, format */
+function capitalizeWords(str) {
+    return str.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/** @requires STRING @produces COUNT @tags string, count */
+function countSubstring(str, sub) {
+    if (!sub)
+        return 0;
+    let count = 0, pos = 0;
+    while ((pos = str.indexOf(sub, pos)) !== -1) {
+        count++;
+        pos += sub.length;
+    }
+    return count;
+}
+/** @requires STRING @produces CLEANED_STRING @tags string, format */
+function removeWhitespace(str) {
+    return str.replace(/\s+/g, "");
+}
+// ── Array ──
+/** @requires ARRAY @produces ELEMENT @tags array, statistics */
+function mostFrequent(arr) {
+    if (arr.length === 0)
+        return null;
+    const counts = new Map();
+    for (const item of arr)
+        counts.set(item, (counts.get(item) || 0) + 1);
+    return [...counts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+/** @requires ARRAY @produces ARRAY @tags array, dedupe */
+function unique(arr) { return [...new Set(arr)]; }
+/** @requires ARRAY @produces ARRAY @tags array, chunk */
+function chunk(arr, size) {
+    const result = [];
+    for (let i = 0; i < arr.length; i += size)
+        result.push(arr.slice(i, i + size));
+    return result;
+}
+/** @requires ARRAY @produces ARRAY @tags array, difference */
+function arrayDiff(a, b) {
+    const setB = new Set(b);
+    return a.filter(x => !setB.has(x));
+}
+// ── Math ──
+/** @requires NUMBERS @produces AVERAGE @tags math, statistics */
+function average(nums) {
+    return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+/** @requires NUMBERS @produces MEDIAN @tags math, statistics */
+function median(nums) {
+    if (nums.length === 0)
+        return 0;
+    const sorted = [...nums].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/** @requires NUMBER @produces ROUNDED_NUMBER @tags math, format */
+function roundTo(num, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(num * factor) / factor;
+}
+/** @requires NUMBER @produces PRIME_CHECK @tags math, validation */
+function isPrime(n) {
+    if (n < 2)
+        return false;
+    for (let i = 2; i <= Math.sqrt(n); i++)
+        if (n % i === 0)
+            return false;
+    return true;
+}
+/** @requires NUMBERS @produces RANDOM_INT @tags math, random */
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+// ── Object ──
+/** @requires OBJECT @produces CLONED_OBJECT @tags object, clone */
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+/** @requires OBJECT @produces PICKED_OBJECT @tags object, filter */
+function pick(obj, keys) {
+    const result = {};
+    for (const k of keys)
+        if (k in obj)
+            result[k] = obj[k];
+    return result;
+}
+/** @requires OBJECTS @produces MERGED_OBJECT @tags object, merge */
+function deepMerge(...objects) {
+    return objects.reduce((acc, obj) => {
+        for (const key of Object.keys(obj || {})) {
+            acc[key] = typeof obj[key] === "object" && !Array.isArray(obj[key])
+                ? deepMerge(acc[key] || {}, obj[key]) : obj[key];
+        }
+        return acc;
+    }, {});
+}
+// ── Validation ──
+/** @requires OBJECT @produces VALIDATION_RESULT @tags validation, schema */
+function hasRequiredFields(obj, fields) {
+    return fields.every(f => obj && obj[f] !== undefined && obj[f] !== null);
+}
+/** @requires ANY @produces VALIDATION_RESULT @tags validation, type */
+function isPlainObject(val) {
+    return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+/** @requires STRING @produces PARSED_VERSION @tags validation, semver */
+function parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+        return null;
+    return { major: +match[1], minor: +match[2], patch: +match[3] };
+}
+// ── Formatting ──
+/** @requires NUMBER @produces FORMATTED_STRING @tags format, duration */
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const mins = Math.floor(ms / 60000);
+    const secs = Math.round((ms % 60000) / 1000);
+    return `${mins}m ${secs}s`;
+}
+/** @requires NUMBER @produces FORMATTED_STRING @tags format, file */
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / 1048576).toFixed(1)}MB`;
+}
+/** @requires OBJECT @produces QUERY_STRING @tags web, format */
+function toQueryString(obj) {
+    return Object.entries(obj)
+        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+        .join("&");
+}
+// ── Async ──
+/** @requires FUNCTION @produces RETRY_RESULT @tags async, retry */
+async function retry(fn, maxRetries = 3) {
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (i === maxRetries - 1)
+                throw e;
+        }
+    }
+    throw new Error("unreachable");
+}
+/** @requires FUNCTION @produces DEBOUNCED_FUNCTION @tags async, debounce */
+function debounce(fn, delay) {
+    let timer;
+    return ((...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => fn(...args), delay);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "progmune-runtime",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Progmune Runtime — Program Immunology: Constraint-Guided Program Synthesis Runtime",
   "main": "dist/mcp-server.mjs",
   "bin": {