@praneeth_54/agentdoctor 0.3.0-beta → 1.1.0

package/dist/core/fix/writers/claude-settings.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
+import { claudeReadDenyRule } from "../../rules/claude-deny.js";
+const MAX_BYTES = 512 * 1024;
+const SETTINGS_RELATIVE = ".claude/settings.json";
+export function denyRuleForFixPattern(pattern, evidencePath) {
+    const isDirectory = pattern.endsWith("/");
+    return claudeReadDenyRule(evidencePath, isDirectory ? "directory" : "file");
+}
+export function missingClaudeDenyRules(currentContent, denyRules) {
+    const existing = parseDenyList(currentContent);
+    const missing = [];
+    for (const rule of denyRules) {
+        if (existing.includes(rule)) {
+            continue;
+        }
+        missing.push(rule);
+    }
+    return missing;
+}
+export function buildClaudeSettingsContent(currentContent, denyRulesToAdd) {
+    if (denyRulesToAdd.length === 0) {
+        return currentContent ?? `${JSON.stringify({ permissions: { deny: [] } }, null, 2)}\n`;
+    }
+    let parsed = {};
+    if (currentContent && currentContent.trim().length > 0) {
+        try {
+            parsed = JSON.parse(currentContent);
+        }
+        catch {
+            throw new Error(`${SETTINGS_RELATIVE} is not valid JSON; refusing to apply Claude Fix`);
+        }
+    }
+    const permissions = parsed.permissions && typeof parsed.permissions === "object" ? { ...parsed.permissions } : {};
+    const deny = Array.isArray(permissions.deny)
+        ? permissions.deny.filter((item) => typeof item === "string")
+        : [];
+    for (const rule of denyRulesToAdd) {
+        if (!deny.includes(rule)) {
+            deny.push(rule);
+        }
+    }
+    permissions.deny = deny;
+    parsed.permissions = permissions;
+    return `${JSON.stringify(parsed, null, 2)}\n`;
+}
+export function previewClaudeSettingsActions(currentContent, actions) {
+    const claudeActions = actions.filter((a) => a.agent === "claude-code" && a.targetRelativePath === SETTINGS_RELATIVE);
+    if (claudeActions.length === 0) {
+        return null;
+    }
+    const requested = [
+        ...new Set(claudeActions.map((a) => denyRuleForFixPattern(a.pattern, a.evidencePath))),
+    ];
+    const denyRulesToAdd = missingClaudeDenyRules(currentContent, requested);
+    if (denyRulesToAdd.length === 0) {
+        return null;
+    }
+    const before = currentContent ?? "";
+    const after = buildClaudeSettingsContent(currentContent, denyRulesToAdd);
+    return {
+        targetRelativePath: SETTINGS_RELATIVE,
+        denyRulesToAdd,
+        before,
+        after,
+        preview: formatSimpleDiff(SETTINGS_RELATIVE, before, after),
+    };
+}
+export async function readClaudeSettings(root) {
+    return readTextFile(path.join(root, SETTINGS_RELATIVE), MAX_BYTES);
+}
+export async function writeClaudeSettings(root, content) {
+    await atomicWriteTextFile(path.join(root, SETTINGS_RELATIVE), content);
+}
+function parseDenyList(currentContent) {
+    if (!currentContent || currentContent.trim().length === 0) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(currentContent);
+        const deny = parsed.permissions?.deny;
+        if (!Array.isArray(deny)) {
+            return [];
+        }
+        return deny.filter((item) => typeof item === "string");
+    }
+    catch {
+        return [];
+    }
+}
+function formatSimpleDiff(fileLabel, before, after) {
+    const lines = [];
+    lines.push(`--- a/${fileLabel}`);
+    lines.push(`+++ b/${fileLabel}`);
+    lines.push(before.trim().length === 0 ? "@@ new file @@" : "@@ update @@");
+    for (const line of after.split(/\r?\n/)) {
+        lines.push(`+${line}`);
+    }
+    return lines.join("\n");
+}

package/dist/core/fix/writers/codex-config.d.ts

@@ -0,0 +1,22 @@
+import type { FixAction } from "../types.js";
+declare const CONFIG_RELATIVE = ".codex/config.toml";
+export interface CodexConfigWritePreview {
+    targetRelativePath: typeof CONFIG_RELATIVE;
+    denyKeysToAdd: string[];
+    before: string;
+    after: string;
+    preview: string;
+}
+export declare function denyKeyForFixPattern(_pattern: string, evidencePath: string): string;
+export declare function missingCodexDenyKeys(currentContent: string | null, denyKeys: string[]): string[];
+/**
+ * Merge filesystem deny keys into project `.codex/config.toml`.
+ * Refuses when sandbox_mode is present (permission profiles do not compose).
+ * Refuses when default_permissions selects a built-in `:…` profile.
+ */
+export declare function buildCodexConfigContent(currentContent: string | null, denyKeysToAdd: string[]): string;
+export declare function previewCodexConfigActions(currentContent: string | null, actions: FixAction[]): CodexConfigWritePreview | null;
+export declare function readCodexConfig(root: string): Promise<string | null>;
+export declare function writeCodexConfig(root: string, content: string): Promise<void>;
+export declare function assertWritableCodexConfig(content: string): void;
+export {};

package/dist/core/fix/writers/codex-config.js

@@ -0,0 +1,183 @@
+import path from "node:path";
+import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
+import { codexDenyKey, configTextDeniesPath } from "../../rules/codex-deny.js";
+const MAX_BYTES = 512 * 1024;
+const CONFIG_RELATIVE = ".codex/config.toml";
+const AGENTDOCTOR_PROFILE = "agentdoctor_context";
+const BEGIN_MARKER = "# BEGIN AgentDoctor context exclusions";
+const END_MARKER = "# END AgentDoctor context exclusions";
+export function denyKeyForFixPattern(_pattern, evidencePath) {
+    return codexDenyKey(evidencePath);
+}
+export function missingCodexDenyKeys(currentContent, denyKeys) {
+    if (!currentContent || currentContent.trim().length === 0) {
+        return [...new Set(denyKeys)];
+    }
+    const missing = [];
+    for (const key of denyKeys) {
+        if (configTextDeniesPath(currentContent, key)) {
+            continue;
+        }
+        missing.push(key);
+    }
+    return [...new Set(missing)];
+}
+/**
+ * Merge filesystem deny keys into project `.codex/config.toml`.
+ * Refuses when sandbox_mode is present (permission profiles do not compose).
+ * Refuses when default_permissions selects a built-in `:…` profile.
+ */
+export function buildCodexConfigContent(currentContent, denyKeysToAdd) {
+    if (denyKeysToAdd.length === 0) {
+        return currentContent ?? "";
+    }
+    const existing = currentContent ?? "";
+    assertWritableCodexConfig(existing);
+    const profile = resolveTargetProfile(existing);
+    const sectionHeader = `[permissions.${profile}.filesystem.":workspace_roots"]`;
+    let next = existing;
+    if (!hasDefaultPermissions(next)) {
+        next = ensureTrailingNewline(next);
+        if (next.trim().length > 0) {
+            next += "\n";
+        }
+        next += `${BEGIN_MARKER}\n`;
+        next += `default_permissions = "${profile}"\n`;
+    }
+    const section = findTomlTableRange(next, sectionHeader);
+    if (!section) {
+        next = ensureTrailingNewline(next);
+        if (!next.includes(BEGIN_MARKER)) {
+            next += `\n${BEGIN_MARKER}\n`;
+        }
+        next += `${sectionHeader}\n`;
+        if (profile === AGENTDOCTOR_PROFILE) {
+            next += `"." = "write"\n`;
+        }
+        for (const key of denyKeysToAdd) {
+            next += `"${key}" = "deny"\n`;
+        }
+        if (!next.includes(END_MARKER)) {
+            next += `${END_MARKER}\n`;
+        }
+        return next;
+    }
+    const body = next.slice(section.bodyStart, section.end);
+    const linesToInsert = [];
+    for (const key of denyKeysToAdd) {
+        if (configTextDeniesPath(body, key) || configTextDeniesPath(next, key)) {
+            continue;
+        }
+        linesToInsert.push(`"${key}" = "deny"`);
+    }
+    if (linesToInsert.length === 0) {
+        return next;
+    }
+    const beforeBodyEnd = next.slice(0, section.end);
+    const afterBodyEnd = next.slice(section.end);
+    const trimmedBodyEnd = beforeBodyEnd.endsWith("\n") ? beforeBodyEnd : `${beforeBodyEnd}\n`;
+    const suffix = afterBodyEnd.startsWith("\n") || afterBodyEnd.length === 0 ? afterBodyEnd : `\n${afterBodyEnd}`;
+    return `${trimmedBodyEnd}${linesToInsert.join("\n")}\n${suffix}`;
+}
+export function previewCodexConfigActions(currentContent, actions) {
+    const codexActions = actions.filter((a) => a.agent === "codex" && a.targetRelativePath === CONFIG_RELATIVE);
+    if (codexActions.length === 0) {
+        return null;
+    }
+    const requested = [
+        ...new Set(codexActions.map((a) => denyKeyForFixPattern(a.pattern, a.evidencePath))),
+    ];
+    const denyKeysToAdd = missingCodexDenyKeys(currentContent, requested);
+    if (denyKeysToAdd.length === 0) {
+        return null;
+    }
+    const before = currentContent ?? "";
+    const after = buildCodexConfigContent(currentContent, denyKeysToAdd);
+    return {
+        targetRelativePath: CONFIG_RELATIVE,
+        denyKeysToAdd,
+        before,
+        after,
+        preview: formatSimpleDiff(CONFIG_RELATIVE, before, after),
+    };
+}
+export async function readCodexConfig(root) {
+    return readTextFile(path.join(root, CONFIG_RELATIVE), MAX_BYTES);
+}
+export async function writeCodexConfig(root, content) {
+    await atomicWriteTextFile(path.join(root, CONFIG_RELATIVE), content);
+}
+export function assertWritableCodexConfig(content) {
+    if (/^\s*sandbox_mode\s*=/m.test(content)) {
+        throw new Error(`${CONFIG_RELATIVE} uses sandbox_mode; refusing Codex Fix (permission profiles do not compose with sandbox_mode)`);
+    }
+    const builtin = readDefaultPermissions(content);
+    if (builtin && builtin.startsWith(":")) {
+        throw new Error(`${CONFIG_RELATIVE} default_permissions is built-in "${builtin}"; refusing Codex Fix (create a custom permissions profile first)`);
+    }
+    if (content.trim().length > 0 && !isRecognizableCodexConfig(content)) {
+        throw new Error(`${CONFIG_RELATIVE} does not look like valid Codex config TOML; refusing Codex Fix`);
+    }
+}
+/** Allow empty/comment-only files, AgentDoctor-managed blocks, or known Codex tables. */
+function isRecognizableCodexConfig(content) {
+    if (content.includes(BEGIN_MARKER) || content.includes(END_MARKER)) {
+        return true;
+    }
+    if (readDefaultPermissions(content) !== null) {
+        return true;
+    }
+    if (/^\s*\[(permissions\.|mcp_servers\.|projects\.)/m.test(content)) {
+        return true;
+    }
+    // Comment-only / blank files are safe to initialize.
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#")) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function resolveTargetProfile(content) {
+    const existing = readDefaultPermissions(content);
+    if (existing && !existing.startsWith(":")) {
+        return existing;
+    }
+    return AGENTDOCTOR_PROFILE;
+}
+function hasDefaultPermissions(content) {
+    return readDefaultPermissions(content) !== null;
+}
+function readDefaultPermissions(content) {
+    const match = content.match(/^\s*default_permissions\s*=\s*["']([^"']+)["']\s*$/m);
+    return match?.[1] ?? null;
+}
+function findTomlTableRange(content, header) {
+    const start = content.indexOf(header);
+    if (start < 0) {
+        return null;
+    }
+    const bodyStart = start + header.length;
+    const rest = content.slice(bodyStart);
+    const nextHeader = rest.search(/\n\s*\[/);
+    const end = nextHeader < 0 ? content.length : bodyStart + nextHeader;
+    return { start, bodyStart, end };
+}
+function ensureTrailingNewline(value) {
+    if (value.length === 0 || value.endsWith("\n")) {
+        return value;
+    }
+    return `${value}\n`;
+}
+function formatSimpleDiff(fileLabel, before, after) {
+    const lines = [];
+    lines.push(`--- a/${fileLabel}`);
+    lines.push(`+++ b/${fileLabel}`);
+    lines.push(before.trim().length === 0 ? "@@ new file @@" : "@@ update @@");
+    for (const line of after.split(/\r?\n/)) {
+        lines.push(`+${line}`);
+    }
+    return lines.join("\n");
+}

package/dist/core/fix/writers/cursorignore.js

@@ -1,6 +1,5 @@
-import fs from "node:fs/promises";
 import path from "node:path";
-import { readTextFile } from "../../../utils/fs.js";
+import { atomicWriteTextFile, readTextFile } from "../../../utils/fs.js";
 import { missingPatternsForCursorignore } from "../plan.js";
 const MAX_BYTES = 512 * 1024;
 const BANNER = "# Added by AgentDoctor";
@@ -41,12 +40,7 @@ export async function readCursorignore(root) {
     return readTextFile(path.join(root, ".cursorignore"), MAX_BYTES);
 }
 export async function writeCursorignore(root, content) {
-    const target = path.join(root, ".cursorignore");
-    const dir = path.dirname(target);
-    await fs.mkdir(dir, { recursive: true });
-    const tmp = path.join(dir, `.cursorignore.agentdoctor.${process.pid}.tmp`);
-    await fs.writeFile(tmp, content, "utf8");
-    await fs.rename(tmp, target);
+    await atomicWriteTextFile(path.join(root, ".cursorignore"), content);
 }
 function formatSimpleDiff(fileLabel, before, after) {
     const beforeLines = before.length === 0 ? [] : before.split(/\r?\n/);

package/dist/core/path-resolution/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Path Resolution Engine — shared path reference preparation/resolution.
+ * Stage 1 exports preparation only; later stages extend this surface.
+ */
+export { isConcretePathReference, normalizePathReference, preparePathReference, type PathConcreteRejectReason, type PreparedPathReference, } from "./prepare.js";

package/dist/core/path-resolution/index.js

@@ -0,0 +1,5 @@
+/**
+ * Path Resolution Engine — shared path reference preparation/resolution.
+ * Stage 1 exports preparation only; later stages extend this surface.
+ */
+export { isConcretePathReference, normalizePathReference, preparePathReference, } from "./prepare.js";

package/dist/core/path-resolution/prepare.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Path Resolution Engine — Stage 1: prepare candidates for deterministic resolution.
+ *
+ * Shared infrastructure. Future stages add lattice resolution; Stage 1 only:
+ * - concrete-only filtering
+ * - URI decoding
+ * - path normalization
+ *
+ * No repository-specific or framework-specific logic.
+ */
+export type PathConcreteRejectReason = "empty" | "placeholder" | "ellipsis" | "home" | "git-ref" | "bundler-module-type" | "undecodable";
+export type PreparedPathReference = {
+    status: "concrete";
+    /** Raw reference as extracted from source text. */
+    original: string;
+    /** Decoded, separator-normalized form used for resolution/existence checks. */
+    normalized: string;
+} | {
+    status: "reject";
+    original: string;
+    reason: PathConcreteRejectReason;
+};
+/**
+ * Normalize a path reference for filesystem checks:
+ * URI-decode percent-encoding, unify separators to `/`.
+ * Does not decide concreteness.
+ */
+export declare function normalizePathReference(raw: string): string | null;
+/**
+ * Stage 1 entry point: filter non-concrete references and normalize survivors.
+ */
+export declare function preparePathReference(raw: string): PreparedPathReference;
+export declare function isConcretePathReference(raw: string): boolean;

package/dist/core/path-resolution/prepare.js

@@ -0,0 +1,98 @@
+/**
+ * Path Resolution Engine — Stage 1: prepare candidates for deterministic resolution.
+ *
+ * Shared infrastructure. Future stages add lattice resolution; Stage 1 only:
+ * - concrete-only filtering
+ * - URI decoding
+ * - path normalization
+ *
+ * No repository-specific or framework-specific logic.
+ */
+/** Angle-bracket or `{name}` template slots — intentional non-paths. */
+const PLACEHOLDER_TOKEN = /(?:<[^<>\s]+>|\{[A-Za-z_][A-Za-z0-9_]*\})/;
+/** Ellipsis segments used as documentation wildcards (`bases/base/...`). */
+const ELLIPSIS_SEGMENT = /(^|\/)\.\.\.(\/|$)/;
+/**
+ * Git-ref shaped tokens that appear in backticks but are not filesystem paths.
+ * Kept narrow: remote refs + conventional-commit branch prefixes.
+ * Does not treat `docs/` as a branch prefix (collides with documentation trees).
+ * Branch-like prefixes are ignored when the reference ends with a file extension.
+ */
+const REMOTE_REF_SHAPE = /^(?:origin|upstream|HEAD)\/[A-Za-z0-9._/-]+$/;
+const BRANCH_PREFIX_SHAPE = /^(?:feature|fix|chore|hotfix|release)\/[A-Za-z0-9._/-]+$/;
+const FILE_EXTENSION_SUFFIX = /\.[A-Za-z0-9]{1,16}$/;
+function looksLikeGitRef(normalized) {
+    if (REMOTE_REF_SHAPE.test(normalized)) {
+        return true;
+    }
+    if (!BRANCH_PREFIX_SHAPE.test(normalized)) {
+        return false;
+    }
+    // `fix/login.ts` is a path; `fix/bug-in-worker-threads` is a branch token
+    return !FILE_EXTENSION_SUFFIX.test(normalized);
+}
+/**
+ * Bundler module-type tokens (`asset/resource`, `javascript/auto`) — not paths.
+ * Generalized type/name pattern; no bundler product names.
+ */
+const BUNDLER_MODULE_TYPE = /^(?:asset|javascript|css|json|wasm|webassembly|runtime)\/[A-Za-z0-9_-]+$/;
+/**
+ * Normalize a path reference for filesystem checks:
+ * URI-decode percent-encoding, unify separators to `/`.
+ * Does not decide concreteness.
+ */
+export function normalizePathReference(raw) {
+    if (!raw) {
+        return null;
+    }
+    let decoded;
+    try {
+        decoded = decodeURIComponent(raw);
+    }
+    catch {
+        return null;
+    }
+    return decoded.replace(/\\/g, "/");
+}
+function concretenessRejectReason(normalized) {
+    if (!normalized) {
+        return "empty";
+    }
+    if (PLACEHOLDER_TOKEN.test(normalized)) {
+        return "placeholder";
+    }
+    if (ELLIPSIS_SEGMENT.test(normalized)) {
+        return "ellipsis";
+    }
+    if (normalized === "~" || normalized.startsWith("~/") || normalized.startsWith("~\\")) {
+        return "home";
+    }
+    if (looksLikeGitRef(normalized)) {
+        return "git-ref";
+    }
+    if (BUNDLER_MODULE_TYPE.test(normalized)) {
+        return "bundler-module-type";
+    }
+    return null;
+}
+/**
+ * Stage 1 entry point: filter non-concrete references and normalize survivors.
+ */
+export function preparePathReference(raw) {
+    const original = raw;
+    if (!original || !original.trim()) {
+        return { status: "reject", original, reason: "empty" };
+    }
+    const normalized = normalizePathReference(original.trim());
+    if (normalized === null) {
+        return { status: "reject", original, reason: "undecodable" };
+    }
+    const reason = concretenessRejectReason(normalized);
+    if (reason) {
+        return { status: "reject", original, reason };
+    }
+    return { status: "concrete", original, normalized };
+}
+export function isConcretePathReference(raw) {
+    return preparePathReference(raw).status === "concrete";
+}

package/dist/core/policy/evaluate.d.ts

@@ -0,0 +1,44 @@
+import type { Finding, ScanResult, Scores, Severity } from "../../types/index.js";
+export type PolicyViolationCode = "minimum-score" | "fail-on-severity" | "fail-on-rule" | "fail-on-new";
+export interface PolicyOptions {
+    /** Fail when overall score is strictly below this value (0–100). */
+    minimumScore?: number;
+    /** Fail when any finding has this severity or higher. */
+    failOnSeverity?: Severity;
+    /** Fail when any finding matches one of these rule IDs. */
+    failOnRules?: string[];
+    /** Fail when verify reports new findings not present in the baseline. */
+    failOnNew?: boolean;
+}
+export interface PolicyViolation {
+    code: PolicyViolationCode;
+    message: string;
+    /** Rule IDs or finding IDs related to this violation, when applicable. */
+    details?: string[];
+}
+export interface PolicyInput {
+    findings: Finding[];
+    scores: Scores | null;
+    /** Count of new findings from verify; omit for scan-only. */
+    newFindingCount?: number;
+    /** When limited, --min-score cannot be treated as agent-readiness enforcement. */
+    agentSecurityAnalysis?: "full" | "limited";
+}
+export declare function severityRank(severity: Severity): number;
+export declare function parseSeverityGate(value: string): Severity;
+export declare function parseFailOnRules(value: string): string[];
+/**
+ * Evaluate CI / Action policy against scan or verify results.
+ * Deterministic: same input → same violations in stable order.
+ */
+export declare function evaluatePolicy(input: PolicyInput, options: PolicyOptions): PolicyViolation[];
+export declare function evaluateScanPolicy(result: ScanResult, options: PolicyOptions): PolicyViolation[];
+export declare function evaluateVerifyPolicy(result: {
+    findings?: Finding[];
+    after: ScanResult;
+    scores: Scores | null;
+    summary: {
+        new: number;
+    };
+    newFindings?: Finding[];
+}, options: PolicyOptions): PolicyViolation[];

package/dist/core/policy/evaluate.js

@@ -0,0 +1,120 @@
+import { InvalidArgumentError } from "commander";
+const SEVERITY_RANK = {
+    critical: 3,
+    warning: 2,
+    info: 1,
+};
+export function severityRank(severity) {
+    return SEVERITY_RANK[severity];
+}
+export function parseSeverityGate(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "critical" || normalized === "warning" || normalized === "info") {
+        return normalized;
+    }
+    throw new InvalidArgumentError(`--fail-on-severity must be critical, warning, or info (got "${value}")`);
+}
+export function parseFailOnRules(value) {
+    return value
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+}
+/**
+ * Evaluate CI / Action policy against scan or verify results.
+ * Deterministic: same input → same violations in stable order.
+ */
+export function evaluatePolicy(input, options) {
+    const violations = [];
+    if (options.minimumScore !== undefined) {
+        if (input.agentSecurityAnalysis === "limited") {
+            violations.push({
+                code: "minimum-score",
+                message: `CI check failed: no supported coding-agent configuration detected; cannot enforce --min-score ${options.minimumScore}`,
+            });
+        }
+        else if (input.scores === null) {
+            violations.push({
+                code: "minimum-score",
+                message: `CI check failed: readiness scores unavailable; cannot enforce --min-score ${options.minimumScore}`,
+            });
+        }
+        else if (input.scores.overall < options.minimumScore) {
+            violations.push({
+                code: "minimum-score",
+                message: `CI check failed: overall score ${input.scores.overall} is below --min-score ${options.minimumScore}`,
+            });
+        }
+    }
+    if (options.failOnSeverity !== undefined) {
+        const threshold = severityRank(options.failOnSeverity);
+        const matched = input.findings.filter((f) => severityRank(f.severity) >= threshold);
+        if (matched.length > 0) {
+            const bySeverity = countBySeverity(matched);
+            violations.push({
+                code: "fail-on-severity",
+                message: `CI check failed: ${matched.length} finding(s) at or above ${options.failOnSeverity} (${formatSeverityCounts(bySeverity)})`,
+                details: [...new Set(matched.map((f) => f.ruleId))].sort(),
+            });
+        }
+    }
+    if (options.failOnRules && options.failOnRules.length > 0) {
+        const wanted = new Set(options.failOnRules);
+        const matched = input.findings.filter((f) => wanted.has(f.ruleId));
+        if (matched.length > 0) {
+            const rules = [...new Set(matched.map((f) => f.ruleId))].sort();
+            violations.push({
+                code: "fail-on-rule",
+                message: `CI check failed: ${matched.length} finding(s) match fail-on-rule (${rules.join(", ")})`,
+                details: rules,
+            });
+        }
+    }
+    if (options.failOnNew === true) {
+        const newCount = input.newFindingCount ?? 0;
+        if (newCount > 0) {
+            violations.push({
+                code: "fail-on-new",
+                message: `CI check failed: verify found ${newCount} new finding(s) not present in the baseline`,
+            });
+        }
+    }
+    return violations;
+}
+export function evaluateScanPolicy(result, options) {
+    const { failOnNew: _ignored, ...scanOptions } = options;
+    return evaluatePolicy({
+        findings: result.findings,
+        scores: result.scores,
+        agentSecurityAnalysis: result.agentSecurityAnalysis,
+    }, scanOptions);
+}
+export function evaluateVerifyPolicy(result, options) {
+    const findings = result.after.findings;
+    return evaluatePolicy({
+        findings,
+        scores: result.scores,
+        newFindingCount: result.summary.new,
+        agentSecurityAnalysis: result.after.agentSecurityAnalysis,
+    }, options);
+}
+function countBySeverity(findings) {
+    const counts = { critical: 0, warning: 0, info: 0 };
+    for (const finding of findings) {
+        counts[finding.severity] += 1;
+    }
+    return counts;
+}
+function formatSeverityCounts(counts) {
+    const parts = [];
+    if (counts.critical > 0) {
+        parts.push(`${counts.critical} critical`);
+    }
+    if (counts.warning > 0) {
+        parts.push(`${counts.warning} warning`);
+    }
+    if (counts.info > 0) {
+        parts.push(`${counts.info} info`);
+    }
+    return parts.join(", ");
+}

package/dist/core/rules/claude-deny.d.ts

@@ -0,0 +1,8 @@
+import type { RuleContext } from "./types.js";
+/**
+ * Claude Code Read deny rule for a repository-relative path.
+ * Directories use a recursive Read(./path/**) form.
+ */
+export declare function claudeReadDenyRule(relativePath: string, kind?: "file" | "directory"): string;
+export declare function settingsTextDeniesPath(settingsText: string, relativePath: string): boolean;
+export declare function claudeDeniesPath(context: RuleContext, relativePath: string): Promise<boolean>;