@safetnsr/vet 0.6.0 → 1.1.0

package/dist/checks/map.d.ts

@@ -0,0 +1,25 @@
+import type { CheckResult } from '../types.js';
+export declare const AGENT_CONFIG_FILES: string[];
+export declare function parseAgentConfigs(cwd: string): string[];
+export declare function extractRefs(content: string, cwd: string): string[];
+export type VisibilityTier = 'config' | 'visible' | 'invisible';
+export interface ClassifiedFile {
+    path: string;
+    tier: VisibilityTier;
+}
+export declare function classifyFiles(cwd: string, configPaths: string[], refs: string[]): ClassifiedFile[];
+export interface MapResult {
+    config: string[];
+    visible: string[];
+    invisible: string[];
+    stats: {
+        total: number;
+        visible_pct: number;
+    };
+}
+export declare function checkMap(cwd: string): Promise<CheckResult & {
+    mapData: MapResult;
+}>;
+export declare function renderMapReport(result: CheckResult & {
+    mapData: MapResult;
+}, asJson: boolean): string;

package/dist/checks/map.js

@@ -0,0 +1,256 @@
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { walkFiles, readFile, c } from '../util.js';
+// ── Agent config filenames to discover ───────────────────────────────────────
+export const AGENT_CONFIG_FILES = [
+    'CLAUDE.md',
+    'AGENTS.md',
+    '.cursorrules',
+    'codex.md',
+    '.github/copilot-instructions.md',
+    'cursor.json',
+    '.cursor/rules',
+    'copilot-instructions.md',
+];
+// ── Parse all agent config files present in cwd ──────────────────────────────
+export function parseAgentConfigs(cwd) {
+    const found = [];
+    for (const name of AGENT_CONFIG_FILES) {
+        const full = join(cwd, name);
+        if (existsSync(full)) {
+            found.push(name);
+        }
+    }
+    return found;
+}
+// ── Extract file/dir references from config file content ─────────────────────
+export function extractRefs(content, cwd) {
+    const refs = new Set();
+    // Patterns to extract:
+    // 1. Backtick paths: `path/to/file.ts` or `./path`
+    const backtickPat = /`([^`\s]+)`/g;
+    // 2. Inline code in markdown: single-line code with path-like content
+    const codePat = /`([./][^`\s]+)`/g;
+    // 3. Explicit path patterns in text: word/word or ./word or ~/word
+    const pathPat = /(?:^|\s)((?:\.\/|\.\.\/|~\/)?(?:[a-zA-Z0-9_-]+\/)+[a-zA-Z0-9_.-]*[a-zA-Z0-9_-])/gm;
+    // 4. Absolute paths starting with /
+    const absPat = /(?:^|\s)(\/(?:[a-zA-Z0-9_.-]+\/)*[a-zA-Z0-9_.-]+)/gm;
+    const extractFromPattern = (pat) => {
+        let match;
+        pat.lastIndex = 0;
+        while ((match = pat.exec(content)) !== null) {
+            const raw = match[1].trim();
+            // Skip URLs
+            if (raw.startsWith('http://') || raw.startsWith('https://') || raw.includes('://'))
+                continue;
+            // Skip if looks like a domain
+            if (/^[a-z]+\.[a-z]{2,}/.test(raw) && !raw.includes('/'))
+                continue;
+            refs.add(raw);
+        }
+    };
+    extractFromPattern(backtickPat);
+    extractFromPattern(codePat);
+    extractFromPattern(pathPat);
+    extractFromPattern(absPat);
+    // Filter to only refs that actually exist on disk (relative to cwd)
+    const resolved = [];
+    for (const ref of refs) {
+        let resolvedPath;
+        if (ref.startsWith('/')) {
+            resolvedPath = ref;
+        }
+        else if (ref.startsWith('~/')) {
+            resolvedPath = join(process.env.HOME || '/root', ref.slice(2));
+        }
+        else {
+            resolvedPath = join(cwd, ref);
+        }
+        if (existsSync(resolvedPath)) {
+            // Store as relative to cwd
+            const rel = ref.startsWith('/') ? ref : ref;
+            resolved.push(rel.replace(/^\.\//, ''));
+        }
+    }
+    return [...new Set(resolved)];
+}
+// ── Classify all codebase files ───────────────────────────────────────────────
+export function classifyFiles(cwd, configPaths, refs) {
+    const allFiles = walkFiles(cwd);
+    const configSet = new Set(configPaths);
+    // Build a set of ref prefixes for directory matching
+    const refSet = new Set(refs);
+    // Also include files whose parent directory is referenced
+    function isReferencedByRef(file) {
+        if (refSet.has(file))
+            return true;
+        // Check if any ref is a directory prefix of this file
+        for (const ref of refSet) {
+            if (file.startsWith(ref + '/') || file.startsWith(ref.replace(/\/$/, '') + '/')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const classified = [];
+    for (const file of allFiles) {
+        let tier;
+        if (configSet.has(file)) {
+            tier = 'config';
+        }
+        else if (isReferencedByRef(file)) {
+            tier = 'visible';
+        }
+        else {
+            tier = 'invisible';
+        }
+        classified.push({ path: file, tier });
+    }
+    // Also add config files that walkFiles might have missed (e.g. .github/copilot-instructions.md)
+    for (const cp of configPaths) {
+        if (!classified.find(f => f.path === cp)) {
+            classified.push({ path: cp, tier: 'config' });
+        }
+    }
+    return classified;
+}
+// ── Main check ───────────────────────────────────────────────────────────────
+export async function checkMap(cwd) {
+    const issues = [];
+    // Discover agent configs
+    const configPaths = parseAgentConfigs(cwd);
+    // Extract all refs from all config files
+    const allRefs = [];
+    for (const cp of configPaths) {
+        const content = readFile(join(cwd, cp));
+        if (content) {
+            const refs = extractRefs(content, cwd);
+            allRefs.push(...refs);
+        }
+    }
+    const uniqueRefs = [...new Set(allRefs)];
+    // Classify files
+    const classified = classifyFiles(cwd, configPaths, uniqueRefs);
+    const configFiles = classified.filter(f => f.tier === 'config').map(f => f.path);
+    const visibleFiles = classified.filter(f => f.tier === 'visible').map(f => f.path);
+    const invisibleFiles = classified.filter(f => f.tier === 'invisible').map(f => f.path);
+    const total = classified.length;
+    const visible = visibleFiles.length + configFiles.length;
+    const visible_pct = total > 0 ? Math.round((visible / total) * 100) : 0;
+    // Issues
+    if (configPaths.length === 0) {
+        issues.push({
+            severity: 'warning',
+            message: 'no agent config files found (CLAUDE.md, .cursorrules, etc.) — agent has no guided context',
+            fixable: true,
+            fixHint: 'run: npx @safetnsr/vet init',
+        });
+    }
+    if (visible_pct < 20 && total > 0) {
+        issues.push({
+            severity: 'warning',
+            message: `agent is mostly blind: only ${visible_pct}% of codebase is referenced in agent configs`,
+            fixable: false,
+        });
+    }
+    // Surface top invisible dirs as info
+    const invisibleDirs = new Set();
+    for (const f of invisibleFiles) {
+        const parts = f.split('/');
+        if (parts.length > 1)
+            invisibleDirs.add(parts[0]);
+    }
+    const topInvisibleDirs = [...invisibleDirs].slice(0, 5);
+    if (topInvisibleDirs.length > 0 && invisibleFiles.length > 0) {
+        issues.push({
+            severity: 'info',
+            message: `top invisible directories: ${topInvisibleDirs.join(', ')}`,
+            fixable: false,
+        });
+    }
+    const mapData = {
+        config: configFiles,
+        visible: visibleFiles,
+        invisible: invisibleFiles,
+        stats: { total, visible_pct },
+    };
+    const summary = configPaths.length === 0
+        ? `no agent config files — all ${total} files invisible`
+        : `${visible_pct}% visible to agent (${visible}/${total} files)`;
+    return {
+        name: 'map',
+        score: visible_pct,
+        maxScore: 100,
+        issues,
+        summary,
+        mapData,
+    };
+}
+// ── Terminal renderer ─────────────────────────────────────────────────────────
+export function renderMapReport(result, asJson) {
+    const { mapData } = result;
+    if (asJson) {
+        return JSON.stringify({
+            config: mapData.config,
+            visible: mapData.visible,
+            invisible: mapData.invisible,
+            stats: mapData.stats,
+        }, null, 2);
+    }
+    const lines = [];
+    lines.push('');
+    lines.push(`  ${c.bold}vet map${c.reset} — agent visibility\n`);
+    lines.push(`  ${c.dim}score:${c.reset}   ${c.bold}${mapData.stats.visible_pct}%${c.reset} visible to agent`);
+    lines.push(`  ${c.dim}total:${c.reset}   ${mapData.stats.total} files`);
+    lines.push('');
+    // Config files tier
+    if (mapData.config.length > 0) {
+        lines.push(`  ${c.yellow}${c.bold}config files${c.reset} ${c.dim}(${mapData.config.length})${c.reset}`);
+        for (const f of mapData.config.slice(0, 10)) {
+            lines.push(`  ${c.yellow}●${c.reset} ${c.dim}${f}${c.reset}`);
+        }
+        if (mapData.config.length > 10) {
+            lines.push(`  ${c.dim}  ... and ${mapData.config.length - 10} more${c.reset}`);
+        }
+        lines.push('');
+    }
+    // Visible files tier
+    if (mapData.visible.length > 0) {
+        lines.push(`  ${c.green}${c.bold}visible to agent${c.reset} ${c.dim}(${mapData.visible.length})${c.reset}`);
+        for (const f of mapData.visible.slice(0, 15)) {
+            lines.push(`  ${c.green}●${c.reset} ${f}`);
+        }
+        if (mapData.visible.length > 15) {
+            lines.push(`  ${c.dim}  ... and ${mapData.visible.length - 15} more${c.reset}`);
+        }
+        lines.push('');
+    }
+    // Invisible dirs summary
+    if (mapData.invisible.length > 0) {
+        const invisibleDirs = new Map();
+        for (const f of mapData.invisible) {
+            const parts = f.split('/');
+            const dir = parts.length > 1 ? parts[0] : '(root)';
+            invisibleDirs.set(dir, (invisibleDirs.get(dir) || 0) + 1);
+        }
+        const sortedDirs = [...invisibleDirs.entries()].sort((a, b) => b[1] - a[1]);
+        lines.push(`  ${c.dim}${c.bold}invisible to agent${c.reset} ${c.dim}(${mapData.invisible.length} files)${c.reset}`);
+        for (const [dir, count] of sortedDirs.slice(0, 8)) {
+            lines.push(`  ${c.dim}○ ${dir}/ (${count} files)${c.reset}`);
+        }
+        if (sortedDirs.length > 8) {
+            lines.push(`  ${c.dim}  ... and ${sortedDirs.length - 8} more directories${c.reset}`);
+        }
+        lines.push('');
+    }
+    // Issues
+    for (const issue of result.issues) {
+        const icon = issue.severity === 'warning' ? c.yellow + '⚠' : c.dim + 'ℹ';
+        lines.push(`  ${icon}${c.reset} ${issue.message}`);
+        if (issue.fixHint)
+            lines.push(`    ${c.dim}→ ${issue.fixHint}${c.reset}`);
+    }
+    if (result.issues.length > 0)
+        lines.push('');
+    return lines.join('\n');
+}

package/dist/checks/memory.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult } from '../types.js';
+export declare function checkMemory(cwd: string): CheckResult;

package/dist/checks/memory.js

@@ -0,0 +1,275 @@
+import { join, resolve } from 'node:path';
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+// ── Memory file targets ──────────────────────────────────────────────────────
+const ROOT_FILES = ['CLAUDE.md', 'AGENTS.md', 'SOUL.md', '.cursorrules', 'codex.md'];
+const MEMORY_DIR = 'memory';
+const DAILY_DIR = join(MEMORY_DIR, 'daily');
+const MAX_DAILY_FILES = 30;
+// ── Tool categories for contradiction detection ─────────────────────────────
+const TOOL_CATEGORIES = {
+    'test framework': [/\bvitest\b/i, /\bjest\b/i, /\bmocha\b/i, /\bnode:test\b/i, /\bava\b/i],
+    'package manager': [/\bnpm\b/, /\byarn\b/, /\bpnpm\b/, /\bbun\b/],
+};
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function safeRead(path) {
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function collectMemoryFiles(cwd) {
+    const files = [];
+    // Root-level memory files
+    for (const name of ROOT_FILES) {
+        const full = join(cwd, name);
+        if (existsSync(full))
+            files.push(full);
+    }
+    // memory/*.md
+    const memDir = join(cwd, MEMORY_DIR);
+    if (existsSync(memDir) && statSync(memDir).isDirectory()) {
+        try {
+            for (const entry of readdirSync(memDir)) {
+                if (!entry.endsWith('.md'))
+                    continue;
+                const full = join(memDir, entry);
+                try {
+                    if (statSync(full).isFile())
+                        files.push(full);
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skip */ }
+    }
+    // memory/daily/*.md (capped)
+    const dailyDir = join(cwd, DAILY_DIR);
+    if (existsSync(dailyDir) && statSync(dailyDir).isDirectory()) {
+        try {
+            const entries = readdirSync(dailyDir).filter(e => e.endsWith('.md')).sort().reverse();
+            for (const entry of entries.slice(0, MAX_DAILY_FILES)) {
+                const full = join(dailyDir, entry);
+                try {
+                    if (statSync(full).isFile())
+                        files.push(full);
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return files;
+}
+/** Extract @scope/package references */
+function extractScopedPackages(content) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const matches = lines[i].matchAll(/@[a-zA-Z0-9_-]+\/[a-zA-Z0-9._-]+/g);
+        for (const m of matches) {
+            results.push({ pkg: m[0], line: i + 1 });
+        }
+    }
+    return results;
+}
+/** Extract file/dir path references */
+function extractPaths(content) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip lines that are purely URLs
+        // Match absolute paths
+        const absMatches = line.matchAll(/(?:^|\s|["`'(])(\/((?:var|home|usr|etc|opt|tmp|root|srv|mnt)[^\s"'`),;]*))(?=[\s"'`),;]|$)/g);
+        for (const m of absMatches) {
+            const p = m[1].replace(/[.,:;)]+$/, '');
+            if (p.startsWith('//') || p.includes('://'))
+                continue;
+            if (p.length < 4)
+                continue;
+            results.push({ path: p, line: i + 1 });
+        }
+        // Match relative paths starting with ./ or ../
+        const relMatches = line.matchAll(/(?:^|\s|["`'(])(\.\.?\/[^\s"'`),;]+)/g);
+        for (const m of relMatches) {
+            const p = m[1].replace(/[.,:;)]+$/, '');
+            if (p.includes('://'))
+                continue;
+            results.push({ path: p, line: i + 1 });
+        }
+    }
+    return results;
+}
+/** Extract tool mentions per category */
+function extractToolMentions(content, fileName) {
+    const mentions = new Map();
+    const lines = content.split('\n');
+    for (const [category, patterns] of Object.entries(TOOL_CATEGORIES)) {
+        for (let i = 0; i < lines.length; i++) {
+            for (const regex of patterns) {
+                if (regex.test(lines[i])) {
+                    const toolMatch = lines[i].match(regex);
+                    if (toolMatch) {
+                        const existing = mentions.get(category) || [];
+                        existing.push({ tool: toolMatch[0].toLowerCase(), file: fileName, line: i + 1 });
+                        mentions.set(category, existing);
+                    }
+                }
+            }
+        }
+    }
+    return mentions;
+}
+/** Count meaningful fact claims in a file */
+function countFacts(content) {
+    let count = 0;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('---') || trimmed.startsWith('```'))
+            continue;
+        // A "fact" is a line with at least some substantive content
+        if (trimmed.length > 15 && /[a-zA-Z]/.test(trimmed)) {
+            // Contains a keyword-like pattern (assignment, instruction, reference)
+            if (/[:=→\->]|use |stack|requires?|install|run |npm |config|version|path|file|dir|tool/i.test(trimmed)) {
+                count++;
+            }
+        }
+    }
+    return count;
+}
+// ── Main check ───────────────────────────────────────────────────────────────
+export function checkMemory(cwd) {
+    const memoryFiles = collectMemoryFiles(cwd);
+    const issues = [];
+    let deductions = 0;
+    if (memoryFiles.length === 0) {
+        return {
+            name: 'memory',
+            score: 100,
+            maxScore: 100,
+            issues: [],
+            summary: 'no agent memory files found',
+        };
+    }
+    // Load package.json deps
+    const pkgPath = join(cwd, 'package.json');
+    const allDeps = new Set();
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            for (const key of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
+                if (pkg[key]) {
+                    for (const name of Object.keys(pkg[key])) {
+                        allDeps.add(name);
+                    }
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    // Collect all tool mentions across files for contradiction detection
+    const globalToolMentions = new Map();
+    for (const filePath of memoryFiles) {
+        const content = safeRead(filePath);
+        if (!content)
+            continue;
+        const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+        // 1. Stale package references
+        if (allDeps.size > 0) {
+            const pkgRefs = extractScopedPackages(content);
+            for (const { pkg, line } of pkgRefs) {
+                if (!allDeps.has(pkg)) {
+                    issues.push({
+                        severity: 'warning',
+                        message: `Stale package: ${pkg} not in package.json`,
+                        file: relPath,
+                        line,
+                        fixable: false,
+                        fixHint: 'Remove or update this reference',
+                    });
+                    deductions += 10;
+                }
+            }
+        }
+        // 2. Broken path references
+        const pathRefs = extractPaths(content);
+        for (const { path: p, line } of pathRefs) {
+            const resolved = p.startsWith('/') ? p : resolve(cwd, p);
+            if (!existsSync(resolved)) {
+                issues.push({
+                    severity: 'error',
+                    message: `Broken path reference: ${p}`,
+                    file: relPath,
+                    line,
+                    fixable: false,
+                    fixHint: 'Remove or update this path reference',
+                });
+                deductions += 15;
+            }
+        }
+        // 3. Collect tool mentions for contradiction check
+        const toolMentions = extractToolMentions(content, relPath);
+        for (const [category, mentions] of toolMentions) {
+            const existing = globalToolMentions.get(category) || [];
+            existing.push(...mentions);
+            globalToolMentions.set(category, existing);
+        }
+        // 4. Bloat check
+        if (content.length > 5000) {
+            const factCount = countFacts(content);
+            if (factCount < 3) {
+                issues.push({
+                    severity: 'info',
+                    message: `Bloated memory file: ${content.length} chars but only ${factCount} fact claims`,
+                    file: relPath,
+                    line: 1,
+                    fixable: false,
+                    fixHint: 'Trim this file to only essential facts',
+                });
+                deductions += 5;
+            }
+        }
+    }
+    // 3. Contradiction detection
+    for (const [category, mentions] of globalToolMentions) {
+        const uniqueTools = new Map();
+        for (const m of mentions) {
+            if (!uniqueTools.has(m.tool)) {
+                uniqueTools.set(m.tool, { file: m.file, line: m.line });
+            }
+        }
+        if (uniqueTools.size > 1) {
+            const tools = [...uniqueTools.entries()];
+            for (let i = 0; i < tools.length; i++) {
+                for (let j = i + 1; j < tools.length; j++) {
+                    // Only flag if they're in different files
+                    if (tools[i][1].file !== tools[j][1].file) {
+                        issues.push({
+                            severity: 'warning',
+                            message: `Contradiction in ${category}: "${tools[i][0]}" in ${tools[i][1].file} vs "${tools[j][0]}" in ${tools[j][1].file}`,
+                            file: tools[i][1].file,
+                            line: tools[i][1].line,
+                            fixable: false,
+                            fixHint: `Standardize on one ${category} across memory files`,
+                        });
+                        deductions += 10;
+                    }
+                }
+            }
+        }
+    }
+    const finalScore = Math.max(0, 100 - deductions);
+    const issueCount = issues.length;
+    return {
+        name: 'memory',
+        score: finalScore,
+        maxScore: 100,
+        issues,
+        summary: issueCount === 0
+            ? `${memoryFiles.length} memory file${memoryFiles.length !== 1 ? 's' : ''} scanned, clean`
+            : `${issueCount} stale fact${issueCount !== 1 ? 's' : ''} found in agent memory files`,
+    };
+}

package/dist/checks/models.js

@@ -8,9 +8,14 @@ async function tryModelGraveyard(cwd) {
             return null;
         const report = await mod.scan(cwd);
         const issues = [];
+        // Files that define deprecated model registries should not be flagged
+        const SELF_FILES = ['models.ts', 'models.js', 'model-graveyard', 'model-registry', 'sunset', 'fix/models'];
         for (const match of report.matches) {
             if (!match.model)
                 continue;
+            // Skip self-referencing files (model definition/fix files)
+            if (match.file && SELF_FILES.some(s => match.file.toLowerCase().includes(s)))
+                continue;
             if (match.model.status === 'deprecated' || match.model.status === 'eol') {
                 issues.push({
                     severity: 'error',
@@ -22,11 +27,11 @@ async function tryModelGraveyard(cwd) {
                 });
             }
         }
-        const score = Math.max(0, 10 - issues.length * 2);
+        const score = Math.max(0, 100 - issues.length * 20);
         return {
             name: 'models',
-            score: Math.min(10, score),
-            maxScore: 10,
+            score: Math.min(100, score),
+            maxScore: 100,
             issues,
             summary: issues.length === 0
                 ? `${report.filesScanned} files scanned (via model-graveyard) — all current`
@@ -111,11 +116,11 @@ function builtinModels(cwd, ignore) {
             fixHint: `replace "${model}" with "${info.replacement}"`,
         });
     }
-    const score = Math.max(0, 10 - issues.length * 2);
+    const score = Math.max(0, 100 - issues.length * 20);
     return {
         name: 'models',
-        score: Math.min(10, score),
-        maxScore: 10,
+        score: Math.min(100, score),
+        maxScore: 100,
         issues,
         summary: issues.length === 0 ? 'all model references current' : `${issues.length} deprecated model${issues.length > 1 ? 's' : ''} found`,
     };

package/dist/checks/owasp-checks.d.ts

@@ -0,0 +1,51 @@
+export declare function collectAgentConfigFiles(cwd: string): string[];
+export declare function collectMcpConfigFiles(cwd: string): string[];
+export declare function readTextFile(filePath: string): string | null;
+export interface OwaspFinding {
+    asiId: string;
+    severity: 'error' | 'warning' | 'info';
+    message: string;
+    file?: string;
+    line?: number;
+    fixHint?: string;
+}
+export declare function checkASI01(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI02(cwd: string, mcpFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI03(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI04(cwd: string, mcpFiles: string[], agentConfigFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI05(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI06(cwd: string): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI07(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI08(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI09(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};
+export declare function checkASI10(cwd: string, configFiles: string[]): {
+    findings: OwaspFinding[];
+    deduction: number;
+};