@safetnsr/vet 0.1.0 → 0.2.0

package/README.md

@@ -13,49 +13,102 @@ works with Claude Code, Cursor, Copilot, Codex, Aider, Windsurf, Cline — anyth
 | check | what | how |
 |-------|------|-----|
 | **ready** | is your codebase AI-friendly? | scans structure, docs, types, tests |
-| **diff** | did the AI leave anti-patterns? | checks staged/unstaged changes for secrets, stubs, empty catches |
-| **models** | using deprecated AI models? | scans code for sunset model strings |
+| **diff** | did the AI leave anti-patterns? | AI-specific patterns: wholesale rewrites, orphaned imports, catch-alls, over-commenting, plus secrets & stubs |
+| **models** | using deprecated AI models? | scans code for sunset model strings across OpenAI, Anthropic, Google, Cohere |
 | **links** | broken markdown links? | validates relative links and wikilinks |
-| **config** | agent configs in place? | checks for CLAUDE.md, .cursorrules, copilot-instructions, etc. |
+| **config** | agent configs in place? | deep analysis of CLAUDE.md, .cursorrules, copilot-instructions — checks completeness, consistency, and specificity against your actual codebase |
 | **history** | git patterns healthy? | analyzes commit churn, AI attribution, large changes |
 
 ## usage
 
 ```bash
-# run all checks (default)
+# run all checks
 npx @safetnsr/vet
 
 # check a specific directory
 npx @safetnsr/vet ./my-project
 
+# auto-fix: generate CLAUDE.md, .cursorrules, fix deprecated models
+npx @safetnsr/vet --fix
+
+# check specific commit range
+npx @safetnsr/vet --since HEAD~5
+
+# live monitoring during AI sessions
+npx @safetnsr/vet --watch
+
 # CI mode — exit code 1 if score below threshold
 npx @safetnsr/vet --ci
 
-# auto-fix what we can
-npx @safetnsr/vet --fix
-
 # JSON output
 npx @safetnsr/vet --json
 
-# set up config + agent files + pre-commit hook
+# generate configs + pre-commit hook
 npx @safetnsr/vet init
 ```
 
 ## output
 
 ```
-  my-project  8.2/10
+  my-project  6.2/10
 
-  ready       ████████░░   8    structure + docs look good
-  diff        ██████████  10    clean diff, no issues
+  ready       ████░░░░░░   4    3 readiness issues
+  diff        ████████░░   8    3 issues (2 AI-specific) in 5 files
   models      ██████████  10    all models current
   links       ██████░░░░   6    3 broken links in docs/
-  config      ████████░░   8    CLAUDE.md missing react patterns
-  history     ████████░░   8    2 high-churn files
+  config      ███░░░░░░░   3    Cursor — needs work (3/10)
+  history     █████████░   9    41 commits (~15% AI-attributed)
+
+  ✗ no README — AI agents have no project context
+  ✗ no tests — AI agents produce better code when tests exist
+  ! [ai] wholesale rewrite: 40 lines removed, 45 added in utils.ts
+  ! [ai] imported "lodash" but never used in new code
 
   run --fix to auto-repair 4 issues
 ```
 
+## --fix
+
+`vet --fix` doesn't just scaffold — it analyzes your codebase and generates project-specific configs:
+
+```bash
+$ npx @safetnsr/vet --fix
+
+  vet --fix
+
+  + CLAUDE.md (generated from codebase: Next.js + React, Vitest, Tailwind CSS, TypeScript)
+  + .cursorrules (generated)
+  ✓ src/api.ts: "gpt-3.5-turbo" → "gpt-4o-mini"
+
+  fixed 3 issues
+```
+
+the generated CLAUDE.md includes your actual stack, directory structure, and framework-specific rules — not generic boilerplate.
+
+## AI-specific diff patterns
+
+vet catches things that are specific to AI-generated code:
+
+| pattern | what it catches |
+|---------|----------------|
+| `[ai] wholesale rewrite` | AI rewrote an entire function when a small edit would suffice |
+| `[ai] orphaned imports` | AI added imports it never uses |
+| `[ai] catch-all handling` | `catch(e) { console.error(e) }` instead of specific error handling |
+| `[ai] comment density` | AI over-commented obvious code |
+| `[ai] empty test body` | AI stubbed a test without implementation |
+| `[ai] trivial assertion` | `expect(true).toBe(true)` — test proves nothing |
+
+## config analysis
+
+the config check does deep analysis — not just "does CLAUDE.md exist":
+
+```
+config score breakdown:
+  completeness:  4/10 — mentions typescript but not react, vitest
+  consistency:   7/10 — "strict TS" but tsconfig.strict is false
+  specificity:   3/10 — generic rules, nothing project-specific
+```
+
 ## config
 
 create `.vetrc` in your project root (optional):
@@ -68,14 +121,6 @@ create `.vetrc` in your project root (optional):
 }
 ```
 
-## init
-
-`npx @safetnsr/vet init` creates:
-- `.vetrc` with sensible defaults
-- `CLAUDE.md` generated from your codebase
-- `.cursorrules` matching your project
-- `.git/hooks/pre-commit` that runs vet before every commit
-
 ## ci
 
 ```yaml

package/dist/checks/config.js

@@ -11,92 +11,196 @@ const AGENT_CONFIGS = {
     windsurf: { files: ['.windsurfrules'], name: 'Windsurf' },
     cline: { files: ['.clinerules', '.cline/settings.json'], name: 'Cline' },
 };
+function analyzeConfig(cwd, configFile, agentName, files) {
+    const content = readFile(join(cwd, configFile)) || '';
+    const contentLower = content.toLowerCase();
+    const suggestions = [];
+    // Existence: it exists, so 10
+    const existence = 10;
+    // Completeness: does it cover the project's actual stack?
+    let completenessScore = 5; // base
+    let completenessChecks = 0;
+    let completenessHits = 0;
+    const pkgJson = readFile(join(cwd, 'package.json'));
+    const deps = {};
+    let projectName = '';
+    if (pkgJson) {
+        try {
+            const pkg = JSON.parse(pkgJson);
+            projectName = pkg.name || '';
+            Object.assign(deps, pkg.dependencies, pkg.devDependencies);
+        }
+        catch { /* */ }
+    }
+    // Framework detection + config coverage
+    const frameworkMap = {
+        react: { keywords: ['react', 'jsx', 'tsx', 'component', 'hook', 'usestate', 'useeffect'], category: 'UI framework' },
+        next: { keywords: ['next', 'nextjs', 'app router', 'pages router', 'server component'], category: 'framework' },
+        vue: { keywords: ['vue', 'composition api', 'options api', 'ref(', 'reactive'], category: 'UI framework' },
+        svelte: { keywords: ['svelte', 'sveltekit', '$:'], category: 'UI framework' },
+        express: { keywords: ['express', 'middleware', 'router', 'req, res'], category: 'backend' },
+        hono: { keywords: ['hono', 'c.json', 'c.text'], category: 'backend' },
+        fastify: { keywords: ['fastify', 'schema', 'route'], category: 'backend' },
+        vitest: { keywords: ['vitest', 'describe', 'it(', 'expect', 'test('], category: 'testing' },
+        jest: { keywords: ['jest', 'describe', 'it(', 'expect', 'test('], category: 'testing' },
+        tailwind: { keywords: ['tailwind', 'className', 'tw-'], category: 'styling' },
+        prisma: { keywords: ['prisma', 'schema.prisma', 'prismaClient'], category: 'database' },
+        drizzle: { keywords: ['drizzle', 'drizzle-orm'], category: 'database' },
+    };
+    for (const [dep, info] of Object.entries(frameworkMap)) {
+        if (deps[dep] || deps[`@${dep}/core`] || deps[`${dep}-dom`]) {
+            completenessChecks++;
+            if (info.keywords.some(k => contentLower.includes(k))) {
+                completenessHits++;
+            }
+            else {
+                suggestions.push(`add ${dep} conventions (${info.category} detected in dependencies)`);
+            }
+        }
+    }
+    if (completenessChecks > 0) {
+        completenessScore = Math.round((completenessHits / completenessChecks) * 10);
+    }
+    // Consistency: cross-reference with actual project config
+    let consistencyScore = 10;
+    const tsconfig = readFile(join(cwd, 'tsconfig.json'));
+    if (tsconfig) {
+        try {
+            const tc = JSON.parse(tsconfig);
+            const strict = tc.compilerOptions?.strict;
+            if (contentLower.includes('strict') && strict === false) {
+                consistencyScore -= 4;
+                suggestions.push('config says "strict" but tsconfig.strict is false — resolve contradiction');
+            }
+            if (contentLower.includes('esm') && tc.compilerOptions?.module?.toLowerCase()?.includes('commonjs')) {
+                consistencyScore -= 3;
+                suggestions.push('config mentions ESM but tsconfig uses CommonJS');
+            }
+        }
+        catch { /* */ }
+    }
+    // Check if config mentions testing but no test framework installed
+    if ((contentLower.includes('test') || contentLower.includes('spec')) && !deps.vitest && !deps.jest && !deps.mocha && !deps.ava) {
+        consistencyScore -= 2;
+        suggestions.push('config mentions tests but no test framework in dependencies');
+    }
+    // Specificity: generic platitudes vs project-specific rules
+    let specificityScore = 5;
+    const genericPhrases = [
+        'keep functions small', 'write clean code', 'follow best practices',
+        'use meaningful names', 'handle errors', 'write tests', 'be consistent',
+        'follow conventions', 'keep it simple',
+    ];
+    let genericCount = 0;
+    for (const phrase of genericPhrases) {
+        if (contentLower.includes(phrase))
+            genericCount++;
+    }
+    // Specific indicators: file paths, function names, patterns, architecture
+    const specificIndicators = [
+        /\.(ts|js|py|rs|go)\b/, // mentions specific file types with context
+        /src\/|lib\/|app\/|pages\/|components\//, // directory structure
+        /import .+ from/, // code examples
+        /```/, // code blocks
+        /\bapi\/|route|endpoint/i, // API patterns
+        /\bmigration|schema|model\b/i, // data patterns
+    ];
+    let specificCount = 0;
+    for (const pattern of specificIndicators) {
+        if (pattern.test(content))
+            specificCount++;
+    }
+    if (genericCount > 3 && specificCount < 2) {
+        specificityScore = 2;
+        suggestions.push('mostly generic rules — add project-specific conventions, file paths, architecture patterns');
+    }
+    else if (specificCount >= 4) {
+        specificityScore = 9;
+    }
+    else if (specificCount >= 2) {
+        specificityScore = 6;
+    }
+    // Length-based adjustments
+    if (content.length < 100) {
+        specificityScore = Math.min(specificityScore, 2);
+        completenessScore = Math.min(completenessScore, 2);
+        suggestions.push('config is very sparse — add project context, conventions, and constraints');
+    }
+    else if (content.length < 300) {
+        specificityScore = Math.min(specificityScore, 5);
+        suggestions.push('config could be richer — consider adding architecture decisions and code patterns');
+    }
+    return {
+        file: configFile,
+        agent: agentName,
+        length: content.length,
+        existence,
+        completeness: Math.max(0, completenessScore),
+        consistency: Math.max(0, consistencyScore),
+        specificity: Math.max(0, specificityScore),
+        suggestions,
+    };
+}
 export function checkConfig(cwd, ignore) {
     const issues = [];
     const files = walkFiles(cwd, ignore);
     // Detect which agents have config
-    const detected = [];
-    const missing = [];
+    const analyses = [];
     for (const [agent, info] of Object.entries(AGENT_CONFIGS)) {
-        const found = info.files.some(f => fileExists(join(cwd, f)));
-        if (found)
-            detected.push(info.name);
+        for (const configFile of info.files) {
+            if (fileExists(join(cwd, configFile))) {
+                analyses.push(analyzeConfig(cwd, configFile, info.name, files));
+            }
+        }
     }
-    if (detected.length === 0) {
+    if (analyses.length === 0) {
         issues.push({
-            severity: 'warning',
-            message: 'no AI agent config found — add CLAUDE.md, .cursorrules, or similar to guide AI behavior',
+            severity: 'error',
+            message: 'no AI agent config found — add CLAUDE.md, .cursorrules, or similar',
             fixable: true,
             fixHint: 'run vet init to generate agent config',
         });
+        return {
+            name: 'config',
+            score: 1,
+            maxScore: 10,
+            issues,
+            summary: 'no agent configs — critically under-configured',
+        };
     }
-    // Check quality of found configs
-    for (const [agent, info] of Object.entries(AGENT_CONFIGS)) {
-        for (const configFile of info.files) {
-            const content = readFile(join(cwd, configFile));
-            if (!content)
-                continue;
-            // Too short to be useful
-            if (content.length < 50) {
-                issues.push({
-                    severity: 'warning',
-                    message: `${configFile} is only ${content.length} chars — probably too sparse to guide AI effectively`,
-                    file: configFile,
-                    fixable: false,
-                });
-            }
-            // Check if config mentions key project patterns
-            const pkgJson = readFile(join(cwd, 'package.json'));
-            if (pkgJson) {
-                try {
-                    const pkg = JSON.parse(pkgJson);
-                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-                    // Major frameworks that should be mentioned
-                    const frameworks = {
-                        react: ['react', 'jsx', 'tsx', 'component'],
-                        next: ['next', 'nextjs', 'app router', 'pages router'],
-                        vue: ['vue', 'composition api', 'options api'],
-                        svelte: ['svelte', 'sveltekit'],
-                        express: ['express', 'middleware', 'router'],
-                        hono: ['hono'],
-                        fastify: ['fastify'],
-                        django: ['django'],
-                        flask: ['flask'],
-                    };
-                    const contentLower = content.toLowerCase();
-                    for (const [framework, keywords] of Object.entries(frameworks)) {
-                        if (deps[framework] && !keywords.some(k => contentLower.includes(k))) {
-                            issues.push({
-                                severity: 'info',
-                                message: `${configFile} doesn't mention ${framework} — but it's in your dependencies`,
-                                file: configFile,
-                                fixable: false,
-                            });
-                        }
-                    }
-                }
-                catch { /* invalid package.json, skip */ }
-            }
-        }
+    // Aggregate scores from best config
+    const best = analyses.reduce((a, b) => (a.completeness + a.consistency + a.specificity) > (b.completeness + b.consistency + b.specificity) ? a : b);
+    // Generate issues from analysis
+    if (best.completeness < 5) {
+        issues.push({ severity: 'warning', message: `${best.file}: low completeness (${best.completeness}/10) — doesn't mention key dependencies`, fixable: true, fixHint: 'run vet --fix to enrich' });
+    }
+    if (best.consistency < 7) {
+        issues.push({ severity: 'warning', message: `${best.file}: consistency issues (${best.consistency}/10) — contradicts project config`, fixable: false });
+    }
+    if (best.specificity < 5) {
+        issues.push({ severity: 'warning', message: `${best.file}: too generic (${best.specificity}/10) — add project-specific rules`, fixable: true, fixHint: 'run vet --fix to add specifics' });
     }
-    // Check for .gitignore (agents need to know what to ignore)
+    if (best.length < 100) {
+        issues.push({ severity: 'warning', message: `${best.file}: only ${best.length} chars — too sparse to guide AI`, fixable: true });
+    }
+    for (const suggestion of best.suggestions.slice(0, 5)) {
+        issues.push({ severity: 'info', message: suggestion, file: best.file, fixable: false });
+    }
+    // Check .gitignore
     if (!fileExists(join(cwd, '.gitignore'))) {
-        issues.push({
-            severity: 'info',
-            message: 'no .gitignore — agents may create files in wrong directories',
-            fixable: false,
-        });
+        issues.push({ severity: 'warning', message: 'no .gitignore — agents may write to wrong directories', fixable: false });
     }
-    const errors = issues.filter(i => i.severity === 'error').length;
-    const warnings = issues.filter(i => i.severity === 'warning').length;
-    const infos = issues.filter(i => i.severity === 'info').length;
-    const score = Math.max(0, Math.min(10, 10 - errors * 2 - warnings * 1.5 - infos * 0.3));
-    const configSummary = detected.length > 0 ? `configs: ${detected.join(', ')}` : 'no agent configs';
+    // Score: weighted average of sub-scores
+    const subScore = (best.existence * 0.2 + best.completeness * 0.3 + best.consistency * 0.25 + best.specificity * 0.25);
+    const gitignorePenalty = fileExists(join(cwd, '.gitignore')) ? 0 : 1;
+    const finalScore = Math.max(0, Math.min(10, subScore - gitignorePenalty));
+    const agents = analyses.map(a => a.agent);
+    const uniqueAgents = [...new Set(agents)];
     return {
         name: 'config',
-        score: Math.round(score * 10) / 10,
+        score: Math.round(finalScore * 10) / 10,
         maxScore: 10,
         issues,
-        summary: issues.length === 0 ? `${configSummary} — well configured` : `${configSummary} — ${issues.length} suggestions`,
+        summary: `${uniqueAgents.join(', ')} — ${best.completeness >= 7 && best.specificity >= 7 ? 'well configured' : `needs work (${Math.round(finalScore)}/10)`}`,
     };
 }

package/dist/checks/diff.d.ts

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

package/dist/checks/diff.js

@@ -1,49 +1,52 @@
 import { git } from '../util.js';
-const PATTERNS = [
+// Generic patterns (still useful but not the star)
+const GENERIC_PATTERNS = [
     // Secrets
     { regex: /(?:api[_-]?key|secret|token|password|credential)\s*[:=]\s*['"][^'"]{8,}['"]/i, message: 'possible hardcoded secret', severity: 'error' },
     { regex: /sk-[a-zA-Z0-9]{20,}/, message: 'possible OpenAI API key', severity: 'error' },
     { regex: /AKIA[0-9A-Z]{16}/, message: 'possible AWS access key', severity: 'error' },
     { regex: /AIza[0-9A-Za-z_-]{35}/, message: 'possible Google API key', severity: 'error' },
-    // AI anti-patterns
-    { regex: /\/\/\s*TODO[:\s]/i, message: 'TODO comment left in code', severity: 'warning' },
-    { regex: /\/\/\s*FIXME[:\s]/i, message: 'FIXME comment left in code', severity: 'warning' },
-    { regex: /\/\/\s*HACK[:\s]/i, message: 'HACK comment left in code', severity: 'warning' },
-    { regex: /console\.log\(/, message: 'console.log left in code', severity: 'warning' },
-    { regex: /catch\s*\([^)]*\)\s*\{\s*\}/, message: 'empty catch block — error silently swallowed', severity: 'error' },
-    { regex: /catch\s*\([^)]*\)\s*\{\s*\/\//, message: 'catch block with only a comment — errors need handling', severity: 'warning' },
-    { regex: /it\(\s*['"].*['"]\s*,\s*(?:async\s*)?\(\)\s*=>\s*\{\s*\}\s*\)/, message: 'empty test body — stubbed test', severity: 'error' },
-    { regex: /test\(\s*['"].*['"]\s*,\s*(?:async\s*)?\(\)\s*=>\s*\{\s*\}\s*\)/, message: 'empty test body — stubbed test', severity: 'error' },
-    { regex: /expect\(true\)\.toBe\(true\)/, message: 'trivial assertion — test proves nothing', severity: 'error' },
-    { regex: /assert\s+True\s*$/, message: 'trivial assertion — test proves nothing', severity: 'error' },
-    { regex: /\.only\(/, message: '.only() left in test — other tests will be skipped', severity: 'error' },
-    { regex: /debugger;/, message: 'debugger statement left in code', severity: 'error' },
+    { regex: /debugger;/, message: 'debugger statement', severity: 'error' },
+    { regex: /\.only\(/, message: '.only() left in test — other tests skipped', severity: 'error' },
 ];
-export function checkDiff(cwd) {
-    const issues = [];
-    // Get staged + unstaged diff
+// AI-specific patterns — things AI agents do that humans typically don't
+const AI_PATTERNS = [
+    // Empty/trivial tests
+    { regex: /(?:it|test)\(\s*['"].*['"]\s*,\s*(?:async\s*)?\(\)\s*=>\s*\{\s*\}\s*\)/, message: '[ai] empty test body — stubbed test', severity: 'error' },
+    { regex: /expect\(true\)\.toBe\(true\)/, message: '[ai] trivial assertion — test proves nothing', severity: 'error' },
+    { regex: /assert\s+True\s*$/, message: '[ai] trivial assertion', severity: 'error' },
+    // Catch-all error handling (AI defaults to generic catches)
+    { regex: /catch\s*\([^)]*\)\s*\{\s*\}/, message: '[ai] empty catch block — error silently swallowed', severity: 'error' },
+    { regex: /catch\s*\(\w+\)\s*\{\s*console\.(log|error)\(\w+\)\s*;?\s*\}/, message: '[ai] catch-all with just console.log — handle errors specifically', severity: 'warning' },
+    // Over-commenting (AI tends to add obvious comments)
+    { regex: /\/\/\s*(set|get|return|create|initialize|import|export|define)\s+(the|a)\s+/i, message: '[ai] obvious comment — "// get the value" adds no information', severity: 'warning' },
+];
+function getDiff(cwd, opts) {
+    if (opts.since) {
+        return git(`diff ${opts.since}`, cwd);
+    }
+    // Default: last commit + working changes
     let diff = git('diff HEAD', cwd);
     if (!diff)
         diff = git('diff --cached', cwd);
     if (!diff)
         diff = git('diff', cwd);
-    if (!diff) {
-        return {
-            name: 'diff',
-            score: 10,
-            maxScore: 10,
-            issues: [],
-            summary: 'no uncommitted changes to check',
-        };
-    }
-    // Parse diff: only check added lines
-    let currentFile = '';
+    // If still nothing, diff last commit against its parent
+    if (!diff)
+        diff = git('diff HEAD~1..HEAD', cwd);
+    return diff;
+}
+function parseDiff(diff) {
+    const files = [];
+    let current = null;
     let lineNum = 0;
     for (const line of diff.split('\n')) {
         if (line.startsWith('diff --git')) {
             const match = line.match(/b\/(.+)$/);
-            if (match)
-                currentFile = match[1];
+            if (match) {
+                current = { path: match[1], addedLines: [], removedLines: [], addedCount: 0, removedCount: 0 };
+                files.push(current);
+            }
             lineNum = 0;
             continue;
         }
@@ -53,46 +56,122 @@ export function checkDiff(cwd) {
                 lineNum = parseInt(match[1]) - 1;
             continue;
         }
+        if (!current)
+            continue;
         if (line.startsWith('+') && !line.startsWith('+++')) {
             lineNum++;
-            const added = line.slice(1);
-            for (const pattern of PATTERNS) {
-                if (pattern.regex.test(added)) {
-                    issues.push({
-                        severity: pattern.severity,
-                        message: pattern.message,
-                        file: currentFile,
-                        line: lineNum,
-                        fixable: false,
-                    });
-                    break; // one issue per line
+            current.addedLines.push({ num: lineNum, text: line.slice(1) });
+            current.addedCount++;
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
+            current.removedLines.push(line.slice(1));
+            current.removedCount++;
+        }
+        else {
+            lineNum++;
+        }
+    }
+    return files;
+}
+export function checkDiff(cwd, opts = {}) {
+    const issues = [];
+    const diff = getDiff(cwd, opts);
+    if (!diff) {
+        return { name: 'diff', score: 10, maxScore: 10, issues: [], summary: 'no changes to check' };
+    }
+    const files = parseDiff(diff);
+    const allPatterns = [...GENERIC_PATTERNS, ...AI_PATTERNS];
+    // Pattern matching on added lines
+    for (const file of files) {
+        for (const { num, text } of file.addedLines) {
+            for (const pattern of allPatterns) {
+                if (pattern.regex.test(text)) {
+                    issues.push({ severity: pattern.severity, message: pattern.message, file: file.path, line: num, fixable: false });
+                    break;
                 }
             }
         }
-        else if (!line.startsWith('-')) {
-            lineNum++;
+    }
+    // AI-specific: wholesale function rewrite detection
+    for (const file of files) {
+        if (file.removedCount > 10 && file.addedCount > 10) {
+            const ratio = Math.min(file.removedCount, file.addedCount) / Math.max(file.removedCount, file.addedCount);
+            if (ratio > 0.7 && file.removedCount > 20) {
+                issues.push({
+                    severity: 'warning',
+                    message: `[ai] ${file.path}: ${file.removedCount} lines removed, ${file.addedCount} added — looks like a wholesale rewrite, verify intent`,
+                    file: file.path,
+                    fixable: false,
+                });
+            }
         }
     }
-    // Check for deleted error handling
+    // AI-specific: orphaned imports (added import lines without corresponding usage)
+    for (const file of files) {
+        const addedImports = file.addedLines.filter(l => /^import\s/.test(l.text) || /^from\s/.test(l.text) || /require\(/.test(l.text));
+        for (const imp of addedImports) {
+            // Extract imported name
+            const nameMatch = imp.text.match(/import\s+(?:\{([^}]+)\}|(\w+))/);
+            if (nameMatch) {
+                const names = (nameMatch[1] || nameMatch[2] || '').split(',').map(n => n.trim().split(' as ').pop()?.trim()).filter(Boolean);
+                for (const name of names) {
+                    if (!name || name.length < 2)
+                        continue;
+                    // Check if name is used in any other added line
+                    const usedElsewhere = file.addedLines.some(l => l !== imp && l.text.includes(name));
+                    if (!usedElsewhere && file.addedLines.length > 3) {
+                        issues.push({
+                            severity: 'warning',
+                            message: `[ai] imported "${name}" but never used in new code`,
+                            file: file.path,
+                            line: imp.num,
+                            fixable: false,
+                        });
+                        break; // one per import line
+                    }
+                }
+            }
+        }
+    }
+    // AI-specific: comment density spike
+    for (const file of files) {
+        if (file.addedCount < 10)
+            continue;
+        const commentLines = file.addedLines.filter(l => /^\s*(\/\/|#|\/\*|\*)/.test(l.text)).length;
+        const ratio = commentLines / file.addedCount;
+        if (ratio > 0.4 && commentLines > 5) {
+            issues.push({
+                severity: 'info',
+                message: `[ai] ${file.path}: ${Math.round(ratio * 100)}% of new lines are comments — AI tends to over-comment`,
+                file: file.path,
+                fixable: false,
+            });
+        }
+    }
+    // Deleted error handling
     let deletedErrorHandling = 0;
-    for (const line of diff.split('\n')) {
-        if (line.startsWith('-') && !line.startsWith('---')) {
-            if (/catch|throw|Error|reject|finally/.test(line)) {
+    for (const file of files) {
+        for (const line of file.removedLines) {
+            if (/catch|throw new|\.reject\(|finally\s*\{/.test(line))
                 deletedErrorHandling++;
-            }
         }
     }
     if (deletedErrorHandling > 3) {
-        issues.push({ severity: 'warning', message: `${deletedErrorHandling} lines of error handling removed — verify this was intentional`, fixable: false });
+        issues.push({ severity: 'warning', message: `${deletedErrorHandling} lines of error handling removed — verify intentional`, fixable: false });
     }
+    // Recalibrated scoring
     const errors = issues.filter(i => i.severity === 'error').length;
     const warnings = issues.filter(i => i.severity === 'warning').length;
-    const score = Math.max(0, Math.min(10, 10 - errors * 1.5 - warnings * 0.5));
+    const score = Math.max(0, Math.min(10, 10 - errors * 2 - warnings * 0.75));
+    const aiIssues = issues.filter(i => i.message.startsWith('[ai]')).length;
+    const totalFiles = files.length;
     return {
         name: 'diff',
         score: Math.round(score * 10) / 10,
         maxScore: 10,
         issues,
-        summary: issues.length === 0 ? 'clean diff, no issues' : `${issues.length} issues in uncommitted changes`,
+        summary: issues.length === 0
+            ? `${totalFiles} file${totalFiles !== 1 ? 's' : ''} changed, clean`
+            : `${issues.length} issues (${aiIssues} AI-specific) in ${totalFiles} files`,
     };
 }

package/dist/checks/ready.js

@@ -4,65 +4,62 @@ import { readFile, walkFiles } from '../util.js';
 export function checkReady(cwd, ignore) {
     const issues = [];
     const files = walkFiles(cwd, ignore);
-    // 1. README exists
+    // 1. README exists — critical for AI context
     const hasReadme = files.some(f => /^readme\.(md|txt|rst)$/i.test(f));
     if (!hasReadme) {
-        issues.push({ severity: 'warning', message: 'no README found — AI agents work better with project context', fixable: true, fixHint: 'create a README.md' });
+        issues.push({ severity: 'error', message: 'no README — AI agents have no project context', fixable: true, fixHint: 'create a README.md' });
     }
     // 2. Project manifest
     const manifests = ['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle', 'Gemfile', 'composer.json'];
     const hasManifest = manifests.some(m => files.includes(m));
     if (!hasManifest) {
-        issues.push({ severity: 'warning', message: 'no package manifest found — agents need dependency context', fixable: false });
+        issues.push({ severity: 'error', message: 'no package manifest — agents can\'t resolve dependencies', fixable: false });
     }
-    // 3. Check for overly large files (>500 lines is harder for AI to reason about)
-    let largeFileCount = 0;
+    // 3. Test coverage
     const codeExts = ['.ts', '.js', '.tsx', '.jsx', '.py', '.rs', '.go', '.java', '.rb', '.php', '.cs', '.swift', '.kt'];
+    const testFiles = files.filter(f => /\.(test|spec)\.(ts|js|tsx|jsx|py)$/.test(f) || f.includes('__tests__/') || f.startsWith('tests/') || f.startsWith('test/'));
+    const codeFiles = files.filter(f => codeExts.some(ext => f.endsWith(ext)));
+    if (codeFiles.length > 5 && testFiles.length === 0) {
+        issues.push({ severity: 'error', message: 'no tests — AI agents produce better code when tests exist to validate against', fixable: false });
+    }
+    // 4. Overly large files (>500 lines)
+    let largeFileCount = 0;
     for (const f of files) {
         if (!codeExts.some(ext => f.endsWith(ext)))
             continue;
         const content = readFile(join(cwd, f));
-        if (content) {
-            const lines = content.split('\n').length;
-            if (lines > 500) {
-                largeFileCount++;
-                if (largeFileCount <= 3) {
-                    issues.push({ severity: 'info', message: `${f} is ${lines} lines — consider splitting for better AI comprehension`, fixable: false });
-                }
+        if (content && content.split('\n').length > 500) {
+            largeFileCount++;
+            if (largeFileCount <= 3) {
+                issues.push({ severity: 'warning', message: `${f} is ${content.split('\n').length} lines — split for better AI comprehension`, fixable: false });
             }
         }
     }
     if (largeFileCount > 3) {
-        issues.push({ severity: 'info', message: `...and ${largeFileCount - 3} more large files`, fixable: false });
+        issues.push({ severity: 'warning', message: `...and ${largeFileCount - 3} more large files`, fixable: false });
     }
-    // 4. Check for .env.example (helps AI understand required env vars)
+    // 5. .env without .env.example
     const hasEnv = files.some(f => f === '.env' || f === '.env.local');
     const hasEnvExample = files.some(f => f === '.env.example' || f === '.env.template');
     if (hasEnv && !hasEnvExample) {
-        issues.push({ severity: 'warning', message: '.env exists but no .env.example — AI agents can\'t see your env structure', fixable: false });
+        issues.push({ severity: 'warning', message: '.env exists but no .env.example — AI agents can\'t see env structure', fixable: false });
     }
-    // 5. TypeScript/Python type coverage
+    // 6. No types in JS-heavy project
     const tsFiles = files.filter(f => f.endsWith('.ts') || f.endsWith('.tsx'));
     const jsFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.jsx'));
     if (jsFiles.length > 10 && tsFiles.length === 0 && files.includes('package.json')) {
-        issues.push({ severity: 'info', message: `${jsFiles.length} JS files with no TypeScript — typed code gives AI agents better context`, fixable: false });
-    }
-    // 6. Test coverage indicator
-    const testFiles = files.filter(f => /\.(test|spec)\.(ts|js|tsx|jsx|py)$/.test(f) || f.includes('__tests__/') || f.startsWith('tests/') || f.startsWith('test/'));
-    const codeFiles = files.filter(f => codeExts.some(ext => f.endsWith(ext)));
-    if (codeFiles.length > 5 && testFiles.length === 0) {
-        issues.push({ severity: 'warning', message: 'no test files found — AI agents produce better code when tests exist to validate against', fixable: false });
+        issues.push({ severity: 'info', message: `${jsFiles.length} JS files, no TypeScript — typed code gives agents better context`, fixable: false });
     }
-    // Score: start at 10, deduct
+    // Recalibrated scoring: errors = -3, warnings = -1.5, info = -0.3
     const errors = issues.filter(i => i.severity === 'error').length;
     const warnings = issues.filter(i => i.severity === 'warning').length;
     const infos = issues.filter(i => i.severity === 'info').length;
-    const score = Math.max(0, Math.min(10, 10 - errors * 2 - warnings * 1 - infos * 0.3));
+    const score = Math.max(0, Math.min(10, 10 - errors * 3 - warnings * 1.5 - infos * 0.3));
     return {
         name: 'ready',
         score: Math.round(score * 10) / 10,
         maxScore: 10,
         issues,
-        summary: issues.length === 0 ? 'codebase is well-structured for AI' : `${issues.length} suggestions for better AI readiness`,
+        summary: issues.length === 0 ? 'codebase is well-structured for AI' : `${issues.length} readiness issues`,
     };
 }

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { resolve } from 'node:path';
 import { readFileSync } from 'node:fs';
-import { isGitRepo, readFile } from './util.js';
+import { isGitRepo, readFile, c } from './util.js';
 import { checkReady } from './checks/ready.js';
 import { checkDiff } from './checks/diff.js';
 import { checkModels } from './checks/models.js';
@@ -11,24 +11,38 @@ import { checkHistory } from './checks/history.js';
 import { score } from './scorer.js';
 import { reportPretty, reportJSON } from './reporter.js';
 const args = process.argv.slice(2);
-const flags = new Set(args.filter(a => a.startsWith('-')));
+const flags = new Set(args.filter(a => a.startsWith('-') && !a.startsWith('--since')));
+const flagMap = new Map();
+// Parse --since=value or --since value
+for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--since=')) {
+        flagMap.set('since', args[i].split('=')[1]);
+    }
+    else if (args[i] === '--since' && args[i + 1]) {
+        flagMap.set('since', args[i + 1]);
+        i++;
+    }
+}
 const positional = args.filter(a => !a.startsWith('-'));
 if (flags.has('--help') || flags.has('-h')) {
     console.log(`
-  vet — vet your AI-generated code
+  ${c.bold}vet${c.reset} — vet your AI-generated code
 
-  usage:
-    npx @safetnsr/vet [dir]       run all checks (default: cwd)
-    npx @safetnsr/vet --ci        exit code 1 if score < threshold
-    npx @safetnsr/vet --fix       auto-repair fixable issues
-    npx @safetnsr/vet --json      output JSON
-    npx @safetnsr/vet init        generate .vetrc + agent config
+  ${c.dim}usage:${c.reset}
+    npx @safetnsr/vet [dir]              run all checks
+    npx @safetnsr/vet --fix              auto-repair fixable issues
+    npx @safetnsr/vet --ci               exit code 1 if below threshold
+    npx @safetnsr/vet --since HEAD~5     check specific commit range
+    npx @safetnsr/vet --watch            live monitoring during AI sessions
+    npx @safetnsr/vet init               generate configs + hooks
 
-  options:
-    --ci          CI mode (exit 1 if below threshold)
-    --fix         auto-fix what we can
+  ${c.dim}options:${c.reset}
+    --ci          CI mode (exit 1 if score < threshold)
+    --fix         auto-fix configs, models, links
+    --since REF   diff against specific commit/range
+    --watch       re-run on file changes
     --json        JSON output
-    --no-color    disable colors
+    --pretty      force pretty output (even in pipes)
     -h, --help    show this help
     -v, --version show version
 `);
@@ -40,7 +54,7 @@ if (flags.has('--version') || flags.has('-v')) {
         console.log(pkg.version);
     }
     catch {
-        console.log('0.1.0');
+        console.log('0.2.0');
     }
     process.exit(0);
 }
@@ -49,7 +63,9 @@ const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
 const isFix = flags.has('--fix');
+const isWatch = flags.has('--watch');
 const isJSON = flags.has('--json') || (!process.stdout.isTTY && !flags.has('--pretty'));
+const since = flagMap.get('since');
 // Load config
 let config = {};
 const configContent = readFile(resolve(cwd, '.vetrc'));
@@ -65,35 +81,90 @@ if (command === 'init') {
     await init(cwd);
     process.exit(0);
 }
-// Run checks
 if (!isGitRepo(cwd)) {
-    console.error('not a git repository. vet operates on git repos.');
+    console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
 }
-const allChecks = ['ready', 'diff', 'models', 'links', 'config', 'history'];
-const enabledChecks = config.checks || allChecks;
-const results = [];
-if (enabledChecks.includes('ready'))
-    results.push(checkReady(cwd, ignore));
-if (enabledChecks.includes('diff'))
-    results.push(checkDiff(cwd));
-if (enabledChecks.includes('models'))
-    results.push(checkModels(cwd, ignore));
-if (enabledChecks.includes('links'))
-    results.push(checkLinks(cwd, ignore));
-if (enabledChecks.includes('config'))
-    results.push(checkConfig(cwd, ignore));
-if (enabledChecks.includes('history'))
-    results.push(checkHistory(cwd));
-const result = score(cwd, results);
-if (isJSON) {
-    console.log(reportJSON(result));
+// --fix mode
+if (isFix) {
+    console.log(`\n  ${c.bold}vet --fix${c.reset}\n`);
+    const { fixConfig } = await import('./fix/config.js');
+    const { fixModels } = await import('./fix/models.js');
+    const { fixLinks } = await import('./fix/links.js');
+    const configResult = fixConfig(cwd);
+    const modelsResult = fixModels(cwd, ignore);
+    const linksResult = fixLinks(cwd, ignore);
+    const allMessages = [...configResult.messages, ...modelsResult.messages, ...linksResult.messages];
+    const totalFixed = configResult.fixed + modelsResult.fixed + linksResult.fixed;
+    if (allMessages.length > 0) {
+        for (const msg of allMessages)
+            console.log(msg);
+    }
+    console.log(`\n  ${totalFixed > 0 ? c.green : c.dim}fixed ${totalFixed} issue${totalFixed !== 1 ? 's' : ''}${c.reset}\n`);
+    process.exit(0);
+}
+function runChecks() {
+    const allChecks = ['ready', 'diff', 'models', 'links', 'config', 'history'];
+    const enabledChecks = config.checks || allChecks;
+    const results = [];
+    if (enabledChecks.includes('ready'))
+        results.push(checkReady(cwd, ignore));
+    if (enabledChecks.includes('diff'))
+        results.push(checkDiff(cwd, { since }));
+    if (enabledChecks.includes('models'))
+        results.push(checkModels(cwd, ignore));
+    if (enabledChecks.includes('links'))
+        results.push(checkLinks(cwd, ignore));
+    if (enabledChecks.includes('config'))
+        results.push(checkConfig(cwd, ignore));
+    if (enabledChecks.includes('history'))
+        results.push(checkHistory(cwd));
+    return score(cwd, results);
 }
-else {
+// --watch mode
+if (isWatch) {
+    console.clear();
+    let result = runChecks();
     console.log(reportPretty(result));
+    console.log(`  ${c.dim}watching for changes... (ctrl+c to stop)${c.reset}\n`);
+    let debounce = null;
+    const { watch } = await import('node:fs');
+    try {
+        const watcher = watch(cwd, { recursive: true }, (event, filename) => {
+            if (!filename)
+                return;
+            if (filename.includes('node_modules') || filename.includes('.git'))
+                return;
+            if (debounce)
+                clearTimeout(debounce);
+            debounce = setTimeout(() => {
+                console.clear();
+                result = runChecks();
+                console.log(reportPretty(result));
+                console.log(`  ${c.dim}watching for changes... (ctrl+c to stop)${c.reset}\n`);
+            }, 500);
+        });
+        process.on('SIGINT', () => {
+            watcher.close();
+            process.exit(0);
+        });
+    }
+    catch {
+        console.error(`${c.yellow}watch mode requires Node 19+ with recursive fs.watch support${c.reset}`);
+        process.exit(1);
+    }
 }
-// CI exit code
-if (isCI) {
-    const threshold = config.thresholds?.min ?? 6;
-    process.exit(result.score >= threshold ? 0 : 1);
+else {
+    // Normal run
+    const result = runChecks();
+    if (isJSON) {
+        console.log(reportJSON(result));
+    }
+    else {
+        console.log(reportPretty(result));
+    }
+    if (isCI) {
+        const threshold = config.thresholds?.min ?? 6;
+        process.exit(result.score >= threshold ? 0 : 1);
+    }
 }

package/dist/fix/config.d.ts

@@ -0,0 +1,4 @@
+export declare function fixConfig(cwd: string): {
+    fixed: number;
+    messages: string[];
+};

package/dist/fix/config.js

@@ -0,0 +1,151 @@
+import { join } from 'node:path';
+import { writeFileSync, existsSync } from 'node:fs';
+import { readFile, walkFiles, c } from '../util.js';
+// Generate or enrich CLAUDE.md from codebase analysis
+export function fixConfig(cwd) {
+    const messages = [];
+    let fixed = 0;
+    const files = walkFiles(cwd);
+    // Detect project context
+    const pkgJson = readFile(join(cwd, 'package.json'));
+    const deps = {};
+    let projectName = 'project';
+    let scripts = {};
+    if (pkgJson) {
+        try {
+            const pkg = JSON.parse(pkgJson);
+            projectName = pkg.name || 'project';
+            Object.assign(deps, pkg.dependencies, pkg.devDependencies);
+            scripts = pkg.scripts || {};
+        }
+        catch { /* */ }
+    }
+    // Detect frameworks
+    const detected = [];
+    if (deps.react || deps['react-dom']) {
+        const rules = ['use functional components with hooks', 'prefer named exports for components'];
+        if (deps.next)
+            rules.push('use App Router conventions (layout.tsx, page.tsx, loading.tsx)');
+        detected.push({ name: deps.next ? 'Next.js + React' : 'React', rules });
+    }
+    if (deps.vue)
+        detected.push({ name: 'Vue', rules: ['use Composition API', 'keep components in SFC format'] });
+    if (deps.svelte)
+        detected.push({ name: 'SvelteKit', rules: ['use +page.svelte conventions'] });
+    if (deps.hono)
+        detected.push({ name: 'Hono', rules: ['use c.json() for responses', 'add specific routes before dynamic routes'] });
+    if (deps.express)
+        detected.push({ name: 'Express', rules: ['use router.use() for middleware', 'error middleware last'] });
+    if (deps.fastify)
+        detected.push({ name: 'Fastify', rules: ['use schema validation on routes'] });
+    // Testing
+    if (deps.vitest)
+        detected.push({ name: 'Vitest', rules: ['write tests in *.test.ts files', 'use describe/it/expect pattern'] });
+    else if (deps.jest)
+        detected.push({ name: 'Jest', rules: ['write tests in *.test.ts files', 'use describe/it/expect pattern'] });
+    // Database
+    if (deps.prisma || deps['@prisma/client'])
+        detected.push({ name: 'Prisma', rules: ['run prisma generate after schema changes', 'use transactions for multi-step mutations'] });
+    if (deps['drizzle-orm'])
+        detected.push({ name: 'Drizzle', rules: ['define schema in src/db/schema.ts'] });
+    // Styling
+    if (deps.tailwindcss)
+        detected.push({ name: 'Tailwind CSS', rules: ['use utility classes, avoid custom CSS where possible'] });
+    // TypeScript
+    const tsconfig = readFile(join(cwd, 'tsconfig.json'));
+    let tsStrict = false;
+    if (tsconfig) {
+        try {
+            tsStrict = JSON.parse(tsconfig).compilerOptions?.strict === true;
+        }
+        catch { /* */ }
+    }
+    if (deps.typescript || tsconfig) {
+        const rules = ['use TypeScript for all new files'];
+        if (tsStrict)
+            rules.push('strict mode enabled — no `any` types, explicit return types on exports');
+        detected.push({ name: 'TypeScript', rules });
+    }
+    // Detect directory structure
+    const dirs = new Set();
+    for (const f of files.slice(0, 200)) {
+        const parts = f.split('/');
+        if (parts.length > 1)
+            dirs.add(parts[0]);
+    }
+    // Generate CLAUDE.md
+    const claudePath = join(cwd, 'CLAUDE.md');
+    const existingContent = readFile(claudePath);
+    if (!existingContent) {
+        // Generate fresh
+        const lines = [`# ${projectName}\n`];
+        if (detected.length > 0) {
+            lines.push('## Stack');
+            lines.push(detected.map(d => `- ${d.name}`).join('\n'));
+            lines.push('');
+        }
+        if (dirs.size > 0) {
+            lines.push('## Structure');
+            const importantDirs = ['src', 'app', 'pages', 'components', 'lib', 'api', 'server', 'public', 'tests', 'test', 'scripts'];
+            const projectDirs = [...dirs].filter(d => importantDirs.includes(d));
+            if (projectDirs.length > 0) {
+                lines.push(projectDirs.map(d => `- \`${d}/\``).join('\n'));
+                lines.push('');
+            }
+        }
+        lines.push('## Rules');
+        lines.push('- handle errors explicitly — no empty catch blocks');
+        lines.push('- no hardcoded secrets or API keys');
+        lines.push('- keep functions focused and under 50 lines');
+        for (const d of detected) {
+            for (const rule of d.rules) {
+                lines.push(`- ${rule}`);
+            }
+        }
+        if (scripts.test)
+            lines.push(`- run \`${scripts.test.split('&&')[0].trim()}\` before committing`);
+        if (scripts.lint)
+            lines.push(`- run \`${scripts.lint.split('&&')[0].trim()}\` to check code style`);
+        lines.push('');
+        writeFileSync(claudePath, lines.join('\n'));
+        messages.push(`${c.green}+${c.reset} CLAUDE.md (generated from codebase: ${detected.map(d => d.name).join(', ')})`);
+        fixed++;
+    }
+    else {
+        // Enrich existing — append missing framework mentions
+        const contentLower = existingContent.toLowerCase();
+        const additions = [];
+        for (const d of detected) {
+            if (!contentLower.includes(d.name.toLowerCase().split(' ')[0])) {
+                additions.push(`\n## ${d.name} (auto-detected)`);
+                for (const rule of d.rules) {
+                    additions.push(`- ${rule}`);
+                }
+            }
+        }
+        if (additions.length > 0) {
+            writeFileSync(claudePath, existingContent + '\n' + additions.join('\n') + '\n');
+            messages.push(`${c.green}+${c.reset} CLAUDE.md enriched with ${additions.length} rules from detected stack`);
+            fixed++;
+        }
+    }
+    // Generate .cursorrules if missing
+    const cursorPath = join(cwd, '.cursorrules');
+    if (!existsSync(cursorPath) && detected.length > 0) {
+        const lines = [`# ${projectName}\n`];
+        lines.push(`${detected.map(d => d.name).join(' + ')} project.\n`);
+        lines.push('## Guidelines');
+        lines.push('- handle errors explicitly');
+        lines.push('- no hardcoded secrets');
+        for (const d of detected) {
+            for (const rule of d.rules) {
+                lines.push(`- ${rule}`);
+            }
+        }
+        lines.push('');
+        writeFileSync(cursorPath, lines.join('\n'));
+        messages.push(`${c.green}+${c.reset} .cursorrules (generated)`);
+        fixed++;
+    }
+    return { fixed, messages };
+}

package/dist/fix/links.d.ts

@@ -0,0 +1,4 @@
+export declare function fixLinks(cwd: string, ignore: string[]): {
+    fixed: number;
+    messages: string[];
+};

package/dist/fix/links.js

@@ -0,0 +1,60 @@
+import { join, dirname } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { readFile, walkFiles, fileExists, c } from '../util.js';
+export function fixLinks(cwd, ignore) {
+    const messages = [];
+    let fixed = 0;
+    const files = walkFiles(cwd, ignore);
+    const mdFiles = files.filter(f => f.endsWith('.md'));
+    // Build file index for finding correct targets
+    const fileIndex = new Map();
+    for (const f of files) {
+        const name = f.split('/').pop() || '';
+        const nameNoExt = name.replace(/\.[^.]+$/, '');
+        fileIndex.set(nameNoExt.toLowerCase(), f);
+        fileIndex.set(name.toLowerCase(), f);
+    }
+    for (const mdFile of mdFiles) {
+        const fullPath = join(cwd, mdFile);
+        let content = readFile(fullPath);
+        if (!content)
+            continue;
+        const dir = dirname(mdFile);
+        let changed = false;
+        // Fix broken relative links by finding the target file
+        content = content.replace(/\[([^\]]*)\]\(([^)]+)\)/g, (match, text, target) => {
+            const cleanTarget = target.split('#')[0].split('?')[0];
+            if (!cleanTarget)
+                return match;
+            if (cleanTarget.startsWith('http://') || cleanTarget.startsWith('https://') || cleanTarget.startsWith('mailto:'))
+                return match;
+            const resolved = join(dir, cleanTarget);
+            if (fileExists(join(cwd, resolved)))
+                return match; // link is fine
+            // Try to find the target file
+            const targetName = cleanTarget.split('/').pop()?.replace(/\.[^.]+$/, '')?.toLowerCase() || '';
+            const found = fileIndex.get(targetName);
+            if (found) {
+                // Calculate relative path from this file to the found file
+                const fromDir = dirname(mdFile);
+                let newTarget = found;
+                if (fromDir !== '.') {
+                    const fromParts = fromDir.split('/');
+                    const toParts = found.split('/');
+                    // Simple relative path
+                    const ups = fromParts.length;
+                    newTarget = '../'.repeat(ups) + found;
+                }
+                changed = true;
+                fixed++;
+                messages.push(`  ${c.green}✓${c.reset} ${mdFile}: "${cleanTarget}" → "${newTarget}"`);
+                return `[${text}](${newTarget})`;
+            }
+            return match;
+        });
+        if (changed) {
+            writeFileSync(fullPath, content);
+        }
+    }
+    return { fixed, messages };
+}

package/dist/fix/models.d.ts

@@ -0,0 +1,4 @@
+export declare function fixModels(cwd: string, ignore: string[]): {
+    fixed: number;
+    messages: string[];
+};

package/dist/fix/models.js

@@ -0,0 +1,64 @@
+import { join } from 'node:path';
+import { writeFileSync } from 'node:fs';
+import { walkFiles, readFile, c } from '../util.js';
+// Same registry as checks/models.ts — inline to avoid coupling
+const REPLACEMENTS = {
+    'gpt-3.5-turbo': 'gpt-4o-mini',
+    'gpt-4-turbo': 'gpt-4o',
+    'gpt-4-turbo-preview': 'gpt-4o',
+    'gpt-4-0314': 'gpt-4o',
+    'gpt-4-0613': 'gpt-4o',
+    'gpt-4-32k': 'gpt-4o',
+    'text-davinci-003': 'gpt-4o-mini',
+    'code-davinci-002': 'gpt-4o',
+    'text-embedding-ada-002': 'text-embedding-3-small',
+    'claude-instant-1': 'claude-sonnet-4-5',
+    'claude-2': 'claude-sonnet-4-5',
+    'claude-2.0': 'claude-sonnet-4-5',
+    'claude-2.1': 'claude-sonnet-4-5',
+    'claude-3-haiku-20240307': 'claude-haiku-3-5',
+    'claude-3-sonnet-20240229': 'claude-sonnet-4-5',
+    'claude-3-opus-20240229': 'claude-opus-4-0',
+    'gemini-pro': 'gemini-2.0-flash',
+    'gemini-1.0-pro': 'gemini-2.0-flash',
+    'gemini-1.5-pro': 'gemini-2.5-pro',
+    'gemini-1.5-flash': 'gemini-2.0-flash',
+    'text-bison': 'gemini-2.0-flash',
+    'chat-bison': 'gemini-2.0-flash',
+};
+const SCAN_EXTS = ['.ts', '.js', '.tsx', '.jsx', '.py', '.rs', '.go', '.java', '.rb', '.php',
+    '.yaml', '.yml', '.json', '.toml', '.cfg', '.ini', '.conf'];
+const SELF_IGNORE = ['models.ts', 'models.js', 'model-graveyard', 'model-registry', 'sunset'];
+export function fixModels(cwd, ignore) {
+    const messages = [];
+    let fixed = 0;
+    const files = walkFiles(cwd, ignore);
+    for (const f of files) {
+        if (!SCAN_EXTS.some(ext => f.endsWith(ext)))
+            continue;
+        if (SELF_IGNORE.some(s => f.toLowerCase().includes(s)))
+            continue;
+        const fullPath = join(cwd, f);
+        const raw = readFile(fullPath);
+        if (!raw)
+            continue;
+        let content = raw;
+        let changed = false;
+        for (const [old, replacement] of Object.entries(REPLACEMENTS)) {
+            if (content.includes(old)) {
+                const regex = new RegExp(`(['"\`])${old.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\1`, 'g');
+                const updated = content.replace(regex, `$1${replacement}$1`);
+                if (updated !== content) {
+                    content = updated;
+                    changed = true;
+                    messages.push(`  ${c.green}✓${c.reset} ${f}: "${old}" → "${replacement}"`);
+                    fixed++;
+                }
+            }
+        }
+        if (changed) {
+            writeFileSync(fullPath, content);
+        }
+    }
+    return { fixed, messages };
+}

package/dist/types.d.ts

@@ -29,3 +29,6 @@ export interface VetConfig {
     };
     agents?: string[];
 }
+export interface DiffOptions {
+    since?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "vet your AI-generated code — one command, six checks, zero config",
   "type": "module",
   "bin": {