kodingo-cli 1.0.38 → 1.1.1

package/dist/utils/ast-parser.js

@@ -63,9 +63,85 @@ function computeFingerprint(body) {
         .trim();
     return (0, crypto_1.createHash)("sha256").update(normalised).digest("hex").slice(0, 16);
 }
+// ── Lightweight call extraction for non-TS languages (heuristic, Tier 2) ─────
+/** Regex-based call-site extraction: matches `identifier(` patterns. Not scope-resolved. */
+function extractCallNamesRegex(body) {
+    const calls = new Set();
+    const pattern = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+    let match;
+    while ((match = pattern.exec(body)) !== null) {
+        calls.add(match[1]);
+    }
+    return Array.from(calls);
+}
 // ── TypeScript / JavaScript parser ───────────────────────────────────────────
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { parse: tsParse } = require("@typescript-eslint/typescript-estree");
+// ── Import extraction ────────────────────────────────────────────────────────
+function extractImports(ast) {
+    const imports = [];
+    const body = ast.body ?? [];
+    for (const node of body) {
+        if (node.type !== "ImportDeclaration" || !node.source?.value)
+            continue;
+        const source = node.source.value;
+        for (const spec of node.specifiers ?? []) {
+            if (spec.type === "ImportDefaultSpecifier" && spec.local?.name) {
+                imports.push({ imported: spec.local.name, source, isDefault: true });
+            }
+            else if (spec.type === "ImportSpecifier" && spec.local?.name) {
+                imports.push({ imported: spec.local.name, source, isDefault: false });
+            }
+            else if (spec.type === "ImportNamespaceSpecifier" && spec.local?.name) {
+                imports.push({ imported: spec.local.name, source, isDefault: false });
+            }
+        }
+    }
+    return imports;
+}
+// ── Call-site extraction ──────────────────────────────────────────────────────
+/** Walks a symbol's body subtree and collects callee identifier names. Heuristic — not scope-resolved. */
+function extractCallNames(node, acc = new Set()) {
+    function walk(n) {
+        if (!n || typeof n !== "object")
+            return;
+        if (n.type === "CallExpression") {
+            const callee = n.callee;
+            if (callee?.type === "Identifier" && callee.name) {
+                acc.add(callee.name);
+            }
+            else if (callee?.type === "MemberExpression" && callee.property?.name) {
+                acc.add(callee.property.name);
+            }
+            // Also capture bare identifier ARGUMENTS passed to this call — e.g.
+            // app.addHook("preHandler", authMiddleware) references authMiddleware
+            // without ever calling it directly. Without this, security checks that
+            // look for "does this function reference an auth check" would miss the
+            // single most common Fastify/Express middleware-registration pattern.
+            if (Array.isArray(n.arguments)) {
+                for (const arg of n.arguments) {
+                    if (arg?.type === "Identifier" && arg.name) {
+                        acc.add(arg.name);
+                    }
+                }
+            }
+        }
+        for (const key of Object.keys(n)) {
+            if (key === "parent")
+                continue;
+            const child = n[key];
+            if (Array.isArray(child)) {
+                for (const c of child)
+                    walk(c);
+            }
+            else if (child && typeof child === "object" && child.type) {
+                walk(child);
+            }
+        }
+    }
+    walk(node);
+    return Array.from(acc);
+}
 async function parseTypeScript(filePath, source) {
     try {
         const parse = tsParse;
@@ -79,6 +155,7 @@ async function parseTypeScript(filePath, source) {
         });
         const symbols = [];
         const lines = source.split("\n");
+        const fileImports = extractImports(ast);
         function getBody(start, end) {
             return source.slice(start, end);
         }
@@ -95,6 +172,8 @@ async function parseTypeScript(filePath, source) {
                     endLine: node.loc.end.line,
                     body,
                     fingerprint: computeFingerprint(body),
+                    calls: extractCallNames(node.body),
+                    imports: fileImports,
                 });
             }
             if ((node.type === "VariableDeclarator") &&
@@ -110,6 +189,8 @@ async function parseTypeScript(filePath, source) {
                     endLine: node.loc.end.line,
                     body,
                     fingerprint: computeFingerprint(body),
+                    calls: extractCallNames(node.init.body),
+                    imports: fileImports,
                 });
             }
             if (node.type === "ClassDeclaration" ||
@@ -125,6 +206,8 @@ async function parseTypeScript(filePath, source) {
                         endLine: node.loc.end.line,
                         body,
                         fingerprint: computeFingerprint(body),
+                        calls: extractCallNames(node.body),
+                        imports: fileImports,
                     });
                     // Visit methods inside the class
                     if (node.body?.body) {
@@ -141,6 +224,8 @@ async function parseTypeScript(filePath, source) {
                                     endLine: member.loc.end.line,
                                     body: mBody,
                                     fingerprint: computeFingerprint(mBody),
+                                    calls: extractCallNames(member.value?.body),
+                                    imports: fileImports,
                                 });
                             }
                         }
@@ -213,6 +298,8 @@ function parseStructural(filePath, source, patterns) {
                 endLine,
                 body,
                 fingerprint: computeFingerprint(body),
+                calls: extractCallNamesRegex(body),
+                imports: [],
             });
             break;
         }
@@ -256,6 +343,8 @@ function parsePython(filePath, source) {
             endLine,
             body,
             fingerprint: computeFingerprint(body),
+            calls: extractCallNamesRegex(body),
+            imports: [],
         });
     }
     return symbols;
@@ -283,6 +372,7 @@ const KOTLIN_PATTERNS = [
     /^(?:fun|override\s+fun|suspend\s+fun|private\s+fun|public\s+fun)\s+(\w+)/,
     /^(?:class|data class|object|interface)\s+(\w+)/,
 ];
+const TREE_SITTER_EXTENSIONS = new Set([".py", ".go", ".rs", ".java", ".kt", ".rb", ".php", ".c", ".cpp"]);
 async function parseFile(filePath, source) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
@@ -293,6 +383,21 @@ async function parseFile(filePath, source) {
         case ".mjs":
         case ".cjs":
             return parseTypeScript(filePath, source);
+        default:
+            break;
+    }
+    if (TREE_SITTER_EXTENSIONS.has(ext)) {
+        try {
+            const { parseWithTreeSitter } = require("./tree-sitter-parser");
+            const result = await parseWithTreeSitter(filePath, source);
+            if (result.length > 0)
+                return result;
+        }
+        catch {
+            // fall through to legacy heuristic parsers below
+        }
+    }
+    switch (ext) {
         case ".py":
             return parsePython(filePath, source);
         case ".go":

package/dist/utils/code-pattern-scanner.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * code-pattern-scanner.ts
+ *
+ * Layer 1 of Kortex Security's code analysis: deterministic pattern detection
+ * over function bodies already extracted by ast-parser.ts. Zero LLM cost,
+ * runs on every scan. Findings here feed Layer 2 (LLM-grounded severity
+ * judgment using graph context) for anything worth a closer look.
+ *
+ * These are heuristic pattern matches, not proof of a vulnerability — that's
+ * exactly what Layer 2 exists to adjudicate. A match here means "worth a
+ * human or an LLM looking at this," not "this is definitely exploitable."
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanSymbolForPatterns = scanSymbolForPatterns;
+exports.scanAllSymbolsForPatterns = scanAllSymbolsForPatterns;
+const MAX_SNIPPET_LENGTH = 200;
+function extractSnippet(body, matchIndex) {
+    // Grab the line containing the match, plus a little context
+    const before = body.slice(0, matchIndex);
+    const lineStart = before.lastIndexOf("\n") + 1;
+    const lineEndRel = body.slice(matchIndex).indexOf("\n");
+    const lineEnd = lineEndRel === -1 ? body.length : matchIndex + lineEndRel;
+    const snippet = body.slice(lineStart, lineEnd).trim();
+    return snippet.length > MAX_SNIPPET_LENGTH ? snippet.slice(0, MAX_SNIPPET_LENGTH) + "..." : snippet;
+}
+const RULES = [
+    // ── SQL injection — string concatenation/interpolation built directly into
+    // a query call, instead of a parameterized placeholder ────────────────────
+    {
+        type: "sql_injection",
+        severity: "critical",
+        regex: /\b(query|execute|exec)\s*\(\s*[`'"][^`'"]*\$\{[^}]+\}[^`'"]*[`'"]/,
+        description: "Query string built with template literal interpolation instead of parameterized placeholders — classic SQL injection pattern.",
+    },
+    {
+        type: "sql_injection",
+        severity: "critical",
+        regex: /\b(query|execute|exec)\s*\(\s*[`'"][^`'"]*['"]?\s*\+\s*\w+/,
+        description: "Query string built with string concatenation instead of parameterized placeholders.",
+    },
+    // ── Command injection ──────────────────────────────────────────────────────
+    {
+        type: "command_injection",
+        severity: "critical",
+        regex: /\b(exec|execSync|spawn)\s*\(\s*[`'"][^`'"]*\$\{[^}]+\}/,
+        description: "Shell command built with interpolated variables — potential command injection if the variable is user-controlled.",
+    },
+    {
+        type: "command_injection",
+        severity: "critical",
+        regex: /\bos\.system\s*\(\s*.*%|\.system\s*\(\s*f['"]/, // Python os.system with % formatting or f-string
+        description: "Shell command built with string formatting — potential command injection.",
+        languages: ["python"],
+    },
+    {
+        type: "command_injection",
+        severity: "high",
+        regex: /\beval\s*\(/,
+        description: "Use of eval() — executes arbitrary code from its input. Almost always avoidable.",
+    },
+    // ── Hardcoded secrets ──────────────────────────────────────────────────────
+    {
+        type: "hardcoded_secret",
+        severity: "high",
+        regex: /\b(api[_-]?key|secret[_-]?key|password|passwd|access[_-]?token|private[_-]?key)\s*[:=]\s*['"][A-Za-z0-9_\-\/+=]{12,}['"]/i,
+        description: "Possible hardcoded credential or secret assigned directly in code, rather than loaded from environment/config.",
+    },
+    // ── Insecure crypto ─────────────────────────────────────────────────────────
+    {
+        type: "insecure_crypto",
+        severity: "moderate",
+        regex: /\bcreateHash\s*\(\s*['"](md5|sha1)['"]\)/i,
+        description: "MD5/SHA1 used for hashing — cryptographically broken for security-sensitive use (passwords, tokens, signatures).",
+    },
+    {
+        type: "insecure_crypto",
+        severity: "high",
+        regex: /\bMath\.random\s*\(\s*\)/,
+        description: "Math.random() used — not cryptographically secure. If this feeds a token, session ID, or password reset code, it's predictable.",
+    },
+    // ── Path traversal ──────────────────────────────────────────────────────────
+    {
+        type: "path_traversal",
+        severity: "high",
+        regex: /\b(readFile|readFileSync|writeFile|writeFileSync|createReadStream|createWriteStream)\s*\(\s*[^)]*\+\s*\w+/,
+        description: "File path built via concatenation with a variable — potential path traversal if that variable is user-controlled.",
+    },
+    // ── SSRF ──────────────────────────────────────────────────────────────────
+    {
+        type: "ssrf",
+        severity: "high",
+        regex: /\b(fetch|axios\.get|axios\.post|request)\s*\(\s*[^)]*\+\s*\w+/,
+        description: "Outbound HTTP request built via concatenation with a variable — potential SSRF if that variable is user-controlled.",
+    },
+];
+/**
+ * Scans a single symbol's body against all pattern rules. Returns every match —
+ * a symbol can trigger multiple findings if it has multiple distinct issues.
+ */
+function scanSymbolForPatterns(symbol, language) {
+    const findings = [];
+    for (const rule of RULES) {
+        if (rule.languages && !rule.languages.includes(language))
+            continue;
+        const match = symbol.body.match(rule.regex);
+        if (match && match.index !== undefined) {
+            findings.push({
+                patternType: rule.type,
+                symbol: symbol.name,
+                file: symbol.file,
+                startLine: symbol.startLine,
+                severity: rule.severity,
+                snippet: extractSnippet(symbol.body, match.index),
+                description: rule.description,
+            });
+        }
+    }
+    return findings;
+}
+/** Scans every symbol in a repo (already-parsed) for code patterns. */
+function scanAllSymbolsForPatterns(symbols) {
+    const findings = [];
+    for (const symbol of symbols) {
+        findings.push(...scanSymbolForPatterns(symbol, symbol.language ?? "unknown"));
+    }
+    return findings;
+}

package/dist/utils/context-assembler.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * context-assembler.ts
+ *
+ * Given a target symbol's fingerprint and the repo's structural graph,
+ * assembles a bounded 1-hop neighborhood: what it calls, what calls it,
+ * and its imports. This is the context sent to /infer/contextual instead
+ * of reasoning about a function in total isolation.
+ *
+ * Token budget is enforced by truncating the lowest-confidence neighbors
+ * first — never sends unbounded context.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleContext = assembleContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DEFAULT_TOKEN_BUDGET = 3000;
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+const MAX_SNIPPET_CHARS = 500; // per-neighbor cap before budget truncation
+function readSnippet(repoRoot, file, startLine, endLine) {
+    try {
+        const absPath = path_1.default.isAbsolute(file) ? file : path_1.default.join(repoRoot, file);
+        const source = fs_1.default.readFileSync(absPath, "utf-8");
+        const lines = source.split("\n");
+        const snippet = lines.slice(Math.max(0, startLine - 1), endLine).join("\n");
+        return snippet.length > MAX_SNIPPET_CHARS ? snippet.slice(0, MAX_SNIPPET_CHARS) + "\n// ...truncated" : snippet;
+    }
+    catch {
+        return null;
+    }
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
+}
+function assembleContext(repoRoot, graph, targetFingerprint, tokenBudget = DEFAULT_TOKEN_BUDGET) {
+    const target = graph.nodes[targetFingerprint];
+    if (!target)
+        return null;
+    const targetBody = readSnippet(repoRoot, target.file, target.startLine, target.endLine);
+    if (targetBody === null)
+        return null;
+    let usedTokens = estimateTokens(targetBody);
+    // Callees: edges where this symbol is the source
+    const calleeEdges = graph.edges
+        .filter(e => e.from === targetFingerprint)
+        .sort((a, b) => b.confidence - a.confidence);
+    // Callers: edges where this symbol is the target
+    const callerEdges = graph.edges
+        .filter(e => e.to === targetFingerprint)
+        .sort((a, b) => b.confidence - a.confidence);
+    function buildNeighbors(edges, direction) {
+        const neighbors = [];
+        for (const edge of edges) {
+            const neighborFingerprint = direction === "from" ? edge.to : edge.from;
+            const neighborNode = graph.nodes[neighborFingerprint];
+            if (!neighborNode)
+                continue;
+            const snippet = readSnippet(repoRoot, neighborNode.file, neighborNode.startLine, neighborNode.endLine);
+            if (snippet === null)
+                continue;
+            const projected = usedTokens + estimateTokens(snippet);
+            if (projected > tokenBudget)
+                break; // budget exhausted — remaining lower-confidence neighbors are dropped
+            usedTokens = projected;
+            neighbors.push({
+                name: neighborNode.name,
+                file: neighborNode.file,
+                snippet,
+                confidence: edge.confidence,
+                edgeType: edge.type,
+            });
+        }
+        return neighbors;
+    }
+    const callees = buildNeighbors(calleeEdges, "from");
+    const callers = buildNeighbors(callerEdges, "to");
+    const allConfidences = [...callees, ...callers].map(n => n.confidence);
+    const weakestConfidence = allConfidences.length > 0 ? Math.min(...allConfidences) : 1.0;
+    return {
+        targetName: target.name,
+        targetFile: target.file,
+        targetBody,
+        callers,
+        callees,
+        imports: [], // populated by caller if needed — graph doesn't currently store per-node imports
+        weakestConfidence,
+    };
+}

package/dist/utils/dependency-parser.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * dependency-parser.ts
+ *
+ * Extracts declared dependencies from manifest files. Used to feed the
+ * security scanning pipeline — the server queries OSV.dev against whatever
+ * this extracts, so accuracy here directly determines scan coverage.
+ *
+ * Ecosystem names match OSV.dev's own ecosystem strings exactly
+ * (https://ossf.github.io/osv-schema/#affectedpackage-field) — this is not
+ * arbitrary; using the wrong ecosystem name means OSV silently returns zero
+ * results instead of erroring, so precision here matters.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDependencies = extractDependencies;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function stripVersionRange(raw) {
+    // package.json / composer.json versions are often ranges like "^4.17.21",
+    // "~1.2.3", ">=2.0 <3.0". OSV wants a concrete version to check, so we take
+    // the first concrete version number found — this is a best-effort resolution,
+    // not a full semver-range solver. A locked version from package-lock.json
+    // or composer.lock is more accurate when available (handled separately).
+    const match = raw.match(/\d+\.\d+(\.\d+)?(-[\w.]+)?/);
+    return match ? match[0] : raw;
+}
+function parsePackageJson(repoRoot, filePath) {
+    const entries = [];
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        const sections = ["dependencies", "devDependencies"];
+        for (const section of sections) {
+            const deps = raw[section];
+            if (!deps || typeof deps !== "object")
+                continue;
+            for (const [name, versionRaw] of Object.entries(deps)) {
+                if (typeof versionRaw !== "string")
+                    continue;
+                entries.push({
+                    ecosystem: "npm",
+                    packageName: name,
+                    version: stripVersionRange(versionRaw),
+                    manifestFile: path_1.default.relative(repoRoot, filePath),
+                });
+            }
+        }
+    }
+    catch {
+        // malformed or unreadable manifest — skip, never fail the whole scan
+    }
+    return entries;
+}
+/** Prefers package-lock.json's exact resolved versions when available — far more
+ *  accurate than package.json's version ranges for vulnerability matching. */
+function parsePackageLockJson(repoRoot, filePath) {
+    const entries = [];
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        const packages = raw.packages;
+        if (packages && typeof packages === "object") {
+            // npm lockfile v2/v3 format: keys are paths like "node_modules/lodash"
+            for (const [key, val] of Object.entries(packages)) {
+                if (!key.startsWith("node_modules/"))
+                    continue;
+                const name = key.replace(/^node_modules\//, "");
+                const version = val?.version;
+                if (typeof version === "string") {
+                    entries.push({
+                        ecosystem: "npm",
+                        packageName: name,
+                        version,
+                        manifestFile: path_1.default.relative(repoRoot, filePath),
+                    });
+                }
+            }
+            return entries;
+        }
+        // npm lockfile v1 format: "dependencies" key, nested
+        const deps = raw.dependencies;
+        if (deps && typeof deps === "object") {
+            for (const [name, val] of Object.entries(deps)) {
+                const version = val?.version;
+                if (typeof version === "string") {
+                    entries.push({
+                        ecosystem: "npm",
+                        packageName: name,
+                        version,
+                        manifestFile: path_1.default.relative(repoRoot, filePath),
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // malformed or unreadable lockfile — skip
+    }
+    return entries;
+}
+function parseComposerJson(repoRoot, filePath) {
+    const entries = [];
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        const sections = ["require", "require-dev"];
+        for (const section of sections) {
+            const deps = raw[section];
+            if (!deps || typeof deps !== "object")
+                continue;
+            for (const [name, versionRaw] of Object.entries(deps)) {
+                if (typeof versionRaw !== "string")
+                    continue;
+                if (name === "php" || name.startsWith("ext-"))
+                    continue; // not real packages
+                entries.push({
+                    ecosystem: "Packagist",
+                    packageName: name,
+                    version: stripVersionRange(versionRaw),
+                    manifestFile: path_1.default.relative(repoRoot, filePath),
+                });
+            }
+        }
+    }
+    catch {
+        // malformed or unreadable manifest — skip
+    }
+    return entries;
+}
+/** Prefers composer.lock's exact resolved versions when available. */
+function parseComposerLock(repoRoot, filePath) {
+    const entries = [];
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(filePath, "utf-8"));
+        const sections = ["packages", "packages-dev"];
+        for (const section of sections) {
+            const pkgs = raw[section];
+            if (!Array.isArray(pkgs))
+                continue;
+            for (const pkg of pkgs) {
+                if (!pkg?.name || !pkg?.version)
+                    continue;
+                entries.push({
+                    ecosystem: "Packagist",
+                    packageName: pkg.name,
+                    version: stripVersionRange(pkg.version),
+                    manifestFile: path_1.default.relative(repoRoot, filePath),
+                });
+            }
+        }
+    }
+    catch {
+        // malformed or unreadable lockfile — skip
+    }
+    return entries;
+}
+const IGNORED_DIRS = new Set(["node_modules", ".git", ".kortex", "dist", "build", "vendor", "out", ".next"]);
+function findManifestFiles(repoRoot) {
+    const result = { packageJson: [], packageLock: [], composerJson: [], composerLock: [] };
+    function walk(dir) {
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.name === "package.json") {
+                result.packageJson.push(fullPath);
+            }
+            else if (entry.name === "package-lock.json") {
+                result.packageLock.push(fullPath);
+            }
+            else if (entry.name === "composer.json") {
+                result.composerJson.push(fullPath);
+            }
+            else if (entry.name === "composer.lock") {
+                result.composerLock.push(fullPath);
+            }
+        }
+    }
+    walk(repoRoot);
+    return result;
+}
+/**
+ * Extracts all dependencies from a repo. Prefers lockfiles (exact resolved
+ * versions) over manifest files (version ranges) when both exist for the
+ * same directory, since lockfile versions are what's actually installed and
+ * therefore what's actually exploitable.
+ */
+function extractDependencies(repoRoot) {
+    const manifests = findManifestFiles(repoRoot);
+    const entries = [];
+    // npm: prefer lockfiles; fall back to package.json only for directories
+    // that don't have a corresponding lockfile
+    const lockDirs = new Set(manifests.packageLock.map(p => path_1.default.dirname(p)));
+    for (const lockFile of manifests.packageLock) {
+        entries.push(...parsePackageLockJson(repoRoot, lockFile));
+    }
+    for (const pkgFile of manifests.packageJson) {
+        if (!lockDirs.has(path_1.default.dirname(pkgFile))) {
+            entries.push(...parsePackageJson(repoRoot, pkgFile));
+        }
+    }
+    // Composer: same lockfile-preference pattern
+    const composerLockDirs = new Set(manifests.composerLock.map(p => path_1.default.dirname(p)));
+    for (const lockFile of manifests.composerLock) {
+        entries.push(...parseComposerLock(repoRoot, lockFile));
+    }
+    for (const pkgFile of manifests.composerJson) {
+        if (!composerLockDirs.has(path_1.default.dirname(pkgFile))) {
+            entries.push(...parseComposerJson(repoRoot, pkgFile));
+        }
+    }
+    // Deduplicate — same package/ecosystem can appear in multiple lockfiles in monorepos
+    const seen = new Map();
+    for (const e of entries) {
+        const key = `${e.ecosystem}::${e.packageName}`;
+        seen.set(key, e); // last write wins — fine since versions should be consistent within a repo
+    }
+    return Array.from(seen.values());
+}