@praneeth_54/agentdoctor 0.1.1-beta → 0.1.3-beta

package/CHANGELOG.md

@@ -13,6 +13,51 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Safe automatic fixes
 - Packaged GitHub Action
 
+## [0.1.3-beta] — 2026-07-29
+
+Backward-compatible security-signal and detection-quality patch.
+
+### Security
+
+- Repositories without supported agent configuration no longer receive an unqualified clean result when relevant repository-risk findings exist
+- Agent exposure and repository risk remain semantically distinct (`affectedAgents` is empty when exposure is not asserted)
+- Additive `agentSecurityAnalysis` field: `full` | `limited`
+- Environment templates (`.env.example`, `.env.sample`, `.env.template`, `.env.dist`) receive informational treatment
+- Common environment backup filenames (`.env_backup`, `.env_old`, `.env_local`) receive conservative warning treatment
+
+### Detection
+
+- Prevent false Django detection from arbitrary nested `settings.py` files
+- Detect nested FastAPI projects using dependency + `app/main.py` structure evidence
+- Detect React from nested project manifests
+- Prevent Poetry detection from generic non-Poetry `pyproject.toml` files (for example hatchling)
+- Improve multi-stack terminal summaries for multi-project repositories
+
+### Testing
+
+- Added Excepta FastAPI/React/Flutter and security-semantics fixtures/tests
+- Total test suite is now 122 tests
+- Three real-world regression families validated (ProxyShield, Flutter/Laravel multi-app, Excepta)
+
+## [0.1.2-beta] — 2026-07-29
+
+Backward-compatible quality patch.
+
+### Fixed
+
+- More reliable CLI/package binary execution (local bin shim + executable CLI entry)
+- Nested `context/generated-directory` ignore handling and precise evidence paths
+- Multi-project repository detection without requiring Node workspace tooling
+- Mixed Composer / Pub / npm package-manager detection
+- False malformed-package diagnostic when root `package.json` is absent
+- Conservative credential-file detection for `.der` and service-account JSON names
+- Quieter permission diagnostics under already-skipped directories
+
+### Testing
+
+- Added real-world multi-app, generated-directory, credential, and CLI bin fixtures/tests
+- Total test suite is now 104 tests
+
 ## [0.1.1-beta] — 2026-07-29
 
 Patch release.
@@ -62,6 +107,8 @@ First public beta.
 - Not a complete secret scanner
 - Git “tracked secret” detection deferred
 
-[Unreleased]: https://github.com/pranee54/AgentDoctor/compare/v0.1.1-beta...HEAD
+[Unreleased]: https://github.com/pranee54/AgentDoctor/compare/v0.1.3-beta...HEAD
+[0.1.3-beta]: https://github.com/pranee54/AgentDoctor/releases/tag/v0.1.3-beta
+[0.1.2-beta]: https://github.com/pranee54/AgentDoctor/releases/tag/v0.1.2-beta
 [0.1.1-beta]: https://github.com/pranee54/AgentDoctor/releases/tag/v0.1.1-beta
 [0.1.0-beta]: https://github.com/pranee54/AgentDoctor/releases/tag/v0.1.0-beta

package/README.md

@@ -5,7 +5,7 @@
 [![GitHub Stars](https://img.shields.io/github/stars/pranee54/AgentDoctor)](https://github.com/pranee54/AgentDoctor/stargazers)
 [![CI](https://img.shields.io/github/actions/workflow/status/pranee54/AgentDoctor/ci.yml?branch=main&label=CI)](https://github.com/pranee54/AgentDoctor/actions)
 [![Node](https://img.shields.io/node/v/@praneeth_54/agentdoctor)](https://nodejs.org)
-[![Release](https://img.shields.io/badge/release-v0.1.1--beta-orange)](CHANGELOG.md)
+[![Release](https://img.shields.io/badge/release-v0.1.2--beta-orange)](CHANGELOG.md)
 
 **Lighthouse for AI coding agents.**
 
@@ -29,7 +29,7 @@ npx @praneeth_54/agentdoctor
 ```text
 $ npx @praneeth_54/agentdoctor
 
-AgentDoctor v0.1.1-beta
+AgentDoctor v0.1.3-beta
 
 Repository
   Framework: Next.js
@@ -88,13 +88,13 @@ AgentDoctor analyzes configuration files. It does not run agents or edit your pr
 ### One-shot
 
 ```bash
-npx @praneeth_54/agentdoctor@0.1.1-beta
+npx @praneeth_54/agentdoctor@0.1.3-beta
 ```
 
 ### Global (optional)
 
 ```bash
-npm install -g @praneeth_54/agentdoctor@0.1.1-beta
+npm install -g @praneeth_54/agentdoctor@0.1.3-beta
 agentdoctor
 ```
 
@@ -225,7 +225,7 @@ npx @praneeth_54/agentdoctor --json
 
 ```json
 {
-  "version": "0.1.1-beta",
+  "version": "0.1.3-beta",
   "repository": {
     "primaryFramework": "nextjs",
     "primaryLanguage": "typescript",

package/dist/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const PACKAGE_VERSION = "0.1.1-beta";
+export declare const PACKAGE_VERSION = "0.1.3-beta";
 export declare const DEFAULT_MAX_FILE_SIZE_BYTES: number;
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export declare const DEFAULT_IGNORE_DIRECTORIES: Set<string>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const PACKAGE_VERSION = "0.1.1-beta";
+export const PACKAGE_VERSION = "0.1.3-beta";
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024; // 2 MiB
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export const DEFAULT_IGNORE_DIRECTORIES = new Set([

package/dist/core/rules/build-context.js

@@ -1,13 +1,44 @@
 import { parseProjectMcpConfigs } from "../mcp/parse.js";
-import { createIgnoreIndex, parseIgnoreFile } from "./ignore.js";
+import { createIgnoreIndex, parseIgnoreFile, relativizeIgnorePatterns } from "./ignore.js";
 import { TextCache } from "./text-cache.js";
 export async function buildRuleContext(options) {
     const textCache = new TextCache(options.root, options.maxFileSizeBytes);
-    const gitignore = await textCache.read(".gitignore");
-    const cursorignore = await textCache.read(".cursorignore");
+    const gitignorePatterns = [];
+    const cursorignorePatterns = [];
+    const rootGitignore = await textCache.read(".gitignore");
+    if (rootGitignore.text) {
+        gitignorePatterns.push(...parseIgnoreFile(rootGitignore.text));
+    }
+    const rootCursorignore = await textCache.read(".cursorignore");
+    if (rootCursorignore.text) {
+        cursorignorePatterns.push(...parseIgnoreFile(rootCursorignore.text));
+    }
+    for (const file of options.discovery.files) {
+        const base = file.relativePath.split("/").pop() ?? file.relativePath;
+        if (base !== ".gitignore" && base !== ".cursorignore") {
+            continue;
+        }
+        if (file.relativePath === ".gitignore" || file.relativePath === ".cursorignore") {
+            continue;
+        }
+        const cached = await textCache.read(file.relativePath);
+        if (!cached.text) {
+            continue;
+        }
+        const dir = file.relativePath.includes("/")
+            ? file.relativePath.slice(0, file.relativePath.lastIndexOf("/"))
+            : "";
+        const patterns = relativizeIgnorePatterns(dir, parseIgnoreFile(cached.text));
+        if (base === ".gitignore") {
+            gitignorePatterns.push(...patterns);
+        }
+        else {
+            cursorignorePatterns.push(...patterns);
+        }
+    }
     const ignore = createIgnoreIndex({
-        gitignorePatterns: gitignore.text ? parseIgnoreFile(gitignore.text) : [],
-        cursorignorePatterns: cursorignore.text ? parseIgnoreFile(cursorignore.text) : [],
+        gitignorePatterns,
+        cursorignorePatterns,
     });
     const mcp = await parseProjectMcpConfigs(options.root, options.maxFileSizeBytes);
     const instructionPaths = new Set();

package/dist/core/rules/context/generated-directory.js

@@ -9,6 +9,13 @@ const GENERATED = [
     { name: ".dart_tool", label: "Dart tooling cache" },
     { name: "target", label: "Rust/Java build output" },
 ];
+function isGeneratedPath(relativePath, name) {
+    return relativePath === name || relativePath.endsWith(`/${name}`);
+}
+function isExcluded(context, relativePath) {
+    const variants = [relativePath, `${relativePath}/`];
+    return variants.some((candidate) => context.ignore.matchesGitignore(candidate) || context.ignore.matchesCursorignore(candidate));
+}
 export const generatedDirectoryRule = {
     id: "context/generated-directory",
     title: "Generated directory may enter agent context",
@@ -20,66 +27,49 @@ export const generatedDirectoryRule = {
     recommendation: "Ensure generated directories are listed in .gitignore and agent ignore configuration where applicable.",
     async check(context) {
         const findings = [];
-        const skipped = new Set(context.discovery.directoriesSkipped.map((d) => d.split("/")[0] ?? d));
-        // directoriesSkipped stores relative paths like "dist" or "packages/app/dist"
-        const present = new Set();
-        for (const dir of context.discovery.directoriesSkipped) {
-            const top = dir.split("/")[0] ?? dir;
-            present.add(top);
-            present.add(dir);
-        }
-        void skipped;
         const affected = context.agents.filter((a) => a.configured || a.detected).map((a) => a.id);
         if (affected.length === 0) {
             return [];
         }
         for (const entry of GENERATED) {
-            const found = present.has(entry.name) ||
-                [...present].some((p) => p === entry.name || p.endsWith(`/${entry.name}`));
-            if (!found) {
-                continue;
-            }
-            // If .gitignore or .cursorignore already exclude it, skip (already appropriately excluded)
-            const samplePath = `${entry.name}/`;
-            const excluded = context.ignore.matchesGitignore(samplePath) ||
-                context.ignore.matchesGitignore(entry.name) ||
-                context.ignore.matchesCursorignore(samplePath) ||
-                context.ignore.matchesCursorignore(entry.name);
-            if (excluded) {
-                continue;
+            const matches = context.discovery.directoriesSkipped.filter((dir) => isGeneratedPath(dir, entry.name));
+            for (const relativePath of matches) {
+                if (isExcluded(context, relativePath)) {
+                    continue;
+                }
+                findings.push({
+                    ruleId: "context/generated-directory",
+                    category: "context",
+                    severity: "info",
+                    title: "Generated directory may enter agent context",
+                    message: `${relativePath}/ (${entry.label}) is present and no project ignore pattern was detected`,
+                    whyItMatters: "Generated directories are usually low-value for coding agents and can bloat indexing/context when not excluded.",
+                    recommendation: `Add an ignore pattern covering ${relativePath}/ to .gitignore and, for Cursor, .cursorignore if you need agent-specific exclusion beyond gitignore.`,
+                    affectedAgents: affected,
+                    evidence: { path: relativePath },
+                    fixability: "safe",
+                });
             }
-            // Discovery already skips these dirs by default — absence from ignore files is still useful info
-            // when agents are configured. Keep severity info.
-            findings.push({
-                ruleId: "context/generated-directory",
-                category: "context",
-                severity: "info",
-                title: "Generated directory may enter agent context",
-                message: `${entry.name}/ (${entry.label}) is present and no project ignore pattern was detected`,
-                whyItMatters: "Generated directories are usually low-value for coding agents and can bloat indexing/context when not excluded.",
-                recommendation: `Add ${entry.name}/ to .gitignore and, for Cursor, .cursorignore if you need agent-specific exclusion beyond gitignore.`,
-                affectedAgents: affected,
-                evidence: { path: entry.name },
-                fixability: "safe",
-            });
         }
-        // vendor/ — only flag for non-PHP/Composer ecosystems
-        if ((present.has("vendor") ||
-            [...present].some((p) => p === "vendor" || p.endsWith("/vendor"))) &&
+        const vendorPaths = context.discovery.directoriesSkipped.filter((dir) => isGeneratedPath(dir, "vendor"));
+        if (vendorPaths.length > 0 &&
             context.repository.primaryPackageManager !== "composer" &&
+            !context.repository.packageManagers.includes("composer") &&
             context.repository.primaryLanguage !== "php") {
-            const excluded = context.ignore.matchesGitignore("vendor/") || context.ignore.matchesCursorignore("vendor/");
-            if (!excluded) {
+            for (const relativePath of vendorPaths) {
+                if (isExcluded(context, relativePath)) {
+                    continue;
+                }
                 findings.push({
                     ruleId: "context/generated-directory",
                     category: "context",
                     severity: "info",
                     title: "Generated directory may enter agent context",
-                    message: "vendor/ is present outside a PHP/Composer project and no ignore pattern was detected",
+                    message: `${relativePath}/ is present outside a PHP/Composer project and no ignore pattern was detected`,
                     whyItMatters: "In non-PHP projects, vendor/ is often third-party or generated content that adds noise to agent context.",
                     recommendation: "Confirm whether vendor/ should be ignored for git and AI tooling.",
                     affectedAgents: affected,
-                    evidence: { path: "vendor" },
+                    evidence: { path: relativePath },
                     fixability: "safe",
                 });
             }

package/dist/core/rules/ignore.d.ts

@@ -11,6 +11,11 @@ export interface IgnoreIndex {
     isExcludedForCursor(relativePath: string): boolean;
 }
 export declare function parseIgnoreFile(content: string): string[];
+/**
+ * Rewrite patterns from a nested ignore file so they apply relative to repository root.
+ * `baseDir` is the directory containing the ignore file (POSIX, no trailing slash), or "".
+ */
+export declare function relativizeIgnorePatterns(baseDir: string, patterns: string[]): string[];
 /**
  * Match a relative POSIX path against a single gitignore-like pattern.
  * Negation (`!`) is not fully supported for re-inclusion of parent-excluded paths.

package/dist/core/rules/ignore.js

@@ -15,6 +15,30 @@ export function parseIgnoreFile(content) {
         .map(normalizePattern)
         .filter((p) => p !== null);
 }
+/**
+ * Rewrite patterns from a nested ignore file so they apply relative to repository root.
+ * `baseDir` is the directory containing the ignore file (POSIX, no trailing slash), or "".
+ */
+export function relativizeIgnorePatterns(baseDir, patterns) {
+    if (!baseDir || baseDir === ".") {
+        return patterns;
+    }
+    return patterns.map((pattern) => {
+        const negated = pattern.startsWith("!");
+        const body = negated ? pattern.slice(1) : pattern;
+        let rewritten;
+        if (body.startsWith("/")) {
+            rewritten = `${baseDir}${body}`;
+        }
+        else if (body.startsWith("**/")) {
+            rewritten = `${baseDir}/${body.slice(3)}`;
+        }
+        else {
+            rewritten = `${baseDir}/${body}`;
+        }
+        return negated ? `!${rewritten}` : rewritten;
+    });
+}
 /**
  * Match a relative POSIX path against a single gitignore-like pattern.
  * Negation (`!`) is not fully supported for re-inclusion of parent-excluded paths.
@@ -24,25 +48,44 @@ export function matchIgnorePattern(relativePath, pattern) {
     if (pat.startsWith("!")) {
         pat = pat.slice(1);
     }
-    const pathNorm = relativePath.replace(/^\/+/, "");
+    const pathNorm = relativePath.replace(/^\/+/, "").replace(/\/+$/, "");
     let matched = false;
     if (pat.endsWith("/")) {
         const dir = pat.slice(0, -1);
-        matched =
-            pathNorm === dir ||
-                pathNorm.startsWith(`${dir}/`) ||
-                globMatch(pathNorm, dir) ||
-                pathNorm.split("/").some((_, i, parts) => globMatch(parts.slice(0, i + 1).join("/"), dir));
+        if (!dir.includes("/")) {
+            // `build/` matches build at any directory level (gitignore semantics)
+            matched =
+                pathNorm === dir ||
+                    pathNorm.endsWith(`/${dir}`) ||
+                    pathNorm.split("/").includes(dir) ||
+                    globMatch(pathNorm, `**/${dir}`) ||
+                    globMatch(pathNorm, `**/${dir}/**`);
+        }
+        else {
+            matched =
+                pathNorm === dir ||
+                    pathNorm.startsWith(`${dir}/`) ||
+                    globMatch(pathNorm, dir) ||
+                    globMatch(pathNorm, `${dir}/**`);
+        }
     }
     else if (pat.startsWith("/")) {
         matched = globMatch(pathNorm, pat.slice(1));
     }
     else if (pat.includes("/")) {
-        matched = globMatch(pathNorm, pat) || pathNorm.endsWith(`/${pat}`);
+        matched =
+            globMatch(pathNorm, pat) ||
+                globMatch(pathNorm, `${pat}/**`) ||
+                pathNorm.endsWith(`/${pat}`) ||
+                pathNorm.startsWith(`${pat}/`);
     }
     else {
         const base = pathNorm.split("/").pop() ?? pathNorm;
-        matched = globMatch(base, pat) || globMatch(pathNorm, pat) || globMatch(pathNorm, `**/${pat}`);
+        matched =
+            globMatch(base, pat) ||
+                globMatch(pathNorm, pat) ||
+                globMatch(pathNorm, `**/${pat}`) ||
+                pathNorm.split("/").includes(pat);
     }
     return matched;
 }
@@ -90,7 +133,6 @@ export function createIgnoreIndex(options) {
             if (pathMatchesAny(relativePath, gitignorePatterns)) {
                 return true;
             }
-            // Documented default ignore list includes .env*
             return pathMatchesAny(relativePath, CURSOR_DEFAULT_ENV_PATTERNS);
         },
     };

package/dist/core/rules/security/env-file-exposure.d.ts

@@ -1,2 +1,8 @@
 import type { RuleDefinition } from "../types.js";
+export type EnvFileKind = "runtime" | "template" | "backup";
+/**
+ * Classify environment-like filenames. Precision over recall.
+ * Does not inspect file contents.
+ */
+export declare function classifyEnvBasename(base: string): EnvFileKind | null;
 export declare const envFileExposureRule: RuleDefinition;

package/dist/core/rules/security/env-file-exposure.js

@@ -1,7 +1,36 @@
-const ENV_BASENAME = /^\.env(\..+)?$/i;
+const TEMPLATE_BASENAMES = new Set([".env.example", ".env.sample", ".env.template", ".env.dist"]);
+const BACKUP_BASENAMES = new Set([".env_backup", ".env_old", ".env_local"]);
+/**
+ * Classify environment-like filenames. Precision over recall.
+ * Does not inspect file contents.
+ */
+export function classifyEnvBasename(base) {
+    const normalized = base.trim();
+    if (!normalized.toLowerCase().startsWith(".env")) {
+        return null;
+    }
+    const lower = normalized.toLowerCase();
+    if (TEMPLATE_BASENAMES.has(lower)) {
+        return "template";
+    }
+    if (BACKUP_BASENAMES.has(lower)) {
+        return "backup";
+    }
+    if (lower === ".env") {
+        return "runtime";
+    }
+    // .env.<name> but not templates above
+    if (/^\.env\.[A-Za-z0-9_.-]+$/.test(normalized)) {
+        return "runtime";
+    }
+    return null;
+}
 function isEnvFile(relativePath) {
     const base = relativePath.split("/").pop() ?? relativePath;
-    return ENV_BASENAME.test(base);
+    return classifyEnvBasename(base);
+}
+function hasConfiguredOrDetectedAgents(context) {
+    return context.agents.some((a) => a.detected || a.configured);
 }
 function agentsWithoutClearExclusion(context, relativePath) {
     const affected = [];
@@ -50,16 +79,53 @@ async function claudeDeniesRead(context, relativePath) {
 export const envFileExposureRule = {
     id: "security/env-file-exposure",
     title: "Sensitive environment file may enter agent context",
-    description: "Detects repository .env files when configured AI agents may be able to access them.",
+    description: "Detects repository .env files as repository risk and, when agents are configured, possible agent context exposure.",
     category: "security",
     severity: "critical",
     fixability: "review",
-    rationale: "Environment files often contain credentials. If an AI coding agent can read them, secrets may enter model context.",
-    recommendation: "Exclude the file from AI agent context (for example .cursorignore / Claude Code Read deny rules) and ensure it is not committed.",
+    rationale: "Environment files often contain credentials. Repository presence is a risk; agent readability can add exposure.",
+    recommendation: "Keep runtime .env files out of version control, exclude them from AI agent context, and rotate credentials if exposed.",
     async check(context) {
         const findings = [];
-        const candidates = context.discovery.files.filter((f) => isEnvFile(f.relativePath));
-        for (const file of candidates) {
+        const agentsPresent = hasConfiguredOrDetectedAgents(context);
+        for (const file of context.discovery.files) {
+            const kind = isEnvFile(file.relativePath);
+            if (!kind) {
+                continue;
+            }
+            if (kind === "template") {
+                findings.push({
+                    ruleId: "security/env-file-exposure",
+                    category: "security",
+                    severity: "info",
+                    title: "Environment template file present",
+                    message: `Environment template file detected at ${file.relativePath}`,
+                    whyItMatters: "Template env files are usually placeholders, but they can still document secret names. Filename classification only — contents were not inspected.",
+                    recommendation: "Keep templates free of real credentials. Prefer documenting variable names without values.",
+                    affectedAgents: [],
+                    evidence: { path: file.relativePath, detail: "template" },
+                    fixability: "review",
+                });
+                continue;
+            }
+            if (!agentsPresent) {
+                findings.push({
+                    ruleId: "security/env-file-exposure",
+                    category: "security",
+                    severity: kind === "backup" ? "warning" : "critical",
+                    title: "Sensitive environment file present in repository",
+                    message: `Sensitive environment file present in the repository: ${file.relativePath}`,
+                    whyItMatters: "No supported coding-agent configuration was detected, so agent-specific exposure was not asserted. The file is still high-risk repository material if tracked or shared.",
+                    recommendation: "Keep runtime environment files out of version control and rotate credentials if the file may have been shared.",
+                    affectedAgents: [],
+                    evidence: {
+                        path: file.relativePath,
+                        detail: kind === "backup" ? "backup-no-agent" : "runtime-no-agent",
+                    },
+                    fixability: "review",
+                });
+                continue;
+            }
             let affected = agentsWithoutClearExclusion(context, file.relativePath);
             if (affected.includes("claude-code")) {
                 if (await claudeDeniesRead(context, file.relativePath)) {
@@ -72,13 +138,16 @@ export const envFileExposureRule = {
             findings.push({
                 ruleId: "security/env-file-exposure",
                 category: "security",
-                severity: "critical",
+                severity: kind === "backup" ? "warning" : "critical",
                 title: "Sensitive environment file may enter agent context",
                 message: `Sensitive environment file detected and no relevant exclusion was found for: ${file.relativePath}`,
                 whyItMatters: "Environment files frequently hold API keys and credentials. If readable by an AI coding agent, those values may be included in prompts or logs.",
                 recommendation: "Add an agent-specific exclusion (for example .cursorignore or a Claude Code Read deny rule), keep the file out of version control, and rotate any credentials that may have been exposed.",
                 affectedAgents: affected,
-                evidence: { path: file.relativePath },
+                evidence: {
+                    path: file.relativePath,
+                    detail: kind === "backup" ? "backup" : "runtime",
+                },
                 fixability: "review",
             });
         }

package/dist/core/rules/security/private-key-file.js

@@ -6,10 +6,14 @@ const PRIVATE_KEY_PATTERNS = [
         test: (b) => /\.pem$/i.test(b) && !/cert|certificate|public|ca-bundle/i.test(b),
         label: "PEM private key",
     },
+    {
+        test: (b) => /\.der$/i.test(b) && !/cert|certificate|public|ca-bundle/i.test(b),
+        label: "DER-encoded key or credential material",
+    },
     { test: (b) => /\.p12$/i.test(b), label: "PKCS#12 credential bundle" },
     { test: (b) => /\.pfx$/i.test(b), label: "PKCS#12 credential bundle" },
     { test: (b) => /^credentials\.json$/i.test(b), label: "credentials file" },
-    { test: (b) => /service-account.*\.json$/i.test(b), label: "service account key" },
+    { test: (b) => /service[-_]?account.*\.json$/i.test(b), label: "service account key" },
     {
         test: (b) => /\.key$/i.test(b) && !/public|pub/i.test(b),
         label: "private key file",
@@ -35,22 +39,24 @@ export const privateKeyFileRule = {
     async check(context) {
         const findings = [];
         const affected = context.agents.filter((a) => a.detected || a.configured).map((a) => a.id);
-        const agents = affected.length > 0 ? affected : ["cursor", "claude-code", "codex"];
         for (const file of context.discovery.files) {
             const base = file.relativePath.split("/").pop() ?? file.relativePath;
             const label = classify(base);
             if (!label) {
                 continue;
             }
+            const agentsPresent = affected.length > 0;
             findings.push({
                 ruleId: "security/private-key-file",
                 category: "security",
                 severity: "critical",
                 title: "Private key or credential file present in repository",
                 message: `Possible ${label} detected at ${file.relativePath}`,
-                whyItMatters: "Credential material in the working tree can be read by AI coding agents and may leak into model context or logs. Filename heuristics only — contents were not inspected.",
+                whyItMatters: agentsPresent
+                    ? "Credential material in the working tree can be read by AI coding agents and may leak into model context or logs. Filename heuristics only — contents were not inspected."
+                    : "Credential material in the working tree is high-risk repository content. No supported coding-agent configuration was detected, so agent-specific exposure was not asserted. Filename heuristics only — contents were not inspected.",
                 recommendation: "Remove the file from the repository, rotate the credential, add ignore rules, and never commit replacements.",
-                affectedAgents: [...agents],
+                affectedAgents: affected,
                 evidence: { path: file.relativePath, detail: label },
                 fixability: "manual",
             });

package/dist/core/scanner/scan.js

@@ -46,6 +46,11 @@ export async function scan(options = {}) {
     for (const error of ruleErrors) {
         warnings.push(sanitizeTerminalText(error));
     }
+    const agentsPresent = agents.some((a) => a.detected || a.configured);
+    const agentSecurityAnalysis = agentsPresent ? "full" : "limited";
+    if (agentSecurityAnalysis === "limited") {
+        warnings.push("No supported coding-agent configuration detected; agent-specific security exposure checks are limited.");
+    }
     return {
         version: PACKAGE_VERSION,
         repository,
@@ -54,6 +59,7 @@ export async function scan(options = {}) {
         summary,
         scores: null,
         scoringAvailable: false,
+        agentSecurityAnalysis,
         timing: {
             discoveryMs: discovery.elapsedMs,
             detectionMs,

package/dist/detectors/framework.d.ts

@@ -3,6 +3,8 @@ export interface FrameworkDetectionInput {
     relativePaths: string[];
     packageJsonDependencies?: Record<string, string>;
     composerJsonRequire?: Record<string, string>;
+    /** Lowercase dependency/package names discovered from Python manifests. */
+    pythonDependencyNames?: string[];
     pubspecName?: string;
 }
 export interface FrameworkDetectionResult {
@@ -15,3 +17,4 @@ export interface FrameworkDetectionResult {
  */
 export declare function detectFrameworks(input: FrameworkDetectionInput): FrameworkDetectionResult;
 export declare function formatFramework(framework: FrameworkId): string;
+export declare function formatFrameworks(ids: FrameworkId[]): string;