progmune-runtime 2.1.6 → 3.2.0

package/dist/extract-ir.js

@@ -192,6 +192,150 @@ function deriveOutputs(returnType) {
     const t = returnType.replace(/\[\]$/, "").replace(/<[^>]*>/g, "").split("|")[0].trim();
     return (t === "void" || t === "any") ? [] : [t];
 }
+/** Read tsconfig.json resolving the extends chain via TypeScript's config parser. */
+function readOriginalTsConfig(tsconfigPath) {
+    try {
+        const raw = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+        if (raw.error)
+            return null;
+        const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, path.dirname(tsconfigPath));
+        if (parsed.errors?.length > 0) {
+            // Non-fatal — config may still be usable
+        }
+        const co = parsed.options;
+        // Convert numeric ModuleResolutionKind to string
+        let modRes;
+        if (co.moduleResolution !== undefined && typeof co.moduleResolution === 'number') {
+            modRes = ts.ModuleResolutionKind[co.moduleResolution];
+        }
+        return {
+            paths: (co.paths && Object.keys(co.paths).length > 0) ? co.paths : undefined,
+            baseUrl: co.baseUrl,
+            moduleResolution: modRes?.toLowerCase(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Manual module resolution for bundler/NodeNext projects.
+ * Falls back after ts-morph's built-in resolution fails.
+ */
+function manualResolveModule(moduleSpecifier, sourceFilePath, projectRoot, originalConfig) {
+    if (!moduleSpecifier || !moduleSpecifier.startsWith('.') && !moduleSpecifier.startsWith('@')) {
+        return null; // Not a relative or aliased import — skip
+    }
+    // ── 1. Path alias resolution (bundler) ──
+    if (originalConfig?.paths) {
+        const baseUrlPath = originalConfig.baseUrl
+            ? path.resolve(projectRoot, originalConfig.baseUrl)
+            : projectRoot;
+        for (const [aliasPattern, targets] of Object.entries(originalConfig.paths)) {
+            // Convert TypeScript glob pattern to regex: "@/*" → /^@\/(.*)$/
+            // Handle both glob ("@/*") and bare ("libnpmconfig") aliases
+            const hasWildcard = aliasPattern.includes('*');
+            let wildcard = '';
+            let matched = false;
+            if (hasWildcard) {
+                const aliasRegexSrc = '^' + aliasPattern.replace(/\*/g, '(.*)') + '$';
+                const aliasRegex = new RegExp(aliasRegexSrc);
+                const match = moduleSpecifier.match(aliasRegex);
+                if (!match)
+                    continue;
+                wildcard = match[1] || '';
+                matched = true;
+            }
+            else {
+                // Bare alias: must be an exact match
+                if (moduleSpecifier !== aliasPattern && !moduleSpecifier.startsWith(aliasPattern + '/')) {
+                    continue;
+                }
+                matched = true;
+                // For bare alias with subpath: "libnpmconfig/foo" → wildcard = "/foo"
+                if (moduleSpecifier.startsWith(aliasPattern + '/')) {
+                    wildcard = moduleSpecifier.slice(aliasPattern.length); // "/foo"
+                }
+            }
+            if (!matched)
+                continue;
+            for (const target of targets) {
+                const resolvedRel = hasWildcard ? target.replace(/\*/g, wildcard) : (target + wildcard);
+                const candidateBase = path.resolve(baseUrlPath, resolvedRel);
+                // Try candidate as a file first
+                try {
+                    const st = fs.statSync(candidateBase);
+                    if (st.isFile())
+                        return candidateBase;
+                }
+                catch { }
+                // Try adding .ts / .tsx / .d.ts extensions
+                for (const ext of ['.ts', '.tsx', '.d.ts']) {
+                    try {
+                        const withExt = candidateBase + ext;
+                        const st = fs.statSync(withExt);
+                        if (st.isFile())
+                            return withExt;
+                    }
+                    catch { }
+                }
+                // Try as directory with index file
+                try {
+                    const idxTs = path.join(candidateBase, 'index.ts');
+                    if (fs.statSync(idxTs).isFile())
+                        return idxTs;
+                }
+                catch { }
+                try {
+                    const idxTsx = path.join(candidateBase, 'index.tsx');
+                    if (fs.statSync(idxTsx).isFile())
+                        return idxTsx;
+                }
+                catch { }
+            }
+            break; // First matching alias pattern wins
+        }
+    }
+    // ── 2. NodeNext .js → .ts mapping ──
+    if (moduleSpecifier.startsWith('.')) {
+        const sourceDir = path.dirname(sourceFilePath);
+        // Try the specifier as-is first (extensionless or explicit)
+        for (const suffix of ['', '.ts', '.tsx', '.d.ts']) {
+            try {
+                const candidate = path.resolve(sourceDir, moduleSpecifier + suffix);
+                if (fs.statSync(candidate).isFile())
+                    return candidate;
+            }
+            catch { }
+        }
+        // NodeNext style: "./foo.js" → "./foo.ts"
+        if (moduleSpecifier.endsWith('.js') || moduleSpecifier.endsWith('.jsx')) {
+            const stripped = moduleSpecifier.replace(/\.jsx?$/, '');
+            for (const suffix of ['.ts', '.tsx', '.d.ts']) {
+                try {
+                    const candidate = path.resolve(sourceDir, stripped + suffix);
+                    if (fs.statSync(candidate).isFile())
+                        return candidate;
+                }
+                catch { }
+            }
+        }
+        // Try as directory with index file
+        try {
+            const idxTs = path.resolve(sourceDir, moduleSpecifier, 'index.ts');
+            if (fs.existsSync(idxTs))
+                return idxTs;
+        }
+        catch { }
+        try {
+            const idxTsx = path.resolve(sourceDir, moduleSpecifier, 'index.tsx');
+            if (fs.existsSync(idxTsx))
+                return idxTsx;
+        }
+        catch { }
+    }
+    return null;
+}
 function extractDirectCalls(func) {
     const body = func.getBody();
     if (!body)
@@ -222,13 +366,69 @@ function extractIR(projectRoot) {
 /** Extract both functions and type→file mapping. */
 /** @requires PROJECT_PATH @produces IR_WITH_TYPES */
 /** @requires PROJECT_PATH @produces IR_WITH_TYPES */
-function extractIRWithTypes(projectRoot) {
+function extractIRWithTypes(projectRoot, _visited = new Set()) {
     const absRoot = path.resolve(projectRoot);
+    const tsconfigPath = path.join(absRoot, "tsconfig.json");
+    // Prevent infinite recursion for circular project references
+    if (_visited.has(absRoot)) {
+        return { functions: [], typeMap: {} };
+    }
+    _visited.add(absRoot);
+    // ── P0: Monorepo / project references detection ──
+    let references = [];
+    if (fs.existsSync(tsconfigPath)) {
+        try {
+            const tsconfigRaw = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
+            if (tsconfigRaw.references && Array.isArray(tsconfigRaw.references)) {
+                references = tsconfigRaw.references
+                    .map((ref) => ref.path ? path.resolve(absRoot, ref.path) : null)
+                    .filter((p) => p !== null && fs.existsSync(path.join(p, "tsconfig.json")));
+            }
+        }
+        catch { /* invalid tsconfig JSON */ }
+    }
+    if (references.length > 0) {
+        console.error(`🔧 检测到 monorepo: ${references.length} 个子项目`);
+        const allFunctions = [];
+        const allTypeMap = {};
+        // Only extract from referenced sub-projects — root tsconfig is just a container
+        for (const refDir of references) {
+            const childResult = extractIRWithTypes(refDir, _visited);
+            // Adjust file paths to be relative to the root project
+            for (const f of childResult.functions) {
+                const absolutePath = path.resolve(refDir, f.file);
+                f.file = path.relative(absRoot, absolutePath);
+            }
+            allFunctions.push(...childResult.functions);
+            Object.assign(allTypeMap, childResult.typeMap);
+        }
+        return { functions: allFunctions, typeMap: allTypeMap };
+    }
+    return _extractSingleProject(absRoot, tsconfigPath);
+}
+/** Extract IR from a single project (no references handling). */
+function _extractSingleProject(absRoot, tsconfigPath) {
+    // ── P0: Read original tsconfig (with extends chain) for paths/baseUrl ──
+    const originalTsConfig = fs.existsSync(tsconfigPath)
+        ? readOriginalTsConfig(tsconfigPath)
+        : null;
+    if (originalTsConfig?.paths) {
+        console.error(`🔧 检测到路径别名: ${Object.keys(originalTsConfig.paths).join(', ')}`);
+    }
+    const modRes = (originalTsConfig?.moduleResolution || '').toLowerCase();
+    if (modRes === 'nodenext' || modRes === 'node16') {
+        console.error(`🔧 检测到 ${modRes} — 启用 .js→.ts 映射`);
+    }
     const project = new ts_morph_1.Project({
-        tsConfigFilePath: path.join(absRoot, "tsconfig.json"),
+        tsConfigFilePath: tsconfigPath,
         skipAddingFilesFromTsConfig: false,
+        skipFileDependencyResolution: true, // compatible with NodeNext/ESM tsconfigs
+        compilerOptions: {
+            module: 1, // CommonJS — overrides project tsconfig for extraction
+            moduleResolution: 2, // Classic Node resolution
+        },
     });
-    if (!fs.existsSync(path.join(absRoot, "tsconfig.json"))) {
+    if (!fs.existsSync(tsconfigPath)) {
         project.addSourceFilesAtPaths(path.join(absRoot, "**/*.ts"));
     }
     const funcs = [];
@@ -369,8 +569,23 @@ function extractIRWithTypes(projectRoot) {
                             continue;
                         }
                     }
+                    // ── P0 fallback: manual resolution for bundler aliases & NodeNext .js→.ts ──
+                    const manualPath = manualResolveModule(mod, sf.getFilePath(), absRoot, originalTsConfig);
+                    if (manualPath) {
+                        try {
+                            const manualFile = project.addSourceFileAtPathIfExists(manualPath);
+                            if (manualFile) {
+                                const sig = extractSignatureFromFile(name, manualFile);
+                                if (sig) {
+                                    externalFuncs.set(name, sig);
+                                    continue;
+                                }
+                            }
+                        }
+                        catch { /* manual file may be a directory or invalid */ }
+                    }
                 }
-                catch { }
+                catch { /* IR parse fallback */ }
             }
             // Namespace imports: import * as X from 'mod'
             const nsImport = imp.getNamespaceImport();
@@ -389,17 +604,29 @@ function extractIRWithTypes(projectRoot) {
                                 namespaceImports.set(nsImport.getText(), dtsFile);
                         }
                         else {
-                            // Node.js built-in: try @types/node
-                            const nodeTypesPath = path.join(absRoot, "node_modules/@types/node", mod + ".d.ts");
-                            if (fs.existsSync(nodeTypesPath)) {
-                                const nodeDts = project.addSourceFileAtPathIfExists(nodeTypesPath);
-                                if (nodeDts)
-                                    namespaceImports.set(nsImport.getText(), nodeDts);
+                            // ── P0 fallback: manual resolution for namespace imports ──
+                            const manualPath = manualResolveModule(mod, sf.getFilePath(), absRoot, originalTsConfig);
+                            if (manualPath) {
+                                try {
+                                    const manualFile = project.addSourceFileAtPathIfExists(manualPath);
+                                    if (manualFile)
+                                        namespaceImports.set(nsImport.getText(), manualFile);
+                                }
+                                catch { /* manual file may be a directory */ }
+                            }
+                            else {
+                                // Node.js built-in: try @types/node
+                                const nodeTypesPath = path.join(absRoot, "node_modules/@types/node", mod + ".d.ts");
+                                if (fs.existsSync(nodeTypesPath)) {
+                                    const nodeDts = project.addSourceFileAtPathIfExists(nodeTypesPath);
+                                    if (nodeDts)
+                                        namespaceImports.set(nsImport.getText(), nodeDts);
+                                }
                             }
                         }
                     }
                 }
-                catch { }
+                catch { /* IR parse fallback */ }
             }
         }
     }
@@ -418,7 +645,7 @@ function extractIRWithTypes(projectRoot) {
     // Collect undeclared calls (functions used but not declared and not resolved above)
     const allCalls = new Set();
     for (const f of funcs) {
-        for (const c of f.calls) {
+        for (const c of (f.calls || [])) {
             allCalls.add(c);
         }
     }
@@ -601,6 +828,40 @@ function extractIRWithTypes(projectRoot) {
                     break;
             }
         }
+        // ── P0 fallback: try manual resolution for named-import-style unknown calls ──
+        // Some imports may not have been resolved as named imports in ts-morph
+        // (e.g., when the import declaration itself wasn't parsed correctly)
+        if (!externalFuncs.has(callName) && !knownExternals[callName]) {
+            // Scan all source file imports again with manual resolution
+            for (const sf of project.getSourceFiles()) {
+                if (sf.getFilePath().includes('node_modules'))
+                    continue;
+                for (const imp of sf.getImportDeclarations()) {
+                    const mod = imp.getModuleSpecifierValue();
+                    const manualPath = manualResolveModule(mod, sf.getFilePath(), absRoot, originalTsConfig);
+                    if (!manualPath)
+                        continue;
+                    // Check if this module exports the callName
+                    let manualFile;
+                    try {
+                        manualFile = project.addSourceFileAtPathIfExists(manualPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!manualFile)
+                        continue;
+                    const sig = extractSignatureFromFile(callName, manualFile);
+                    if (sig) {
+                        externalFuncs.set(callName, sig);
+                        dynamicCount++;
+                        break;
+                    }
+                }
+                if (externalFuncs.has(callName))
+                    break;
+            }
+        }
         // Priority: dynamic resolution > knownExternals fallback > any
         const dynamic = externalFuncs.get(callName);
         const fallback = knownExternals[callName];
@@ -670,6 +931,109 @@ function extractIRWithTypes(projectRoot) {
                 _typeMap[_n] = _rp;
         }
     }
+    // ── Post-process: auto-derive missing capability metadata ──
+    // Name-based data-flow inference patterns
+    const PRODUCER_PREFIXES = [
+        [/^(load|get|fetch|read|find|list|query|select)/i, "DATA"],
+        [/^(create|build|generate|make|new)/i, "CREATED"],
+        [/^(validate|verify|check|assert)/i, "VALIDATION_RESULT"],
+        [/^(format|render|emit|stringify)/i, "FORMATTED"],
+        [/^(save|write|persist|store|put)/i, "SAVED"],
+        [/^(count|compute|calculate|measure)/i, "RESULT"],
+        [/^(extract|parse|scan)/i, "EXTRACTED"],
+        [/^(execute|run|invoke|apply)/i, "EXECUTED"],
+        [/^(delete|remove|clear|destroy)/i, "DELETED"],
+    ];
+    const CONSUMER_PREFIXES = [
+        [/^(save|write|persist|store)/i, "DATA"],
+        [/^(validate|verify|check|assert)/i, "DATA"],
+        [/^(format|render|emit|display)/i, "DATA"],
+        [/^(delete|remove|clear)/i, "DATA"],
+        [/^(execute|run|apply)/i, "CONFIG"],
+        [/^(search|query|filter|sort)/i, "DATA"],
+        [/^(merge|combine|concat)/i, "DATA"],
+        [/^(compare|diff|match)/i, "DATA"],
+        [/^(hash|encode|encrypt|sign)/i, "INPUT"],
+    ];
+    for (const f of funcs) {
+        // Strategy 1: @protocol pre_states → @requires, post_states → @produces
+        if (f.protocol) {
+            if ((!f.requires || f.requires.length === 0) && f.protocol.pre_states?.length > 0) {
+                f.requires = f.protocol.pre_states;
+            }
+            if ((!f.produces || f.produces.length === 0) && f.protocol.post_states?.length > 0) {
+                f.produces = f.protocol.post_states;
+            }
+        }
+        // Strategy 2: Derive purpose from function name if missing
+        if (!f.purpose && f.name) {
+            f.purpose = f.name
+                .replace(/([A-Z])/g, " $1")
+                .replace(/_/g, " ")
+                .replace(/\s+/g, " ")
+                .trim()
+                .toLowerCase();
+        }
+        // Strategy 3: Derive tags from file path if missing
+        if (!f.tags || f.tags.length === 0) {
+            const parts = (f.file || "").replace(/\.ts$/, "").replace(/^src\//, "").split("/");
+            f.tags = parts.filter(t => t.length > 2 && t !== "src");
+        }
+        // Strategy 4: Infer requires/produces from function name prefix
+        // Mark as derived so Strategy 5 can skip these (name-derived labels are
+        // too generic for cross-function data-flow inheritance).
+        if (!f.requires || f.requires.length === 0) {
+            for (const [re, label] of CONSUMER_PREFIXES) {
+                if (re.test(f.name)) {
+                    f.requires = [label];
+                    f._requiresDerived = true;
+                    break;
+                }
+            }
+        }
+        if (!f.produces || f.produces.length === 0) {
+            for (const [re, label] of PRODUCER_PREFIXES) {
+                if (re.test(f.name)) {
+                    f.produces = [label];
+                    f._producesDerived = true;
+                    break;
+                }
+            }
+        }
+    }
+    // Strategy 5: Cross-function data-flow — only inherit from callees
+    // with BOTH explicit requires AND produces (true pipeline functions).
+    // Single-hop only. Prevents noise: generateAttemptId→CREATED won't propagate.
+    const nameToFunc = new Map();
+    for (const f of funcs)
+        nameToFunc.set(f.name, f);
+    for (const f of funcs) {
+        if ((f.requires || []).length > 0 && (f.produces || []).length > 0)
+            continue; // already annotated
+        if (!f.calls || f.calls.length === 0)
+            continue;
+        let inherited = 0;
+        const MAX_INHERIT = 2; // cap edges per function
+        for (const calleeName of f.calls) {
+            if (inherited >= MAX_INHERIT)
+                break;
+            const callee = nameToFunc.get(calleeName);
+            if (!callee)
+                continue;
+            // Require BOTH explicit requires AND produces — true pipeline node
+            const hasExplicitR = callee.requires && callee.requires.length > 0 && !callee._requiresDerived;
+            const hasExplicitP = callee.produces && callee.produces.length > 0 && !callee._producesDerived;
+            if (!hasExplicitR || !hasExplicitP)
+                continue;
+            if (!f.requires || f.requires.length === 0) {
+                f.requires = [...new Set(callee.requires)];
+                inherited++;
+            }
+            if (!f.produces || f.produces.length === 0) {
+                f.produces = [...new Set(callee.produces)];
+            }
+        }
+    }
     return { functions: funcs, typeMap: _typeMap };
 }
 // ═══════════════════════════════════════════════════════════════

package/dist/failure-collector.js

@@ -98,7 +98,7 @@ function recordFailure(record) {
             fs.mkdirSync(CORPUS_DIR, { recursive: true });
         fs.writeFileSync(`${CORPUS_DIR}/${id}.json`, JSON.stringify(entry, null, 2), "utf-8");
     }
-    catch { }
+    catch { /* collect best-effort */ }
     return id;
 }
 /** Load all recorded failures. */
@@ -116,7 +116,7 @@ function loadFailures() {
         try {
             failures.push(JSON.parse(fs.readFileSync(`${CORPUS_DIR}/${f}`, "utf-8")));
         }
-        catch { }
+        catch { /* collect best-effort */ }
     }
     return failures.sort((a, b) => b.timestamp - a.timestamp);
 }