@safetnsr/vet 1.20.0 → 1.21.0

package/dist/checks/context.d.ts

@@ -0,0 +1,3 @@
+import type { CheckResult } from '../types.js';
+export declare function checkContext(cwd: string): CheckResult;
+export declare function runContextCommand(format: string, cwd: string): Promise<void>;

package/dist/checks/context.js

@@ -0,0 +1,359 @@
+import { join } from 'node:path';
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { c } from '../util.js';
+import { cachedReadFile } from '../file-cache.js';
+// ── Tiktoken lazy init ───────────────────────────────────────────────────────
+import { encodingForModel } from 'js-tiktoken';
+let _encoder = null;
+function getEncoder() {
+    if (!_encoder) {
+        _encoder = encodingForModel('gpt-4');
+    }
+    return _encoder;
+}
+function countTokens(text) {
+    return getEncoder().encode(text).length;
+}
+// ── Constants ────────────────────────────────────────────────────────────────
+const CONTEXT_FILES = ['CLAUDE.md', 'AGENTS.md', 'SOUL.md', '.cursorrules', 'codex.md'];
+const CURSOR_RULES_DIR = join('.cursor', 'rules');
+const MEMORY_DIR = 'memory';
+const DAILY_DIR = join(MEMORY_DIR, 'daily');
+const MODEL_COSTS = {
+    opus: 15, // $15 per MTok input
+    sonnet: 3, // $3 per MTok input
+    haiku: 0.25, // $0.25 per MTok input
+};
+const TOKEN_THRESHOLD = 8000;
+const BLOATED_FILE_THRESHOLD = 10000;
+function splitIntoSections(content, file) {
+    const lines = content.split('\n');
+    const sections = [];
+    let currentTitle = '(intro)';
+    let currentLines = [];
+    for (const line of lines) {
+        const headerMatch = line.match(/^(#{2,3})\s+(.+)/);
+        if (headerMatch) {
+            // flush previous
+            if (currentLines.length > 0) {
+                const text = currentLines.join('\n');
+                sections.push({ title: currentTitle, content: text, tokens: countTokens(text), file });
+            }
+            currentTitle = headerMatch[2].trim();
+            currentLines = [line];
+        }
+        else {
+            currentLines.push(line);
+        }
+    }
+    // flush last
+    if (currentLines.length > 0) {
+        const text = currentLines.join('\n');
+        sections.push({ title: currentTitle, content: text, tokens: countTokens(text), file });
+    }
+    return sections;
+}
+// ── File discovery ───────────────────────────────────────────────────────────
+function discoverContextFiles(cwd) {
+    const files = [];
+    for (const name of CONTEXT_FILES) {
+        const full = join(cwd, name);
+        if (existsSync(full))
+            files.push(full);
+    }
+    // memory/*.md (not daily/)
+    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 */ }
+    }
+    // .cursor/rules
+    const cursorDir = join(cwd, CURSOR_RULES_DIR);
+    if (existsSync(cursorDir) && statSync(cursorDir).isDirectory()) {
+        try {
+            for (const entry of readdirSync(cursorDir)) {
+                const full = join(cursorDir, entry);
+                try {
+                    if (statSync(full).isFile())
+                        files.push(full);
+                }
+                catch { /* skip */ }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return files;
+}
+// ── Stale detection ──────────────────────────────────────────────────────────
+function detectStaleSections(sections) {
+    const stale = new Set();
+    const claudeDir = join(homedir(), '.claude', 'projects');
+    if (!existsSync(claudeDir))
+        return stale;
+    // Collect recent session log content
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    let sessionContent = '';
+    try {
+        const projects = readdirSync(claudeDir);
+        for (const project of projects) {
+            const projectDir = join(claudeDir, project);
+            try {
+                if (!statSync(projectDir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            try {
+                const files = readdirSync(projectDir);
+                for (const file of files) {
+                    if (!file.endsWith('.jsonl'))
+                        continue;
+                    const full = join(projectDir, file);
+                    try {
+                        const stat = statSync(full);
+                        if (stat.mtimeMs < sevenDaysAgo)
+                            continue;
+                        sessionContent += readFileSync(full, 'utf-8') + '\n';
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch {
+        return stale;
+    }
+    if (!sessionContent)
+        return stale;
+    // Check each section: extract significant phrases and grep
+    for (const section of sections) {
+        if (section.title === '(intro)')
+            continue;
+        // Extract significant words from section content (skip short/generic)
+        const words = section.content
+            .replace(/[#`*_\-\[\](){}|]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 4);
+        // Take a sample of phrases to check
+        const phrases = words.slice(0, 20);
+        if (phrases.length === 0)
+            continue;
+        const found = phrases.some(phrase => sessionContent.includes(phrase));
+        if (!found) {
+            stale.add(`${section.file}::${section.title}`);
+        }
+    }
+    return stale;
+}
+// ── Cost calculation ─────────────────────────────────────────────────────────
+function calculateCost(tokens, model) {
+    const rate = MODEL_COSTS[model] || 3;
+    return (tokens / 1_000_000) * rate;
+}
+function formatCost(cost) {
+    if (cost < 0.001)
+        return `$${cost.toFixed(6)}`;
+    if (cost < 0.01)
+        return `$${cost.toFixed(4)}`;
+    return `$${cost.toFixed(3)}`;
+}
+// ── CheckResult (for full vet scan) ──────────────────────────────────────────
+export function checkContext(cwd) {
+    const files = discoverContextFiles(cwd);
+    const issues = [];
+    let score = 100;
+    if (files.length === 0) {
+        score -= 15;
+        issues.push({
+            severity: 'error',
+            message: 'No agent context files found',
+            fixable: false,
+        });
+        return {
+            name: 'context',
+            score: Math.max(0, score),
+            maxScore: 100,
+            issues,
+            summary: 'no agent context files found',
+        };
+    }
+    const allSections = [];
+    let totalTokens = 0;
+    for (const filePath of files) {
+        const content = cachedReadFile(filePath);
+        if (!content)
+            continue;
+        const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+        const sections = splitIntoSections(content, relPath);
+        allSections.push(...sections);
+        const fileTokens = sections.reduce((sum, s) => sum + s.tokens, 0);
+        totalTokens += fileTokens;
+        if (fileTokens > BLOATED_FILE_THRESHOLD) {
+            issues.push({
+                severity: 'warning',
+                message: `Context file exceeds 10K tokens: ${relPath} (${fileTokens} tokens)`,
+                file: relPath,
+                fixable: false,
+                fixHint: 'Split or trim this file to reduce token cost',
+            });
+            score -= 5;
+        }
+    }
+    // Stale detection
+    const staleSections = detectStaleSections(allSections);
+    let staleDeduction = 0;
+    let staleSavings = 0;
+    for (const key of staleSections) {
+        const [file, title] = key.split('::');
+        const section = allSections.find(s => s.file === file && s.title === title);
+        if (section)
+            staleSavings += section.tokens;
+        if (staleDeduction < 40) {
+            issues.push({
+                severity: 'warning',
+                message: `Stale section: "${title}" in ${file}`,
+                file,
+                fixable: false,
+                fixHint: 'Section not referenced in recent sessions — consider removing',
+            });
+            staleDeduction += 10;
+        }
+    }
+    score -= Math.min(staleDeduction, 40);
+    // Token threshold penalty
+    if (totalTokens > TOKEN_THRESHOLD) {
+        const over = totalTokens - TOKEN_THRESHOLD;
+        const penalty = Math.min(Math.floor(over / 2000) * 5, 30);
+        score -= penalty;
+    }
+    // Info issues
+    issues.push({
+        severity: 'info',
+        message: `Total context: ${totalTokens} tokens across ${files.length} file${files.length !== 1 ? 's' : ''}`,
+        fixable: false,
+    });
+    if (staleSavings > 0) {
+        const savings = formatCost(calculateCost(staleSavings, 'sonnet'));
+        issues.push({
+            severity: 'info',
+            message: `Potential savings: ${staleSavings} tokens (${savings}/call at sonnet rates) from removing stale sections`,
+            fixable: false,
+        });
+    }
+    return {
+        name: 'context',
+        score: Math.max(0, score),
+        maxScore: 100,
+        issues,
+        summary: `${totalTokens} tokens in ${files.length} context file${files.length !== 1 ? 's' : ''}${staleSections.size > 0 ? `, ${staleSections.size} stale section${staleSections.size !== 1 ? 's' : ''}` : ''}`,
+    };
+}
+// ── Subcommand output ────────────────────────────────────────────────────────
+export async function runContextCommand(format, cwd) {
+    const files = discoverContextFiles(cwd);
+    if (files.length === 0) {
+        if (format === 'json') {
+            console.log(JSON.stringify({ files: [], sections: [], totalTokens: 0, costs: {}, stale: [], score: 0 }, null, 2));
+        }
+        else {
+            console.log(`\n  ${c.bold}vet context${c.reset} — no agent context files found\n`);
+        }
+        return;
+    }
+    const allSections = [];
+    let totalTokens = 0;
+    for (const filePath of files) {
+        const content = cachedReadFile(filePath);
+        if (!content)
+            continue;
+        const relPath = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+        const sections = splitIntoSections(content, relPath);
+        allSections.push(...sections);
+        totalTokens += sections.reduce((sum, s) => sum + s.tokens, 0);
+    }
+    const staleSections = detectStaleSections(allSections);
+    if (format === 'json') {
+        const result = {
+            files: files.map(f => f.startsWith(cwd) ? f.slice(cwd.length + 1) : f),
+            sections: allSections.map(s => ({
+                file: s.file,
+                title: s.title,
+                tokens: s.tokens,
+                stale: staleSections.has(`${s.file}::${s.title}`),
+                costs: {
+                    opus: calculateCost(s.tokens, 'opus'),
+                    sonnet: calculateCost(s.tokens, 'sonnet'),
+                    haiku: calculateCost(s.tokens, 'haiku'),
+                },
+            })),
+            totalTokens,
+            costs: {
+                opus: calculateCost(totalTokens, 'opus'),
+                sonnet: calculateCost(totalTokens, 'sonnet'),
+                haiku: calculateCost(totalTokens, 'haiku'),
+            },
+            stale: [...staleSections],
+            staleSavingsTokens: allSections
+                .filter(s => staleSections.has(`${s.file}::${s.title}`))
+                .reduce((sum, s) => sum + s.tokens, 0),
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // ASCII table output
+    console.log(`\n  ${c.bold}vet context${c.reset} — agent context cost audit\n`);
+    // Header
+    const fileW = 30;
+    const sectionW = 25;
+    const tokenW = 8;
+    const costW = 12;
+    console.log(`  ${c.dim}${'─'.repeat(fileW + sectionW + tokenW + costW * 3 + 10)}${c.reset}`);
+    console.log(`  ${pad('File', fileW)} ${pad('Section', sectionW)} ${padR('Tokens', tokenW)} ${padR('Opus', costW)} ${padR('Sonnet', costW)} ${padR('Haiku', costW)}`);
+    console.log(`  ${c.dim}${'─'.repeat(fileW + sectionW + tokenW + costW * 3 + 10)}${c.reset}`);
+    for (const s of allSections) {
+        const isStale = staleSections.has(`${s.file}::${s.title}`);
+        const staleMarker = isStale ? ` ${c.yellow}⚠ stale${c.reset}` : '';
+        const file = truncate(s.file, fileW);
+        const title = truncate(s.title, sectionW);
+        console.log(`  ${pad(file, fileW)} ${pad(title, sectionW)} ${padR(String(s.tokens), tokenW)} ${padR(formatCost(calculateCost(s.tokens, 'opus')), costW)} ${padR(formatCost(calculateCost(s.tokens, 'sonnet')), costW)} ${padR(formatCost(calculateCost(s.tokens, 'haiku')), costW)}${staleMarker}`);
+    }
+    console.log(`  ${c.dim}${'─'.repeat(fileW + sectionW + tokenW + costW * 3 + 10)}${c.reset}`);
+    console.log(`  ${pad(c.bold + 'Total' + c.reset, fileW)} ${pad('', sectionW)} ${padR(String(totalTokens), tokenW)} ${padR(formatCost(calculateCost(totalTokens, 'opus')), costW)} ${padR(formatCost(calculateCost(totalTokens, 'sonnet')), costW)} ${padR(formatCost(calculateCost(totalTokens, 'haiku')), costW)}`);
+    console.log('');
+    if (staleSections.size > 0) {
+        const staleToks = allSections
+            .filter(s => staleSections.has(`${s.file}::${s.title}`))
+            .reduce((sum, s) => sum + s.tokens, 0);
+        console.log(`  ${c.yellow}⚠ ${staleSections.size} stale section${staleSections.size !== 1 ? 's' : ''} detected${c.reset} — ${staleToks} tokens (${formatCost(calculateCost(staleToks, 'sonnet'))}/call at sonnet rates)`);
+        console.log(`  ${c.dim}These sections weren't referenced in recent Claude sessions${c.reset}\n`);
+    }
+}
+// ── String helpers ───────────────────────────────────────────────────────────
+function pad(s, w) {
+    // Strip ANSI for length calculation
+    const clean = s.replace(/\x1b\[[0-9;]*m/g, '');
+    return s + ' '.repeat(Math.max(0, w - clean.length));
+}
+function padR(s, w) {
+    const clean = s.replace(/\x1b\[[0-9;]*m/g, '');
+    return ' '.repeat(Math.max(0, w - clean.length)) + s;
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 1) + '…';
+}

package/dist/checks/deep.js

@@ -26,10 +26,16 @@ function analyzeCatch(node) {
     const block = node.block;
     const stmts = block.statements;
     const line = node.getSourceFile().getLineAndCharacterOfPosition(node.getStart()).line + 1;
+    const text = block.getText();
     if (stmts.length === 0) {
+        // Check if there's a deliberate comment (/* skip */, /* ignore */, etc.)
+        const hasComment = /\/[/*]\s*(skip|ignore|noop|intentional|expected|ok|no-op)/i.test(text);
+        if (hasComment) {
+            // Deliberate empty catch — not a bug
+            return { line, isEmpty: false, isLazy: false, isRethrow: false };
+        }
         return { line, isEmpty: true, isLazy: false, isRethrow: false };
     }
-    const text = block.getText();
     const isLazy = stmts.length === 1 && /console\.(log|error|warn)\s*\(/.test(text) && !text.includes('throw');
     const isRethrow = text.includes('throw');
     return { line, isEmpty: false, isLazy, isRethrow };

package/dist/checks/deps.js

@@ -311,6 +311,16 @@ const TOOLING_PACKAGES = new Set([
     'del-cli', 'make-node',
     // Type packages (consumed by TS compiler, not imported)
     '@types/react', '@types/react-dom', '@types/jest', '@types/mocha',
+    // Test runners / e2e (used via CLI, not imported)
+    'playwright', '@playwright/test', 'cypress', 'puppeteer',
+    // Package quality tools (used via CLI)
+    'publint', 'arethetypeswrong', 'are-the-types-wrong', 'attw',
+    'pkg-pr-new', 'size-limit', '@size-limit/preset-small-lib',
+    // Monorepo/workspace tools
+    'update-ts-references', 'syncpack', 'manypkg',
+    // Prettier plugins (loaded via config, not imported)
+    'prettier-plugin-svelte', 'prettier-plugin-tailwindcss',
+    'prettier-plugin-organize-imports', 'prettier-plugin-packagejson',
 ]);
 // ── Collect all deps declared in workspace sub-packages ──────────────────────
 export function collectWorkspaceDeps(cwd) {
@@ -500,6 +510,11 @@ export async function checkDeps(cwd) {
                 // Skip known tooling packages that are devDependencies (used via CLI scripts, not imports)
                 if (TOOLING_PACKAGES.has(pkg) && devDepNames.has(pkg))
                     continue;
+                // Wildcard tooling patterns (eslint configs, prettier plugins, @types/*)
+                if (devDepNames.has(pkg) && (pkg.startsWith('eslint-config-') || pkg.startsWith('eslint-plugin-') ||
+                    pkg.startsWith('prettier-plugin-') || pkg.startsWith('@types/') ||
+                    pkg.startsWith('@typescript-eslint/') || pkg.startsWith('@eslint/')))
+                    continue;
                 // Check if it's a CLI tool / plugin / type package (common false positives)
                 // Still flag it, but as info
                 issues.push({

package/dist/checks/semantic.js

@@ -130,7 +130,7 @@ export async function checkSemantic(cwd) {
             patternEmbeddings.push({ pattern, embedding: new Float32Array(result.data) });
         }
         // Embed and compare each function
-        const THRESHOLD = 0.40; // similarity threshold — code-to-code embeddings
+        const THRESHOLD = 0.45; // similarity threshold — code-to-code embeddings (0.40 gave false positives)
         for (const func of funcsToAnalyze) {
             const result = await extractor(func.body, { pooling: 'mean', normalize: true });
             const funcEmb = new Float32Array(result.data);

package/dist/cli.js

@@ -31,6 +31,7 @@ import { checkLoop, runLoopCommand } from './checks/loop.js';
 import { checkBloat, runBloatCommand } from './checks/bloat.js';
 import { checkGuard, runGuardCommand } from './checks/guard.js';
 import { checkExplain, runExplainCommand } from './checks/explain.js';
+import { checkContext, runContextCommand } from './checks/context.js';
 import { checkCompleteness } from './checks/completeness.js';
 import { score } from './scorer.js';
 import { reportPretty, reportJSON, reportBadge } from './reporter.js';
@@ -86,6 +87,7 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet bloat              detect agent-generated code bloat
     npx @safetnsr/vet guard [dir]        scan for destructive operation bomb sites
     npx @safetnsr/vet explain [--since REF] [--verbose] [--json]  risk-tier agent changes
+    npx @safetnsr/vet context [dir]    audit agent context files for token cost + stale sections
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -121,7 +123,7 @@ if (flags.has('--version') || flags.has('-v')) {
     }
     process.exit(0);
 }
-const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact', 'subsidy', 'loop', 'bloat', 'guard', 'explain', 'context'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -263,6 +265,17 @@ if (command === 'guard') {
     }
     process.exit(0);
 }
+if (command === 'context') {
+    try {
+        const format = isJSON ? 'json' : 'ascii';
+        await runContextCommand(format, cwd);
+    }
+    catch (e) {
+        console.error(`${c.red}context failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 if (command === 'explain') {
     try {
         const format = isJSON ? 'json' : 'ascii';
@@ -327,7 +340,7 @@ async function runChecks() {
             }
         }
         // Run ALL independent checks in parallel
-        const [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, bloatResult, guardResult, explainResult, architectureResult, aireadyResult, deepResult, semanticResult, hotspotsResult, clonesResult,] = await Promise.all([
+        const [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult, integrityResult, readyResult, debtResult, depsResult, receiptResult, compactResult, subsidyResult, memoryResult, verifyResult, testsResult, loopResult, completenessResult, bloatResult, guardResult, explainResult, architectureResult, aireadyResult, deepResult, semanticResult, hotspotsResult, clonesResult, contextResult,] = await Promise.all([
             withTimeout('scan', () => checkScan(cwd)),
             withTimeout('secrets', () => checkSecrets(cwd)),
             withTimeout('config', () => checkConfig(cwd, ignore)),
@@ -355,6 +368,7 @@ async function runChecks() {
             withTimeout('semantic', () => checkSemantic(cwd), 60_000),
             withTimeout('hotspots', () => checkHotspots(cwd), 30_000),
             withTimeout('clones', () => checkClones(cwd), 60_000),
+            withTimeout('context', () => checkContext(cwd)),
         ]);
         // Git-dependent checks (diff + history) — parallel with each other
         const [diffResult, historyResult] = await Promise.all([
@@ -369,7 +383,7 @@ async function runChecks() {
             debt: [readyResult, historyResult, debtResult, bloatResult, clonesResult],
             deps: [depsResult],
             architecture: [architectureResult],
-            aiready: [aireadyResult, deepResult, semanticResult],
+            aiready: [aireadyResult, deepResult, semanticResult, contextResult],
             history: [hotspotsResult],
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "description": "vet your AI-generated code — one command, one score card, one letter grade",
   "type": "module",
   "bin": {
@@ -44,6 +44,7 @@
     "@safetnsr/model-graveyard": "^0.2.0"
   },
   "dependencies": {
-    "@huggingface/transformers": "^3.8.1"
+    "@huggingface/transformers": "^3.8.1",
+    "js-tiktoken": "^1.0.21"
   }
 }