kodingo-cli 1.1.0 → 1.1.1

package/dist/cli.js

@@ -15,6 +15,8 @@ const scan_git_1 = require("./commands/scan-git");
 const scan_claude_1 = require("./commands/scan-claude");
 const scan_repo_1 = require("./commands/scan-repo");
 const sync_graph_1 = require("./commands/sync-graph");
+const sync_dependencies_1 = require("./commands/sync-dependencies");
+const security_scan_1 = require("./commands/security-scan");
 const init_1 = require("./commands/init");
 const install_hook_1 = require("./commands/install-hook");
 const update_1 = require("./commands/update");
@@ -242,6 +244,26 @@ program
         payload.repo = String(options.repo);
     await (0, sync_graph_1.syncGraphCommand)(payload);
 });
+program
+    .command("sync-dependencies")
+    .description("Extract and sync declared dependencies for security scanning")
+    .option("--repo <path>", "repo path to scan")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        payload.repo = String(options.repo);
+    await (0, sync_dependencies_1.syncDependenciesCommand)(payload);
+});
+program
+    .command("security-scan")
+    .description("Scan synced dependencies for known vulnerabilities")
+    .option("--repo <path>", "repo path to scan")
+    .action(async (options) => {
+    const payload = {};
+    if (options.repo)
+        payload.repo = String(options.repo);
+    await (0, security_scan_1.securityScanCommand)(payload);
+});
 program
     .command("context")
     .description("Get affirmed memories for a file — designed for AI agents")

package/dist/commands/init.js

@@ -289,7 +289,24 @@ function registerInitCommand(program) {
             catch { }
             console.log(`✔ Connected. Token saved to ${persistence_config_1.CONFIG_PATH}`);
             console.log("\nKortex is now watching this repo.");
-            console.log("Run `kodingo install-hook` to capture memories on every commit.\n");
+            // Install the git hook automatically — no manual step required.
+            // This is what triggers scan-git and sync-dependencies on every future
+            // commit, silently in the background.
+            try {
+                const { installHookCommand } = await Promise.resolve().then(() => __importStar(require("./install-hook")));
+                await installHookCommand({ repo: repoRoot });
+                console.log("✔ Git hook installed — memories and dependency data will stay current automatically on every commit.\n");
+            }
+            catch (err) {
+                console.log(`⚠ Could not auto-install git hook (${err.message}). Run \`kodingo install-hook\` manually to enable automatic capture.\n`);
+            }
+            // Initial dependency sync — so security scanning has data immediately,
+            // rather than waiting for the next commit to trigger the hook.
+            try {
+                const { syncDependenciesCommand } = await Promise.resolve().then(() => __importStar(require("./sync-dependencies")));
+                await syncDependenciesCommand({ repo: repoRoot, silent: true });
+            }
+            catch { }
             // Auto-scan existing codebase
             try {
                 const { scanRepoCommand } = await Promise.resolve().then(() => __importStar(require("./scan-repo")));

package/dist/commands/install-hook.js

@@ -18,6 +18,8 @@ async function installHookCommand(options) {
         "# <kodingo>",
         "# Kodingo: auto-infer decision memory from git commits",
         `"${kodingoBin}" scan-git --repo "$(git rev-parse --show-toplevel)" &`,
+        "# Kodingo Security: keep dependency data current for vulnerability scanning",
+        `"${kodingoBin}" sync-dependencies --repo "$(git rev-parse --show-toplevel)" &`,
         "# </kodingo>",
     ].join("\n");
     // Pre-commit hook — runs synchronously to enforce guardrails

package/dist/commands/security-scan.js

@@ -0,0 +1,217 @@
+"use strict";
+/**
+ * kodingo security-scan
+ *
+ * Triggers a vulnerability scan against whatever dependencies were last
+ * synced via 'kodingo sync-dependencies', then prints a ranked report.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityScanCommand = securityScanCommand;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const persistence_config_1 = require("../utils/persistence-config");
+const repo_scope_1 = require("../utils/repo-scope");
+const graph_builder_1 = require("../utils/graph-builder");
+const security_code_analyzer_1 = require("../utils/security-code-analyzer");
+const context_assembler_1 = require("../utils/context-assembler");
+const ast_parser_1 = require("../utils/ast-parser");
+const IGNORED_DIRS = new Set(["node_modules", ".git", ".kortex", "dist", "build", "vendor", "out", ".next"]);
+const SUPPORTED_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".php", ".java", ".kt", ".rb", ".c", ".cpp"];
+function walkFiles(dir) {
+    const results = [];
+    try {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...walkFiles(fullPath));
+            }
+            else if (entry.isFile() && SUPPORTED_EXTENSIONS.includes(path_1.default.extname(entry.name))) {
+                results.push(fullPath);
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+const SEVERITY_ICON = {
+    critical: "🔴", high: "🟠", moderate: "🟡", low: "🔵", unknown: "⚪",
+};
+async function securityScanCommand(options = {}) {
+    const repoRoot = (0, repo_scope_1.resolveRepoScope)(options.repo ? { repo: options.repo } : {}) ?? process.cwd();
+    const config = (0, persistence_config_1.readConfig)();
+    const wsConfig = (0, persistence_config_1.readWorkspaceConfig)(repoRoot);
+    const token = wsConfig?.token ?? "";
+    const apiUrl = wsConfig?.apiUrl ?? config.apiUrl ?? "https://kodingo-api.onrender.com";
+    if (!token) {
+        if (!options.silent)
+            console.error("✖ This repo is not connected to Kodingo. Run `kodingo init` first.");
+        return false;
+    }
+    const repoName = path_1.default.basename(repoRoot);
+    if (!options.silent)
+        console.log(`\n🔒 Kortex Security — scanning ${repoName} for known vulnerabilities...\n`);
+    try {
+        const scanRes = await fetch(`${apiUrl}/security/scan`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+            body: JSON.stringify({ repo: repoName }),
+        });
+        if (!scanRes.ok) {
+            if (!options.silent)
+                console.error(`  ✖ Scan failed: ${scanRes.status} ${await scanRes.text()}`);
+            return false;
+        }
+        const scanData = await scanRes.json();
+        if (scanData.message) {
+            if (!options.silent)
+                console.log(`  ${scanData.message}`);
+            return true;
+        }
+        if (!options.silent)
+            console.log(`  Checked ${scanData.scanned} dependencies against known vulnerability databases\n`);
+        const findingsRes = await fetch(`${apiUrl}/security/findings?repo=${encodeURIComponent(repoName)}`, {
+            headers: { "X-Kodingo-Token": token },
+        });
+        if (!findingsRes.ok)
+            return true; // scan itself succeeded even if the report fetch fails
+        const { findings } = await findingsRes.json();
+        if (findings.length === 0) {
+            if (!options.silent)
+                console.log("  ✔ No known vulnerabilities found in your dependencies.");
+            return true;
+        }
+        if (!options.silent) {
+            console.log(`  ⚠ ${findings.length} vulnerabilit${findings.length === 1 ? "y" : "ies"} found:\n`);
+            for (const f of findings) {
+                const icon = SEVERITY_ICON[f.severity] ?? "⚪";
+                console.log(`  ${icon} ${f.severity.toUpperCase()} — ${f.package_name}@${f.version}`);
+                console.log(`     ${f.summary}`);
+                if (f.fixed_version)
+                    console.log(`     Fix: upgrade to ${f.fixed_version} or later`);
+                if (f.alsoAffectsRepoCount && f.alsoAffectsRepoCount > 0) {
+                    console.log(`     ⚠ Also present in ${f.alsoAffectsRepoCount} other repo${f.alsoAffectsRepoCount === 1 ? "" : "s"} in this project`);
+                }
+                console.log(`     ${f.vulnerability_id}\n`);
+            }
+        }
+        // ── Code-level analysis — Layer 1 (local) + Layer 2 (server LLM judgment) ──
+        if (!options.silent)
+            console.log(`\n🔍 Analysing code for vulnerable patterns and missing auth...\n`);
+        try {
+            const graph = await (0, graph_builder_1.buildGraph)(repoRoot);
+            (0, graph_builder_1.saveGraph)(repoRoot, graph);
+            const files = walkFiles(repoRoot);
+            const symbols = [];
+            for (const file of files) {
+                try {
+                    const source = fs_1.default.readFileSync(file, "utf-8");
+                    symbols.push(...(await (0, ast_parser_1.parseFile)(file, source)));
+                }
+                catch { }
+            }
+            const candidates = (0, security_code_analyzer_1.analyzeForSecurityCandidates)(repoRoot, graph, symbols);
+            if (candidates.length === 0) {
+                if (!options.silent)
+                    console.log("  ✔ No suspicious patterns detected.");
+            }
+            else {
+                const codeScanRes = await fetch(`${apiUrl}/security/scan-code`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                    body: JSON.stringify({ repo: repoName, candidates }),
+                });
+                if (codeScanRes.ok) {
+                    const codeResult = await codeScanRes.json();
+                    if (!options.silent) {
+                        console.log(`  Checked ${codeResult.scanned} candidates — ${codeResult.findingsCreated} confirmed, ${codeResult.dismissed} dismissed as false positives after review\n`);
+                    }
+                }
+                else if (!options.silent) {
+                    console.error(`  ✖ Code analysis failed: ${codeScanRes.status}`);
+                }
+            }
+        }
+        catch (err) {
+            if (!options.silent)
+                console.error(`  ✖ Code analysis failed: ${err.message}`);
+        }
+        // ── Decision drift — does current code still honour past decisions? ──────
+        if (!options.silent)
+            console.log(`\n📜 Checking for drift from past decisions...\n`);
+        try {
+            const graph = await (0, graph_builder_1.buildGraph)(repoRoot);
+            const files = walkFiles(repoRoot);
+            const symbols = [];
+            for (const file of files) {
+                try {
+                    const source = fs_1.default.readFileSync(file, "utf-8");
+                    symbols.push(...(await (0, ast_parser_1.parseFile)(file, source)));
+                }
+                catch { }
+            }
+            const symbolNames = Array.from(new Set(symbols.map(s => s.name)));
+            if (symbolNames.length > 0) {
+                const candidatesRes = await fetch(`${apiUrl}/security/decision-drift-candidates`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                    body: JSON.stringify({ repo: repoName, symbols: symbolNames.slice(0, 3000) }),
+                });
+                if (candidatesRes.ok) {
+                    const { matches } = await candidatesRes.json();
+                    if (matches.length === 0) {
+                        if (!options.silent)
+                            console.log("  No symbols with affirmed decisions found yet.");
+                    }
+                    else {
+                        const checks = [];
+                        for (const match of matches) {
+                            const sym = symbols.find(s => s.name === match.symbol);
+                            if (!sym)
+                                continue;
+                            const assembled = (0, context_assembler_1.assembleContext)(repoRoot, graph, sym.fingerprint);
+                            if (!assembled)
+                                continue;
+                            checks.push({
+                                symbol: match.symbol,
+                                file: sym.file,
+                                fingerprint: sym.fingerprint,
+                                currentBody: assembled.targetBody,
+                                decisionTitle: match.decisionTitle,
+                                decisionContent: match.decisionContent,
+                            });
+                        }
+                        if (checks.length > 0) {
+                            const driftRes = await fetch(`${apiUrl}/security/scan-decision-drift`, {
+                                method: "POST",
+                                headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+                                body: JSON.stringify({ repo: repoName, checks }),
+                            });
+                            if (driftRes.ok) {
+                                const driftResult = await driftRes.json();
+                                if (!options.silent) {
+                                    console.log(`  Checked ${driftResult.scanned} symbols against past decisions — ${driftResult.findingsCreated} drifted, ${driftResult.noDrift} still honoured\n`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (!options.silent)
+                console.error(`  ✖ Decision drift check failed: ${err.message}`);
+        }
+        return true;
+    }
+    catch (err) {
+        if (!options.silent)
+            console.error(`  ✖ Scan failed: ${err.message}`);
+        return false;
+    }
+}

package/dist/commands/sync-dependencies.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * kodingo sync-dependencies
+ *
+ * Extracts declared dependencies from the current repo (package.json/lock,
+ * composer.json/lock) and syncs them to the server for security scanning.
+ * Run this before 'kodingo security-scan' — the scan works off whatever was
+ * last synced here.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncDependenciesCommand = syncDependenciesCommand;
+const path_1 = __importDefault(require("path"));
+const persistence_config_1 = require("../utils/persistence-config");
+const repo_scope_1 = require("../utils/repo-scope");
+const dependency_parser_1 = require("../utils/dependency-parser");
+async function syncDependenciesCommand(options = {}) {
+    const repoRoot = (0, repo_scope_1.resolveRepoScope)(options.repo ? { repo: options.repo } : {}) ?? process.cwd();
+    const config = (0, persistence_config_1.readConfig)();
+    const wsConfig = (0, persistence_config_1.readWorkspaceConfig)(repoRoot);
+    const token = wsConfig?.token ?? "";
+    const apiUrl = wsConfig?.apiUrl ?? config.apiUrl ?? "https://kodingo-api.onrender.com";
+    if (!token) {
+        if (!options.silent)
+            console.error("✖ This repo is not connected to Kodingo. Run `kodingo init` first.");
+        return false;
+    }
+    const repoName = path_1.default.basename(repoRoot);
+    if (!options.silent)
+        console.log(`\n🔒 Kortex Security — scanning dependencies for ${repoName}...\n`);
+    const deps = (0, dependency_parser_1.extractDependencies)(repoRoot);
+    if (deps.length === 0) {
+        if (!options.silent)
+            console.log("  No package.json or composer.json found. Nothing to sync.");
+        return true;
+    }
+    if (!options.silent)
+        console.log(`  Found ${deps.length} dependencies`);
+    try {
+        const res = await fetch(`${apiUrl}/security/sync`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Kodingo-Token": token },
+            body: JSON.stringify({
+                repo: repoName,
+                dependencies: deps.map(d => ({
+                    ecosystem: d.ecosystem,
+                    packageName: d.packageName,
+                    version: d.version,
+                    manifestFile: d.manifestFile,
+                })),
+            }),
+        });
+        if (!res.ok) {
+            if (!options.silent)
+                console.error(`  ✖ Sync failed: ${res.status} ${await res.text()}`);
+            return false;
+        }
+        if (!options.silent)
+            console.log(`\n✔ Synced ${deps.length} dependencies for ${repoName}`);
+        return true;
+    }
+    catch (err) {
+        if (!options.silent)
+            console.error(`  ✖ Sync failed: ${err.message}`);
+        return false;
+    }
+}

package/dist/commands/sync-graph.js

@@ -69,6 +69,7 @@ async function syncGraphCommand(options = {}) {
                         fanIn: n.fanIn,
                         fanOut: n.fanOut,
                         centrality: n.centrality,
+                        rawCalls: n.rawCalls,
                     })),
                     removed: i === 0 ? diff.removed : [],
                     edgesAdded: edgeChunk.map(e => ({

package/dist/test-buildgraph-debug.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graph_builder_1 = require("./utils/graph-builder");
+async function main() {
+    const repoRoot = process.argv[2];
+    const graph = await (0, graph_builder_1.buildGraph)(repoRoot);
+    const node = Object.values(graph.nodes).find(n => n.name === "projectRoutes");
+    console.log(node);
+}
+main();

package/dist/test-calls-debug.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const ast_parser_1 = require("./utils/ast-parser");
+async function main() {
+    const filePath = process.argv[2];
+    const source = fs_1.default.readFileSync(filePath, "utf-8");
+    const symbols = await (0, ast_parser_1.parseFile)(filePath, source);
+    for (const s of symbols) {
+        console.log(`${s.name}: calls = [${s.calls.join(", ")}]`);
+    }
+}
+main();

package/dist/utils/ast-parser.js

@@ -113,6 +113,18 @@ function extractCallNames(node, acc = new Set()) {
             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")

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/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());
+}

package/dist/utils/graph-builder.js

@@ -301,6 +301,7 @@ async function buildGraph(repoRoot) {
             fanIn: 0,
             fanOut: 0,
             centrality: 0,
+            rawCalls: sym.calls ?? [],
         };
     }
     const tsFiles = symbols

package/dist/utils/security-code-analyzer.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * security-code-analyzer.ts
+ *
+ * Layer 1 orchestrator — runs entirely client-side, where the actual source
+ * code and the fully-resolved local graph both exist. Combines:
+ *  - Deterministic code pattern scanning (SQL injection, hardcoded secrets, etc)
+ *  - Missing-auth-on-route detection, using the RESOLVED local graph (more
+ *    precise than the raw_calls fallback, since resolved edges already
+ *    correctly handle object-literal patterns like { preHandler: authMiddleware })
+ *
+ * For every flagged candidate, assembles full code context (target body +
+ * 1-hop callers/callees) via context-assembler.ts, ready to send to the
+ * server for Layer 2 — an LLM judgment with full visibility, which is what
+ * actually adjudicates real risk vs false positive.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMissingAuthCandidatesLocal = findMissingAuthCandidatesLocal;
+exports.analyzeForSecurityCandidates = analyzeForSecurityCandidates;
+const context_assembler_1 = require("./context-assembler");
+const code_pattern_scanner_1 = require("./code-pattern-scanner");
+const ROUTE_REGISTRATION_METHOD_NAMES = new Set(["get", "post", "put", "delete", "patch", "addhook", "all"]);
+const AUTH_FUNCTION_HINTS = [
+    "auth", "requireauth", "requireorg", "requireadmin", "requirelogin",
+    "verifytoken", "checkauth", "isauthenticated", "authenticate", "authorize",
+    "ensureauth", "authmiddleware", "authguard", "protect", "jwt",
+];
+const PUBLIC_ENDPOINT_HINTS = ["health", "login", "signup", "register", "public", "webhook", "ping", "status"];
+function includesRouteRegistration(names) {
+    return names.some(name => ROUTE_REGISTRATION_METHOD_NAMES.has(name.toLowerCase()));
+}
+function includesAuthHint(names) {
+    return names.some(name => {
+        const lower = name.toLowerCase();
+        return AUTH_FUNCTION_HINTS.some(hint => lower.includes(hint));
+    });
+}
+function looksLikePublicEndpoint(symbolName, file) {
+    const lower = (symbolName + " " + file).toLowerCase();
+    return PUBLIC_ENDPOINT_HINTS.some(hint => lower.includes(hint));
+}
+/**
+ * Finds route-registering functions with no resolved auth reference.
+ * Uses BOTH the resolved local graph edges (most precise — handles object-
+ * literal patterns) AND the raw call/reference list (catches library calls
+ * that never resolve as edges, like app.get itself).
+ */
+function findMissingAuthCandidatesLocal(graph, symbolsByFingerprint) {
+    const candidates = [];
+    for (const node of Object.values(graph.nodes)) {
+        if (node.type !== "function" && node.type !== "method")
+            continue;
+        const sym = symbolsByFingerprint.get(node.fingerprint);
+        const rawCallNames = sym?.calls ?? [];
+        // Names reachable via resolved graph edges (calls + references) — this
+        // correctly includes object-literal-nested identifiers like
+        // { preHandler: authMiddleware }, which raw call extraction alone misses.
+        const resolvedEdgeNames = graph.edges
+            .filter(e => e.from === node.fingerprint)
+            .map(e => graph.nodes[e.to]?.name)
+            .filter((n) => !!n);
+        const allNames = [...rawCallNames, ...resolvedEdgeNames];
+        if (!includesRouteRegistration(allNames))
+            continue;
+        if (includesAuthHint(allNames))
+            continue;
+        if (looksLikePublicEndpoint(node.name, node.file))
+            continue;
+        candidates.push({ symbol: node.name, file: node.file, fingerprint: node.fingerprint });
+    }
+    return candidates;
+}
+/**
+ * Runs both Layer 1 detectors and assembles full code context for every
+ * flagged candidate — ready to send to the server for Layer 2 LLM judgment.
+ */
+function analyzeForSecurityCandidates(repoRoot, graph, symbols) {
+    const symbolsByFingerprint = new Map(symbols.map(s => [s.fingerprint, s]));
+    const candidates = [];
+    // ── Code pattern findings ────────────────────────────────────────────────
+    const patternFindings = (0, code_pattern_scanner_1.scanAllSymbolsForPatterns)(symbols);
+    for (const finding of patternFindings) {
+        const sym = symbols.find(s => s.name === finding.symbol && s.file === finding.file);
+        const fingerprint = sym?.fingerprint ?? "";
+        const assembled = fingerprint ? (0, context_assembler_1.assembleContext)(repoRoot, graph, fingerprint) : null;
+        candidates.push({
+            kind: "code_pattern",
+            symbol: finding.symbol,
+            file: finding.file,
+            fingerprint,
+            patternType: finding.patternType,
+            severity: finding.severity,
+            snippet: finding.snippet,
+            description: finding.description,
+            context: assembled ? {
+                targetBody: assembled.targetBody,
+                callers: assembled.callers.map(c => ({ name: c.name, snippet: c.snippet })),
+                callees: assembled.callees.map(c => ({ name: c.name, snippet: c.snippet })),
+            } : null,
+        });
+    }
+    // ── Missing-auth candidates ───────────────────────────────────────────────
+    const authCandidates = findMissingAuthCandidatesLocal(graph, symbolsByFingerprint);
+    for (const cand of authCandidates) {
+        const assembled = (0, context_assembler_1.assembleContext)(repoRoot, graph, cand.fingerprint);
+        candidates.push({
+            kind: "missing_auth",
+            symbol: cand.symbol,
+            file: cand.file,
+            fingerprint: cand.fingerprint,
+            context: assembled ? {
+                targetBody: assembled.targetBody,
+                callers: assembled.callers.map(c => ({ name: c.name, snippet: c.snippet })),
+                callees: assembled.callees.map(c => ({ name: c.name, snippet: c.snippet })),
+            } : null,
+        });
+    }
+    return candidates;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodingo-cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Kodingo CLI",
   "license": "MIT",
   "private": false,