progmune-runtime 2.1.6 → 3.2.0

package/dist/flywheel-batch.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * P3: Batch Flywheel Runner
+ *
+ * Scans all benchmark repos with sequence files, auto-generates proposals,
+ * and produces a Flywheel Health Dashboard with operational metrics.
+ *
+ * Usage:
+ *   npx ts-node --transpile-only src/flywheel-batch.ts
+ *   npx ts-node --transpile-only src/flywheel-batch.ts --auto-accept
+ *   npx ts-node --transpile-only src/flywheel-batch.ts --repos curl,libssh
+ */
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ═══════════════════════════════════════════════════════════════
+// Repo Scanner
+// ═══════════════════════════════════════════════════════════════
+const BENCHMARKS_DIR = path.resolve(process.cwd(), "benchmarks");
+const PROPOSALS_DIR = path.resolve(process.cwd(), ".progmune_corpus", "flywheel");
+function scanRepo(repoName, autoAccept = false) {
+    const seqFile = path.join(BENCHMARKS_DIR, `${repoName}-sequences.json`);
+    if (!fs.existsSync(seqFile)) {
+        // Try alternate names
+        const altFile = path.join(BENCHMARKS_DIR, `${repoName}-manual-sequences.json`);
+        if (!fs.existsSync(altFile)) {
+            return { repo: repoName, status: "no_sequences", proposals: 0, accepted: 0, rejected: 0, topMatches: [] };
+        }
+    }
+    try {
+        // Dynamically invoke the flywheel scanner
+        const { scanRepo: flywheelScan } = require("./knowledge-flywheel");
+        // The scanRepo function expects a path like "benchmarks/curl"
+        const repoPath = path.join("benchmarks", repoName);
+        let proposals;
+        try {
+            proposals = flywheelScan(repoPath);
+        }
+        catch (e) {
+            return {
+                repo: repoName,
+                status: "error",
+                error: e.message || String(e),
+                proposals: 0, accepted: 0, rejected: 0,
+                topMatches: [],
+            };
+        }
+        let accepted = 0;
+        let rejected = 0;
+        if (autoAccept && proposals.length > 0) {
+            try {
+                const { acceptProposal, getProposal } = require("./knowledge-flywheel");
+                for (const p of proposals) {
+                    if (p.suggestion !== "insufficient") {
+                        try {
+                            acceptProposal(p.id, { autoApproved: true });
+                            accepted++;
+                        }
+                        catch {
+                            // Already accepted or error
+                        }
+                    }
+                    else {
+                        rejected++;
+                    }
+                }
+            }
+            catch {
+                // Accept function might not exist or fail — proposals are still pending
+            }
+        }
+        const topMatches = proposals
+            .sort((a, b) => b.evidenceCount - a.evidenceCount)
+            .slice(0, 3)
+            .map((p) => ({ unit: p.unitName, count: p.evidenceCount }));
+        return {
+            repo: repoName,
+            status: "scanned",
+            proposals: proposals.length,
+            accepted,
+            rejected,
+            topMatches,
+        };
+    }
+    catch (e) {
+        return {
+            repo: repoName,
+            status: "error",
+            error: e.message || String(e),
+            proposals: 0, accepted: 0, rejected: 0,
+            topMatches: [],
+        };
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+// Dashboard Generator
+// ═══════════════════════════════════════════════════════════════
+function loadFlywheelState() {
+    let totalProposals = 0;
+    let accepted = 0;
+    let rejected = 0;
+    let pending = 0;
+    if (fs.existsSync(PROPOSALS_DIR)) {
+        const files = fs.readdirSync(PROPOSALS_DIR).filter(f => f.endsWith(".json"));
+        totalProposals = files.length;
+        for (const file of files) {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(PROPOSALS_DIR, file), "utf-8"));
+                if (data.status === "accepted")
+                    accepted++;
+                else if (data.status === "rejected")
+                    rejected++;
+                else
+                    pending++;
+            }
+            catch { /* skip */ }
+        }
+    }
+    return { totalProposals, accepted, rejected, pending };
+}
+function generateDashboard(results) {
+    const scanned = results.filter(r => r.status === "scanned");
+    const state = loadFlywheelState();
+    const totalProposals = results.reduce((s, r) => s + r.proposals, 0);
+    const reposWithProposals = results.filter(r => r.proposals > 0).length;
+    const knowledgeVelocity = scanned.length > 0
+        ? totalProposals / scanned.length
+        : 0;
+    const totalConfidenceGained = state.accepted * 3 + state.pending * 1.5;
+    let assessment = "IDLE";
+    if (scanned.length >= 3 && state.accepted >= 2) {
+        assessment = "FLYWHEEL SPINNING — knowledge growing";
+    }
+    else if (scanned.length >= 1 && state.pending >= 1) {
+        assessment = "BOOTSTRAPPING — proposals pending review";
+    }
+    else if (scanned.length === 0) {
+        assessment = "STALLED — no repos with sequences";
+    }
+    else {
+        assessment = "STARTING — scan complete, awaiting proposals";
+    }
+    const recommendations = [];
+    if (state.pending > 3) {
+        recommendations.push(`${state.pending} proposals pending — review and accept high-confidence ones`);
+    }
+    if (knowledgeVelocity < 0.5) {
+        recommendations.push("Knowledge velocity low — need more repos with high match rates");
+    }
+    if (state.accepted === 0 && state.pending > 0) {
+        recommendations.push("No proposals accepted yet — start reviewing to activate flywheel");
+    }
+    if (state.accepted > 0) {
+        recommendations.push("Flywheel active — continue scanning new repos to reinforce accepted knowledge");
+    }
+    return {
+        generated: new Date().toISOString(),
+        totalReposScanned: scanned.length,
+        reposWithProposals,
+        totalProposals,
+        acceptedProposals: state.accepted,
+        rejectedProposals: state.rejected,
+        pendingProposals: state.pending,
+        knowledgeVelocity: Math.round(knowledgeVelocity * 100) / 100,
+        totalConfidenceGained: Math.round(totalConfidenceGained),
+        byRepo: results,
+        assessment,
+        recommendations,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Formatting
+// ═══════════════════════════════════════════════════════════════
+function formatDashboard(d) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════╗");
+    lines.push("║        Knowledge Flywheel Health Dashboard                   ║");
+    lines.push("╠══════════════════════════════════════════════════════════════╣");
+    lines.push(`║  Generated: ${d.generated}  ║`);
+    lines.push("╚══════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    // Summary metrics
+    lines.push("── Flywheel Metrics ──");
+    lines.push(`  Repos scanned:      ${d.totalReposScanned}`);
+    lines.push(`  Repos with proposals: ${d.reposWithProposals}`);
+    lines.push(`  Total proposals:    ${d.totalProposals}`);
+    lines.push(`  Accepted:           ${d.acceptedProposals} ★`);
+    lines.push(`  Pending:            ${d.pendingProposals}`);
+    lines.push(`  Rejected:           ${d.rejectedProposals}`);
+    lines.push(`  Knowledge velocity: ${d.knowledgeVelocity} proposals/scan`);
+    lines.push(`  Confidence gained:  +${d.totalConfidenceGained}%`);
+    lines.push(`  Assessment:         ${d.assessment}`);
+    lines.push("");
+    // Per-repo table
+    lines.push("── Per-Repo Scan Results ──");
+    for (const repo of d.byRepo) {
+        if (repo.status === "no_sequences") {
+            lines.push(`  ${repo.repo}: ⏭️ no sequences`);
+        }
+        else if (repo.status === "error") {
+            lines.push(`  ${repo.repo}: ❌ ${repo.error}`);
+        }
+        else {
+            const icon = repo.proposals > 0 ? "📊" : "✓";
+            lines.push(`  ${icon} ${repo.repo}: ${repo.proposals} proposals`);
+            if (repo.topMatches.length > 0) {
+                const matches = repo.topMatches.map(m => `${m.unit}(${m.count})`).join(", ");
+                lines.push(`     Top matches: ${matches}`);
+            }
+        }
+    }
+    lines.push("");
+    lines.push("── Recommendations ──");
+    for (const r of d.recommendations) {
+        lines.push(`  • ${r}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// ═══════════════════════════════════════════════════════════════
+// Save
+// ═══════════════════════════════════════════════════════════════
+function saveDashboard(dashboard) {
+    const metricsPath = path.resolve(process.cwd(), ".progmune_corpus", "flywheel-metrics.json");
+    fs.writeFileSync(metricsPath, JSON.stringify(dashboard, null, 2));
+    console.log(`Dashboard saved to ${metricsPath}`);
+}
+// ═══════════════════════════════════════════════════════════════
+// Main
+// ═══════════════════════════════════════════════════════════════
+function main() {
+    const args = process.argv.slice(2);
+    const autoAccept = args.includes("--auto-accept");
+    const repoArg = args.find(a => a.startsWith("--repos="));
+    // Find all repos with sequence files
+    const allRepos = [];
+    if (fs.existsSync(BENCHMARKS_DIR)) {
+        const files = fs.readdirSync(BENCHMARKS_DIR);
+        const seqRepos = new Set();
+        for (const file of files) {
+            const match = file.match(/^(.+)-sequences\.json$/);
+            if (match)
+                seqRepos.add(match[1]);
+        }
+        allRepos.push(...seqRepos);
+    }
+    const repoNames = repoArg
+        ? repoArg.replace("--repos=", "").split(",")
+        : allRepos;
+    console.log(`Scanning ${repoNames.length} repos...`);
+    if (autoAccept)
+        console.log(`  (auto-accepting proposals with sufficient evidence)`);
+    const results = repoNames.map(name => scanRepo(name, autoAccept));
+    const dashboard = generateDashboard(results);
+    console.log(formatDashboard(dashboard));
+    saveDashboard(dashboard);
+}
+main();

package/dist/frameworks/express-cli.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env npx ts-node
+"use strict";
+/**
+ * Express Framework Adapter CLI
+ *
+ * Usage:
+ *   npm run express <path>              Analyze an Express project
+ *   npm run express <path> -- --json    JSON output
+ *   npm run express <path> -- --help    Show help
+ *
+ * Examples:
+ *   npm run express src/server.ts
+ *   npm run express .
+ *   npm run express ~/my-express-app
+ */
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const express_detector_1 = require("./express-detector");
+const args = process.argv.slice(2);
+// ── Help ──
+if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    console.log(`
+╔══════════════════════════════════════════════════════════╗
+║        Progmune Express Framework Adapter               ║
+║        Protocol Detection for Express.js                 ║
+╚══════════════════════════════════════════════════════════╝
+
+Usage:
+  npm run express <path> [options]
+
+Arguments:
+  <path>           File or directory to analyze
+                   (auto-detects Express .ts/.js files)
+
+Options:
+  --json           Output as JSON
+  --summary        Show summary only (no per-file details)
+  --help, -h       Show this help
+
+Examples:
+  npm run express src/server.ts
+  npm run express .
+  npm run express ~/my-express-app -- --json
+  npm run express . -- --summary
+`);
+    process.exit(0);
+}
+// ── Parse options ──
+const jsonOutput = args.includes("--json");
+const summaryOnly = args.includes("--summary");
+const targetPath = args.filter(a => !a.startsWith("--"))[0];
+if (!targetPath) {
+    console.error("Error: path required. Use --help for usage.");
+    process.exit(1);
+}
+const resolvedPath = path.resolve(targetPath);
+// ── Helpers ──
+function findTsFiles(dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fp = path.join(dir, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+            files.push(...findTsFiles(fp));
+        }
+        else if (/\.(ts|js|mjs)$/.test(entry.name) && !/\.test\./.test(entry.name)) {
+            files.push(fp);
+        }
+    }
+    return files;
+}
+// ── Main ──
+async function main() {
+    if (!fs.existsSync(resolvedPath)) {
+        console.error(`Error: path not found: ${resolvedPath}`);
+        process.exit(1);
+    }
+    const stat = fs.statSync(resolvedPath);
+    const isDirectory = stat.isDirectory();
+    let result;
+    if (isDirectory) {
+        const tsFiles = findTsFiles(resolvedPath);
+        const fileResults = [];
+        for (const fp of tsFiles) {
+            const analysis = (0, express_detector_1.analyzeExpressFile)(fp);
+            if (analysis && analysis.hasExpress) {
+                fileResults.push({ file: fp, analysis });
+            }
+        }
+        result = {
+            files: tsFiles.length,
+            expressApps: fileResults.length,
+            totalRoutes: fileResults.reduce((sum, r) => sum + r.analysis.routes.length, 0),
+            issues: fileResults.flatMap(r => r.analysis.issues.map(i => ({ ...i, route: i.route ? `[${path.basename(r.file)}] ${i.route}` : `[${path.basename(r.file)}]` }))),
+            fileResults,
+        };
+    }
+    else {
+        const analysis = (0, express_detector_1.analyzeExpressFile)(resolvedPath);
+        if (!analysis || !analysis.hasExpress) {
+            console.log(`\n${path.basename(resolvedPath)}: Not an Express app (no express import found).\n`);
+            process.exit(0);
+        }
+        result = {
+            files: 1,
+            expressApps: 1,
+            totalRoutes: analysis.routes.length,
+            issues: analysis.issues,
+            fileResults: [{ file: resolvedPath, analysis }],
+        };
+    }
+    // ── JSON output ──
+    if (jsonOutput) {
+        const output = {
+            target: resolvedPath,
+            scannedFiles: result.files,
+            expressApps: result.expressApps,
+            totalRoutes: result.totalRoutes,
+            totalIssues: result.issues.length,
+            bySeverity: {
+                critical: result.issues.filter(i => i.severity === "critical").length,
+                high: result.issues.filter(i => i.severity === "high").length,
+                medium: result.issues.filter(i => i.severity === "medium").length,
+                low: result.issues.filter(i => i.severity === "low").length,
+            },
+            decision: result.issues.some(i => i.severity === "critical") ? "BLOCKED"
+                : result.issues.some(i => i.severity === "high") ? "NEEDS_REVIEW"
+                    : "APPROVED",
+            issues: result.issues.map(i => ({
+                severity: i.severity,
+                rule: i.rule,
+                message: i.message,
+                route: i.route ?? null,
+                line: i.line,
+                fix: i.fix,
+            })),
+        };
+        console.log(JSON.stringify(output, null, 2));
+        process.exit(result.issues.some(i => i.severity === "critical") ? 1 : 0);
+    }
+    // ── Terminal output ──
+    console.log("\n╔══════════════════════════════════════════════════════════╗");
+    console.log("║   Progmune Express Framework Adapter                   ║");
+    console.log("╚══════════════════════════════════════════════════════════╝\n");
+    console.log(`  Target:  ${resolvedPath}`);
+    console.log(`  Files:   ${result.files} scanned`);
+    console.log(`  Apps:    ${result.expressApps} Express app(s) found`);
+    if (result.expressApps === 0) {
+        console.log("\n  No Express apps found in this directory.\n");
+        process.exit(0);
+    }
+    console.log(`  Routes:  ${result.totalRoutes}`);
+    console.log(`  Issues:  ${result.issues.length}\n`);
+    // Severity summary bar
+    const crit = result.issues.filter(i => i.severity === "critical").length;
+    const high = result.issues.filter(i => i.severity === "high").length;
+    const med = result.issues.filter(i => i.severity === "medium").length;
+    const low = result.issues.filter(i => i.severity === "low").length;
+    const bar = [
+        crit > 0 ? `🔴 ${crit} critical` : "",
+        high > 0 ? `🟠 ${high} high` : "",
+        med > 0 ? `🟡 ${med} medium` : "",
+        low > 0 ? `🔵 ${low} low` : "",
+    ].filter(Boolean).join("  ");
+    if (bar) {
+        console.log(`  ${bar}\n`);
+    }
+    // Decision
+    const decision = crit > 0 ? "❌ BLOCKED" : high > 0 ? "⚠️  NEEDS_REVIEW" : "✅ APPROVED";
+    console.log(`  Decision: ${decision}\n`);
+    // Per-file details
+    if (!summaryOnly && result.fileResults && result.fileResults.length > 0) {
+        for (const { file, analysis } of result.fileResults) {
+            if (!analysis)
+                continue;
+            console.log(`── ${path.basename(file)} ──`);
+            console.log((0, express_detector_1.formatExpressReport)(analysis));
+            console.log("");
+        }
+    }
+    // Summary table
+    console.log("── Issues ──");
+    if (result.issues.length === 0) {
+        console.log("  ✅ No Express security issues detected.\n");
+    }
+    else {
+        for (const issue of result.issues) {
+            const emoji = issue.severity === "critical" ? "🔴" : issue.severity === "high" ? "🟠" : issue.severity === "medium" ? "🟡" : "🔵";
+            console.log(`  ${emoji} [${issue.rule}]`);
+            console.log(`     ${issue.message}`);
+            if (issue.route)
+                console.log(`     Route: ${issue.route} (line ${issue.line})`);
+            console.log(`     Fix: ${issue.fix}`);
+            console.log("");
+        }
+    }
+    // ── Exit code for CI ──
+    process.exit(crit > 0 ? 1 : 0);
+}
+main().catch(err => {
+    console.error("Fatal:", err.message);
+    process.exit(2);
+});