codegate-ai 0.7.0 → 0.8.0

package/dist/layer2-static/detectors/advisory-intelligence.js

@@ -0,0 +1,170 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildFindingEvidence } from "../evidence.js";
+const COMPONENTS_PATH = join(dirname(fileURLToPath(import.meta.url)), "../advisories/agent-components.json");
+const GENERIC_AFFECTED_TOOLS = [
+    "claude-code",
+    "codex-cli",
+    "opencode",
+    "cursor",
+    "windsurf",
+    "github-copilot",
+];
+function globToRegExp(glob) {
+    const pattern = glob.replaceAll("\\", "/").trim();
+    if (pattern.length === 0) {
+        return /^$/u;
+    }
+    let regex = "^";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === "*") {
+            if (pattern[index + 1] === "*") {
+                regex += ".*";
+                index += 1;
+            }
+            else {
+                regex += "[^/]*";
+            }
+            continue;
+        }
+        if (char === "?") {
+            regex += "[^/]";
+            continue;
+        }
+        if ("\\^$.*+?()[]{}|".includes(char)) {
+            regex += `\\${char}`;
+            continue;
+        }
+        regex += char;
+    }
+    regex += "$";
+    return new RegExp(regex, "u");
+}
+function matchesGlob(value, glob) {
+    const normalizedValue = value.replaceAll("\\", "/");
+    const normalizedGlob = glob.replaceAll("\\", "/").trim();
+    if (normalizedGlob.startsWith("**/")) {
+        const suffix = normalizedGlob.slice(3);
+        return normalizedValue === suffix || normalizedValue.endsWith(`/${suffix}`);
+    }
+    return globToRegExp(normalizedGlob).test(normalizedValue);
+}
+function loadComponents() {
+    const raw = readFileSync(COMPONENTS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+}
+const ADVISORY_COMPONENTS = loadComponents();
+function normalizeToken(value) {
+    return value.trim().toLowerCase();
+}
+function collectStringCandidates(value, path = [], output = []) {
+    if (typeof value === "string") {
+        output.push({ path: path.join("."), value });
+        return output;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => {
+            collectStringCandidates(entry, [...path, String(index)], output);
+        });
+        return output;
+    }
+    if (!value || typeof value !== "object") {
+        return output;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        collectStringCandidates(child, [...path, key], output);
+    }
+    return output;
+}
+function makeFinding(filePath, matchedPath, component, signature, evidence) {
+    const location = { field: matchedPath };
+    if (typeof evidence?.line === "number") {
+        location.line = evidence.line;
+    }
+    if (typeof evidence?.column === "number") {
+        location.column = evidence.column;
+    }
+    return {
+        rule_id: component.rule_id,
+        finding_id: `${component.rule_id}-${filePath}-${matchedPath}`,
+        severity: component.severity,
+        category: component.category,
+        layer: "L2",
+        file_path: filePath,
+        location,
+        description: component.description,
+        affected_tools: GENERIC_AFFECTED_TOOLS,
+        cve: null,
+        owasp: component.owasp,
+        cwe: component.cwe,
+        confidence: component.confidence,
+        fixable: true,
+        remediation_actions: component.remediation_actions,
+        metadata: {
+            sources: component.metadata?.sources ?? [],
+            sinks: component.metadata?.sinks ?? [],
+            referenced_secrets: component.metadata?.referenced_secrets ?? [],
+            risk_tags: component.metadata?.risk_tags ?? [],
+            origin: component.metadata?.origin ?? "agent-components.json",
+        },
+        evidence: evidence?.evidence ?? null,
+        suppressed: false,
+    };
+}
+function componentMatchesFile(component, filePath) {
+    return component.file_patterns.some((pattern) => matchesGlob(filePath, pattern));
+}
+function signatureMatches(value, signatures) {
+    const normalizedValue = normalizeToken(value);
+    for (const signature of signatures) {
+        const normalizedSignature = normalizeToken(signature);
+        if (normalizedSignature.length > 0 && normalizedValue.includes(normalizedSignature)) {
+            return signature;
+        }
+    }
+    return null;
+}
+function detectComponentMatch(input, component) {
+    if (!componentMatchesFile(component, input.filePath)) {
+        return null;
+    }
+    const stringCandidates = collectStringCandidates(input.parsed);
+    for (const candidate of stringCandidates) {
+        const signature = signatureMatches(candidate.value, component.signatures);
+        if (!signature) {
+            continue;
+        }
+        const evidence = buildFindingEvidence({
+            textContent: input.textContent,
+            jsonPaths: candidate.path.length > 0 ? [candidate.path] : [],
+            searchTerms: [signature],
+            fallbackValue: `${candidate.path} = ${candidate.value}`,
+        });
+        return makeFinding(input.filePath, candidate.path || component.id, component, signature, evidence);
+    }
+    for (const signature of component.signatures) {
+        if (!signatureMatches(input.textContent, [signature])) {
+            continue;
+        }
+        const evidence = buildFindingEvidence({
+            textContent: input.textContent,
+            searchTerms: [signature],
+            fallbackValue: signature,
+        });
+        return makeFinding(input.filePath, component.id, component, signature, evidence);
+    }
+    return null;
+}
+export function detectAdvisoryIntelligence(input) {
+    const findings = [];
+    for (const component of ADVISORY_COMPONENTS) {
+        const finding = detectComponentMatch(input, component);
+        if (finding) {
+            findings.push(finding);
+        }
+    }
+    return findings;
+}

package/dist/layer2-static/detectors/command-exec.js

@@ -95,6 +95,12 @@ function makeFinding(filePath, field, ruleId, severity, description, evidence) {
         confidence: "HIGH",
         fixable: true,
         remediation_actions: ["remove_field", "replace_with_default"],
+        metadata: {
+            sources: [filePath, field],
+            sinks: ["process-execution"],
+            risk_tags: ["command-execution", "shell-pipeline"],
+            origin: "command-exec",
+        },
         evidence: evidence?.evidence ?? null,
         suppressed: false,
     };

package/dist/layer2-static/detectors/rule-file.js

@@ -48,6 +48,11 @@ function makeFinding(filePath, field, ruleId, description, evidence, severity =
         confidence: "HIGH",
         fixable: true,
         remediation_actions: ["strip_unicode", "remove_block", "quarantine_file"],
+        metadata: {
+            sources: [filePath, field],
+            risk_tags: ["rule-injection", "prompt-injection"],
+            origin: "rule-file",
+        },
         evidence: evidence?.evidence ?? null,
         observed: narrative.observed ?? null,
         inference: narrative.inference ?? null,

package/dist/layer2-static/engine.d.ts

@@ -1,6 +1,6 @@
 import { type GitHookEntry } from "./detectors/git-hooks.js";
 import { type SymlinkEscapeEntry } from "./detectors/symlink.js";
-import type { Finding } from "../types/finding.js";
+import { type Finding } from "../types/finding.js";
 import type { DiscoveryFormat } from "../types/discovery.js";
 export interface StaticFileInput {
     filePath: string;
@@ -17,6 +17,9 @@ export interface StaticEngineConfig {
     trustedApiDomains: string[];
     unicodeAnalysis: boolean;
     checkIdeSettings: boolean;
+    rulePackPaths?: string[];
+    allowedRules?: string[];
+    skipRules?: string[];
 }
 export interface StaticEngineInput {
     projectRoot: string;

package/dist/layer2-static/engine.js

@@ -1,4 +1,5 @@
 import { detectCommandExecution } from "./detectors/command-exec.js";
+import { detectAdvisoryIntelligence } from "./detectors/advisory-intelligence.js";
 import { detectConsentBypass } from "./detectors/consent-bypass.js";
 import { detectEnvOverrides } from "./detectors/env-override.js";
 import { detectGitHookIssues } from "./detectors/git-hooks.js";
@@ -6,6 +7,78 @@ import { detectIdeSettingsIssues } from "./detectors/ide-settings.js";
 import { detectPluginManifestIssues } from "./detectors/plugin-manifest.js";
 import { detectRuleFileIssues } from "./detectors/rule-file.js";
 import { detectSymlinkEscapes } from "./detectors/symlink.js";
+import { FINDING_CATEGORIES } from "../types/finding.js";
+import { buildFindingEvidence } from "./evidence.js";
+import { evaluateRule, loadRulePacks } from "./rule-engine.js";
+const GENERIC_AFFECTED_TOOLS = [
+    "claude-code",
+    "codex-cli",
+    "opencode",
+    "cursor",
+    "windsurf",
+    "github-copilot",
+];
+function parseRuleSeverity(value) {
+    const normalized = value.trim().toUpperCase();
+    if (normalized === "CRITICAL" ||
+        normalized === "HIGH" ||
+        normalized === "MEDIUM" ||
+        normalized === "LOW") {
+        return normalized;
+    }
+    return "INFO";
+}
+function parseRuleCategory(value) {
+    const normalized = value.trim().toUpperCase();
+    if (FINDING_CATEGORIES.some((category) => category === normalized)) {
+        return normalized;
+    }
+    return "CONFIG_PRESENT";
+}
+function remediationActionsForRule(rule) {
+    if (rule.query_type === "text_pattern") {
+        return ["quarantine_file", "remove_block"];
+    }
+    return ["remove_field", "replace_with_default"];
+}
+function findingFromRulePackMatch(file, rule) {
+    const locationField = rule.query_type === "text_pattern" ? "content" : rule.query;
+    const evidence = buildFindingEvidence({
+        textContent: file.textContent,
+        searchTerms: [rule.query],
+        fallbackValue: `${locationField} matched rule ${rule.id}`,
+    });
+    const affectedTools = rule.tool === "*" ? GENERIC_AFFECTED_TOOLS : [rule.tool];
+    return {
+        rule_id: rule.id,
+        finding_id: `RULE_PACK-${rule.id}-${file.filePath}-${locationField}`,
+        severity: parseRuleSeverity(rule.severity),
+        category: parseRuleCategory(rule.category),
+        layer: "L2",
+        file_path: file.filePath,
+        location: { field: locationField },
+        description: rule.description,
+        affected_tools: affectedTools,
+        cve: rule.cve ?? null,
+        owasp: rule.owasp,
+        cwe: rule.cwe,
+        confidence: "HIGH",
+        fixable: true,
+        remediation_actions: remediationActionsForRule(rule),
+        metadata: {
+            sources: [file.filePath, locationField],
+            risk_tags: ["rule-pack"],
+            origin: "rule-pack",
+        },
+        evidence: evidence?.evidence ?? null,
+        suppressed: false,
+    };
+}
+function hasEquivalentFinding(findings, candidate) {
+    return findings.some((finding) => finding.rule_id === candidate.rule_id &&
+        finding.file_path === candidate.file_path &&
+        (finding.location.field ?? "") === (candidate.location.field ?? ""));
+}
 function dedupeFindings(findings) {
     const deduped = new Map();
     for (const finding of findings) {
@@ -32,6 +105,11 @@ function dedupeFindings(findings) {
 }
 export function runStaticEngine(input) {
     const findings = [];
+    const rulePackRules = loadRulePacks({
+        rule_pack_paths: input.config.rulePackPaths ?? [],
+        allowed_rules: input.config.allowedRules ?? [],
+        skip_rules: input.config.skipRules ?? [],
+    });
     for (const file of input.files) {
         findings.push(...detectEnvOverrides({
             filePath: file.filePath,
@@ -69,6 +147,11 @@ export function runStaticEngine(input) {
             trustedApiDomains: input.config.trustedApiDomains,
             blockedCommands: input.config.blockedCommands,
         }));
+        findings.push(...detectAdvisoryIntelligence({
+            filePath: file.filePath,
+            parsed: file.parsed,
+            textContent: file.textContent,
+        }));
         if (file.format === "text" || file.format === "markdown") {
             findings.push(...detectRuleFileIssues({
                 filePath: file.filePath,
@@ -76,6 +159,20 @@ export function runStaticEngine(input) {
                 unicodeAnalysis: input.config.unicodeAnalysis,
             }));
         }
+        for (const rule of rulePackRules) {
+            if (!evaluateRule(rule, {
+                filePath: file.filePath,
+                format: file.format,
+                parsed: file.parsed,
+                textContent: file.textContent,
+            })) {
+                continue;
+            }
+            const candidate = findingFromRulePackMatch(file, rule);
+            if (!hasEquivalentFinding(findings, candidate)) {
+                findings.push(candidate);
+            }
+        }
     }
     findings.push(...detectSymlinkEscapes({ symlinkEscapes: input.symlinkEscapes }));
     findings.push(...detectGitHookIssues({ hooks: input.hooks, knownSafeHooks: input.config.knownSafeHooks }));

package/dist/layer2-static/rule-engine.d.ts

@@ -21,4 +21,4 @@ export interface RuleEvaluationInput {
     textContent: string;
 }
 export declare function evaluateRule(rule: DetectionRule, input: RuleEvaluationInput): boolean;
-export declare function loadRulePacks(baseDir?: string): DetectionRule[];
+export { loadRulePacks } from "./rule-pack-loader.js";

package/dist/layer2-static/rule-engine.js

@@ -1,7 +1,3 @@
-import { readdirSync, readFileSync } from "node:fs";
-import { dirname, extname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-const rulesDir = resolve(dirname(fileURLToPath(import.meta.url)), "rules");
 function escapeRegex(value) {
     return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
 }
@@ -127,12 +123,4 @@ export function evaluateRule(rule, input) {
     }
     return false;
 }
-export function loadRulePacks(baseDir = rulesDir) {
-    const files = readdirSync(baseDir)
-        .filter((file) => extname(file) === ".json")
-        .sort();
-    return files.flatMap((file) => {
-        const raw = readFileSync(join(baseDir, file), "utf8");
-        return JSON.parse(raw);
-    });
-}
+export { loadRulePacks } from "./rule-pack-loader.js";

package/dist/layer2-static/rule-pack-loader.d.ts

@@ -0,0 +1,10 @@
+import type { DetectionRule } from "./rule-engine.js";
+export interface RulePackLoaderOptions {
+    baseDir?: string;
+    rule_pack_paths?: string[];
+    allowed_rules?: string[];
+    skip_rules?: string[];
+}
+export declare function loadRulePacks(): DetectionRule[];
+export declare function loadRulePacks(baseDir: string): DetectionRule[];
+export declare function loadRulePacks(options: RulePackLoaderOptions): DetectionRule[];

package/dist/layer2-static/rule-pack-loader.js

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const defaultRulesDir = resolve(dirname(fileURLToPath(import.meta.url)), "rules");
+const require = createRequire(import.meta.url);
+const Ajv = require("ajv");
+const RULE_SCHEMA = {
+    type: "object",
+    additionalProperties: true,
+    required: [
+        "id",
+        "severity",
+        "category",
+        "description",
+        "tool",
+        "file_pattern",
+        "query_type",
+        "query",
+        "condition",
+        "owasp",
+        "cwe",
+    ],
+    properties: {
+        id: { type: "string", minLength: 1 },
+        severity: { type: "string", minLength: 1 },
+        category: { type: "string", minLength: 1 },
+        description: { type: "string", minLength: 1 },
+        tool: { type: "string", minLength: 1 },
+        file_pattern: { type: "string", minLength: 1 },
+        query_type: {
+            type: "string",
+            enum: ["json_path", "toml_path", "env_key", "text_pattern"],
+        },
+        query: { type: "string" },
+        condition: {
+            type: "string",
+            enum: [
+                "equals_true",
+                "equals_false",
+                "exists",
+                "not_empty",
+                "matches_regex",
+                "not_in_allowlist",
+                "regex_match",
+                "contains",
+                "line_length_exceeds",
+            ],
+        },
+        cve: { type: "string" },
+        owasp: {
+            type: "array",
+            items: { type: "string" },
+        },
+        cwe: { type: "string", minLength: 1 },
+    },
+};
+const ruleValidator = new Ajv({ allErrors: true, strict: false }).compile(RULE_SCHEMA);
+function normalizeRuleIds(values) {
+    const seen = new Set();
+    const normalized = [];
+    for (const value of values ?? []) {
+        const trimmed = value.trim();
+        if (trimmed.length === 0 || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized;
+}
+function toErrorMessage(errors) {
+    if (!errors || errors.length === 0) {
+        return "validation error";
+    }
+    return errors
+        .map((error) => {
+        const location = error.instancePath === "" ? "<root>" : error.instancePath;
+        return `${location}: ${error.message ?? "validation error"}`;
+    })
+        .join("; ");
+}
+function isPackDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isPackFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function resolvePackPaths(path) {
+    const absolutePath = resolve(path);
+    if (!existsSync(absolutePath)) {
+        throw new Error(`Rule pack path does not exist: ${absolutePath}`);
+    }
+    if (isPackFile(absolutePath)) {
+        return [absolutePath];
+    }
+    if (!isPackDirectory(absolutePath)) {
+        throw new Error(`Rule pack path is not a file or directory: ${absolutePath}`);
+    }
+    return readdirSync(absolutePath)
+        .filter((file) => extname(file) === ".json")
+        .filter((file) => file !== "schema.json")
+        .sort()
+        .map((file) => join(absolutePath, file));
+}
+function loadRulesFromFile(path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse rule pack ${path}: ${reason}`, { cause: error });
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error(`Invalid rule pack ${path}: expected a JSON array of rule objects`);
+    }
+    return parsed.map((candidate, index) => {
+        if (!ruleValidator(candidate)) {
+            const reasons = toErrorMessage(ruleValidator.errors);
+            throw new Error(`Invalid rule pack ${path} [${index}]: ${reasons}`);
+        }
+        return candidate;
+    });
+}
+function collectRulesFromPaths(paths) {
+    const collected = [];
+    for (const path of paths) {
+        for (const packPath of resolvePackPaths(path)) {
+            collected.push(...loadRulesFromFile(packPath));
+        }
+    }
+    return collected;
+}
+function dedupeByRuleId(rules) {
+    const deduped = new Map();
+    for (const rule of rules) {
+        deduped.set(rule.id, rule);
+    }
+    return Array.from(deduped.values());
+}
+function filterRules(rules, allowedRules, skipRules) {
+    const allowed = new Set(allowedRules);
+    const skipped = new Set(skipRules);
+    return rules.filter((rule) => {
+        if (skipped.has(rule.id)) {
+            return false;
+        }
+        if (allowed.size > 0 && !allowed.has(rule.id)) {
+            return false;
+        }
+        return true;
+    });
+}
+function normalizeOptions(arg) {
+    if (typeof arg === "string") {
+        return {
+            baseDir: arg,
+            rulePackPaths: [],
+            allowedRules: [],
+            skipRules: [],
+        };
+    }
+    const options = arg ?? {};
+    return {
+        baseDir: options.baseDir ?? defaultRulesDir,
+        rulePackPaths: options.rule_pack_paths ?? [],
+        allowedRules: normalizeRuleIds(options.allowed_rules),
+        skipRules: normalizeRuleIds(options.skip_rules),
+    };
+}
+export function loadRulePacks(arg) {
+    const options = normalizeOptions(arg);
+    const bundledRules = collectRulesFromPaths([options.baseDir]);
+    const externalRules = collectRulesFromPaths(options.rulePackPaths);
+    return filterRules(dedupeByRuleId([...bundledRules, ...externalRules]), options.allowedRules, options.skipRules);
+}

package/dist/layer3-dynamic/toxic-flow.js

@@ -42,6 +42,12 @@ function makeFinding(input, sourceTool, sensitiveTool, sinkTool) {
         confidence: "HIGH",
         fixable: false,
         remediation_actions: [],
+        metadata: {
+            sources: [sourceTool],
+            sinks: [sinkTool],
+            risk_tags: ["toxic-flow"],
+            origin: "toxic-flow",
+        },
         suppressed: false,
     };
 }

package/dist/pipeline.js

@@ -3,6 +3,7 @@ import { createEmptyReport } from "./types/report.js";
 import { scanToolDescriptions, } from "./layer3-dynamic/tool-description-scanner.js";
 import { detectToxicFlows } from "./layer3-dynamic/toxic-flow.js";
 import { applyReportSummary } from "./report-summary.js";
+import { withFindingFingerprint } from "./report/finding-fingerprint.js";
 export function runStaticPipeline(input) {
     const findings = runStaticEngine({
         projectRoot: input.projectRoot,
@@ -10,7 +11,7 @@ export function runStaticPipeline(input) {
         symlinkEscapes: input.symlinkEscapes,
         hooks: input.hooks,
         config: input.config,
-    });
+    }).map(withFindingFingerprint);
     const report = createEmptyReport({
         version: input.version,
         kbVersion: input.kbVersion,
@@ -63,7 +64,7 @@ function parseLayer3Response(resourceId, metadata) {
         .filter((item) => typeof item === "object" && item !== null)
         .map((item, index) => {
         const findingId = item.id ?? `L3-${resourceId}-${index}`;
-        return {
+        return withFindingFingerprint({
             rule_id: item.id ?? "layer3-analysis-finding",
             finding_id: findingId,
             severity: parseSeverity(item.severity),
@@ -82,7 +83,7 @@ function parseLayer3Response(resourceId, metadata) {
             remediation_actions: item.remediation_actions ?? [],
             source_config: item.source_config ?? null,
             suppressed: false,
-        };
+        });
     });
 }
 function asRecord(value) {
@@ -172,17 +173,17 @@ function deriveLayer3ToolFindings(resourceId, metadata, options = {}) {
             serverId: resourceId,
             tools: toolDescriptions,
             unicodeAnalysis: options.unicodeAnalysis,
-        }),
+        }).map(withFindingFingerprint),
         ...detectToxicFlows({
             scopeId: resourceId,
             tools: toolDescriptions,
             knownClassifications,
-        }),
+        }).map(withFindingFingerprint),
     ];
 }
 function layer3ErrorFinding(resourceId, status, description) {
     const severity = status === "timeout" ? "MEDIUM" : status === "skipped_without_consent" ? "INFO" : "LOW";
-    return {
+    return withFindingFingerprint({
         rule_id: `layer3-${status}`,
         finding_id: `L3-${status}-${resourceId}`,
         severity,
@@ -199,7 +200,7 @@ function layer3ErrorFinding(resourceId, status, description) {
         fixable: false,
         remediation_actions: [],
         suppressed: false,
-    };
+    });
 }
 function isRegistryMetadataResource(resourceId) {
     return (resourceId.startsWith("npm:") || resourceId.startsWith("pypi:") || resourceId.startsWith("git:"));
@@ -232,7 +233,7 @@ export function layer3OutcomesToFindings(outcomes, options = {}) {
 export function mergeLayer3Findings(baseReport, layer3Findings) {
     return applyReportSummary({
         ...baseReport,
-        findings: [...baseReport.findings, ...layer3Findings],
+        findings: [...baseReport.findings, ...layer3Findings].map(withFindingFingerprint),
     });
 }
 export async function runDeepScanWithConsent(resources, requestConsent, execute) {

package/dist/report/finding-fingerprint.d.ts

@@ -0,0 +1,5 @@
+import type { Finding } from "../types/finding.js";
+export declare function buildFindingFingerprint(finding: Finding): string;
+export declare function withFindingFingerprint<T extends Finding>(finding: T): T & {
+    fingerprint: string;
+};