@safetnsr/vet 1.8.5 → 1.9.0

package/dist/checks/compact.d.ts

@@ -0,0 +1,26 @@
+import type { CheckResult } from '../types.js';
+interface SessionEntry {
+    type?: string;
+    role?: string;
+    content?: unknown;
+    meta?: {
+        type?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface CompactionEvent {
+    messageIndex: number;
+    summary: string;
+    preContext: string[];
+    droppedInstructions: string[];
+    droppedFilePaths: string[];
+    droppedIdentifiers: string[];
+}
+export declare function extractFilePaths(text: string): string[];
+export declare function extractIdentifiers(text: string): string[];
+export declare function extractInstructions(text: string): string[];
+export declare function detectCompactions(entries: SessionEntry[]): CompactionEvent[];
+export declare function checkCompact(cwd: string): Promise<CheckResult>;
+export declare function runCompactCommand(format: 'ascii' | 'json', sessionPath?: string): Promise<void>;
+export {};

package/dist/checks/compact.js

@@ -0,0 +1,280 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createInterface } from 'node:readline';
+import { c } from '../util.js';
+import { findLatestSession } from './receipt.js';
+// ── Extraction helpers ───────────────────────────────────────────────────────
+const FILE_PATH_RE = /(?:(?:\/[\w.@-]+)+(?:\/[\w.@-]+)*|[\w@-]+(?:\/[\w.@-]+)+)(?:\.\w+)?/g;
+const IDENTIFIER_RE = /\b(?:[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*|[a-z]+(?:_[a-z]+)+)\b/g;
+const INSTRUCTION_RE = /(?:^|\.\s+)((?:always|never|must|don't|do not)\s[^.!?\n]{5,})/gim;
+export function extractFilePaths(text) {
+    const matches = text.match(FILE_PATH_RE) || [];
+    // Deduplicate and filter out very short ones
+    return [...new Set(matches)].filter(m => m.includes('/') || m.includes('.'));
+}
+export function extractIdentifiers(text) {
+    const matches = text.match(IDENTIFIER_RE) || [];
+    return [...new Set(matches)];
+}
+export function extractInstructions(text) {
+    const results = [];
+    let match;
+    const re = new RegExp(INSTRUCTION_RE.source, INSTRUCTION_RE.flags);
+    while ((match = re.exec(text)) !== null) {
+        const instruction = match[1].trim();
+        if (instruction.length > 10)
+            results.push(instruction);
+    }
+    return [...new Set(results)];
+}
+function getTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map(block => {
+            if (typeof block === 'string')
+                return block;
+            if (block && typeof block === 'object') {
+                const b = block;
+                if (typeof b.text === 'string')
+                    return b.text;
+                if (typeof b.content === 'string')
+                    return b.content;
+            }
+            return '';
+        })
+            .join('\n');
+    }
+    return '';
+}
+// ── Core parsing ─────────────────────────────────────────────────────────────
+async function parseEntries(filePath) {
+    const entries = [];
+    const rl = createInterface({
+        input: fs.createReadStream(filePath, { encoding: 'utf-8' }),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            entries.push(JSON.parse(trimmed));
+        }
+        catch { /* skip malformed */ }
+    }
+    return entries;
+}
+function isCompactionEvent(entry, index, hasExchanges) {
+    // Explicit type markers
+    if (typeof entry.type === 'string' && /compact|summary/i.test(entry.type))
+        return true;
+    if (entry.meta && typeof entry.meta.type === 'string' && /compact/i.test(entry.meta.type))
+        return true;
+    // System message with long content after user/assistant exchanges
+    if (entry.role === 'system' && hasExchanges) {
+        const text = getTextContent(entry.content);
+        if (text.length > 500)
+            return true;
+    }
+    return false;
+}
+export function detectCompactions(entries) {
+    const events = [];
+    let hasExchanges = false;
+    let preContextTexts = [];
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const role = entry.role ||
+            (entry.message
+                ? entry.message?.role
+                : undefined);
+        if (role === 'user' || role === 'assistant') {
+            hasExchanges = true;
+            const text = getTextContent(entry.content);
+            if (text)
+                preContextTexts.push(text);
+        }
+        if (isCompactionEvent(entry, i, hasExchanges)) {
+            const summaryText = getTextContent(entry.content);
+            const preText = preContextTexts.join('\n');
+            // Extract keywords from pre-context
+            const preFilePaths = extractFilePaths(preText);
+            const preIdentifiers = extractIdentifiers(preText);
+            const preInstructions = extractInstructions(preText);
+            // Check which are absent from summary
+            const summaryLower = summaryText.toLowerCase();
+            const droppedFilePaths = preFilePaths.filter(fp => !summaryText.includes(fp));
+            const droppedIdentifiers = preIdentifiers.filter(id => !summaryLower.includes(id.toLowerCase()));
+            const droppedInstructions = preInstructions.filter(inst => {
+                // Check if the core of the instruction is preserved
+                const words = inst.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+                const preserved = words.filter(w => summaryLower.includes(w));
+                return preserved.length < words.length * 0.5;
+            });
+            events.push({
+                messageIndex: i,
+                summary: summaryText.slice(0, 200),
+                preContext: preContextTexts.slice(-5), // keep last 5 for context
+                droppedInstructions,
+                droppedFilePaths,
+                droppedIdentifiers,
+            });
+            // Reset pre-context after compaction (summary becomes the new context)
+            preContextTexts = [summaryText];
+            hasExchanges = false;
+        }
+    }
+    return events;
+}
+// ── Score calculation ────────────────────────────────────────────────────────
+function calculateScore(events) {
+    const issues = [];
+    for (const event of events) {
+        for (const inst of event.droppedInstructions) {
+            issues.push({
+                severity: 'error',
+                message: `compaction #${event.messageIndex}: dropped instruction: "${inst.slice(0, 80)}"`,
+                fixable: false,
+            });
+        }
+        for (const fp of event.droppedFilePaths) {
+            issues.push({
+                severity: 'warning',
+                message: `compaction #${event.messageIndex}: dropped file reference: ${fp}`,
+                fixable: false,
+            });
+        }
+        for (const id of event.droppedIdentifiers) {
+            issues.push({
+                severity: 'info',
+                message: `compaction #${event.messageIndex}: dropped identifier: ${id}`,
+                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, 100 - (errors * 30 + warnings * 15 + infos * 5));
+    return { score, issues };
+}
+// ── Check function (for full vet run) ────────────────────────────────────────
+export async function checkCompact(cwd) {
+    const sessionFile = findLatestSession();
+    if (!sessionFile) {
+        return {
+            name: 'compact',
+            score: 100,
+            maxScore: 100,
+            issues: [{ severity: 'info', message: 'no claude session files found (~/.claude/projects/)', fixable: false }],
+            summary: 'no session logs found',
+        };
+    }
+    let entries;
+    try {
+        entries = await parseEntries(sessionFile);
+    }
+    catch {
+        return {
+            name: 'compact',
+            score: 100,
+            maxScore: 100,
+            issues: [{ severity: 'warning', message: 'could not parse session file', fixable: false }],
+            summary: 'session parse error',
+        };
+    }
+    if (entries.length === 0) {
+        return {
+            name: 'compact',
+            score: 100,
+            maxScore: 100,
+            issues: [{ severity: 'info', message: 'session file is empty', fixable: false }],
+            summary: 'empty session file',
+        };
+    }
+    const events = detectCompactions(entries);
+    if (events.length === 0) {
+        return {
+            name: 'compact',
+            score: 100,
+            maxScore: 100,
+            issues: [],
+            summary: 'no compactions detected',
+        };
+    }
+    const { score, issues } = calculateScore(events);
+    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;
+    return {
+        name: 'compact',
+        score,
+        maxScore: 100,
+        issues,
+        summary: `${events.length} compaction${events.length !== 1 ? 's' : ''}: ${errors} instructions, ${warnings} file refs, ${infos} identifiers dropped`,
+    };
+}
+// ── Standalone subcommand ────────────────────────────────────────────────────
+export async function runCompactCommand(format, sessionPath) {
+    const filePath = sessionPath || findLatestSession();
+    if (!filePath) {
+        console.error('no claude session files found in ~/.claude/projects/');
+        process.exit(1);
+    }
+    if (!fs.existsSync(filePath) && !sessionPath) {
+        console.error('session file not found');
+        process.exit(1);
+    }
+    const entries = await parseEntries(filePath);
+    const events = detectCompactions(entries);
+    const { score, issues } = calculateScore(events);
+    if (format === 'json') {
+        const result = {
+            name: 'compact',
+            score,
+            maxScore: 100,
+            issues,
+            summary: events.length === 0
+                ? 'no compactions detected'
+                : `${events.length} compaction${events.length !== 1 ? 's' : ''} found`,
+        };
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    // ASCII output
+    const sessionId = path.basename(filePath, '.jsonl').slice(0, 30);
+    console.log(`\n  ${c.bold}vet compact${c.reset} — compaction forensics\n`);
+    console.log(`  session: ${sessionId}`);
+    console.log(`  compactions found: ${events.length}\n`);
+    if (events.length === 0) {
+        console.log(`  ${c.green}no compactions detected${c.reset}\n`);
+        console.log(`  score: 100/100\n`);
+        return;
+    }
+    for (let i = 0; i < events.length; i++) {
+        const event = events[i];
+        console.log(`  compaction ${i + 1} (message #${event.messageIndex}):`);
+        for (const inst of event.droppedInstructions) {
+            console.log(`    ${c.red}✗${c.reset} dropped instruction: "${inst.slice(0, 60)}"`);
+        }
+        for (const fp of event.droppedFilePaths) {
+            console.log(`    ${c.yellow}⚠${c.reset} dropped file reference: ${fp}`);
+        }
+        for (const id of event.droppedIdentifiers) {
+            console.log(`    ${c.dim}i${c.reset} dropped identifier: ${id}`);
+        }
+        if (event.droppedInstructions.length === 0 &&
+            event.droppedFilePaths.length === 0 &&
+            event.droppedIdentifiers.length === 0) {
+            console.log(`    ${c.green}no drops detected${c.reset}`);
+        }
+        console.log('');
+    }
+    const totalInstructions = events.reduce((s, e) => s + e.droppedInstructions.length, 0);
+    const totalFileRefs = events.reduce((s, e) => s + e.droppedFilePaths.length, 0);
+    const totalIdentifiers = events.reduce((s, e) => s + e.droppedIdentifiers.length, 0);
+    console.log(`  total drops: ${totalInstructions} instructions, ${totalFileRefs} file refs, ${totalIdentifiers} identifiers`);
+    console.log(`  score: ${score}/100\n`);
+}

package/dist/checks/models.js

@@ -16,6 +16,10 @@ function isAiFramework(cwd) {
                 return true;
             if (Array.isArray(pkg.keywords) && pkg.keywords.some((k) => AI_PKG_KEYWORDS.has(k.toLowerCase())))
                 return true;
+            // Check if any AI SDK is in dependencies
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (aiDeps.some(d => allDeps[d]))
+                return true;
         }
         catch { /* skip */ }
     }

package/dist/cli.js

@@ -19,6 +19,7 @@ import { checkVerify } from './checks/verify.js';
 import { checkTests } from './checks/tests.js';
 import { checkMap, renderMapReport } from './checks/map.js';
 import { checkPermissions } from './checks/permissions.js';
+import { checkCompact, runCompactCommand } from './checks/compact.js';
 import { score } from './scorer.js';
 import { reportPretty, reportJSON, reportBadge } from './reporter.js';
 const args = process.argv.slice(2);
@@ -51,6 +52,7 @@ if (flags.has('--help') || flags.has('-h')) {
     npx @safetnsr/vet receipt            show last agent session receipt
     npx @safetnsr/vet map [dir]          show agent visibility map
     npx @safetnsr/vet permissions [dir]  audit Claude Code config for dangerous grants
+    npx @safetnsr/vet compact [log]      compaction forensics for claude code sessions
 
   ${c.dim}categories:${c.reset}
     security   (30%)  scan, secrets, config, model usage
@@ -85,7 +87,7 @@ if (flags.has('--version') || flags.has('-v')) {
     }
     process.exit(0);
 }
-const COMMANDS = ['init', 'receipt', 'map', 'permissions'];
+const COMMANDS = ['init', 'receipt', 'map', 'permissions', 'compact'];
 const command = COMMANDS.includes(positional[0]) ? positional[0] : undefined;
 const cwd = resolve(positional.find(p => !COMMANDS.includes(p)) || '.');
 const isCI = flags.has('--ci');
@@ -167,6 +169,18 @@ if (command === 'permissions') {
     }
     process.exit(result.score < 60 ? 1 : 0);
 }
+if (command === 'compact') {
+    try {
+        const format = isJSON ? 'json' : 'ascii';
+        const sessionArg = positional.find(p => p !== 'compact' && !COMMANDS.includes(p));
+        await runCompactCommand(format, sessionArg);
+    }
+    catch (e) {
+        console.error(`${c.red}compact failed:${c.reset}`, e instanceof Error ? e.message : e);
+        process.exit(1);
+    }
+    process.exit(0);
+}
 if (!isGitRepo(cwd)) {
     console.error(`${c.red}not a git repository${c.reset}. vet operates on git repos.`);
     process.exit(1);
@@ -218,6 +232,8 @@ async function runChecks() {
         const depsResult = await checkDeps(cwd);
         // Receipt is informational — fold into integrity category but keep low weight
         const receiptResult = await checkReceipt(cwd);
+        // Compact: compaction forensics
+        const compactResult = await checkCompact(cwd);
         // Memory: stale facts in agent memory files
         const memoryResult = checkMemory(cwd);
         // Verify: agent claim validation
@@ -226,7 +242,7 @@ async function runChecks() {
         const testsResult = checkTests(cwd, ignore);
         return score(cwd, {
             security: [scanResult, secretsResult, configResult, modelsResult, owaspResult, permissionsResult],
-            integrity: [diffResult, integrityResult, receiptResult, memoryResult, verifyResult, testsResult],
+            integrity: [diffResult, integrityResult, receiptResult, compactResult, memoryResult, verifyResult, testsResult],
             debt: [readyResult, historyResult, debtResult],
             deps: [depsResult],
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@safetnsr/vet",
-  "version": "1.8.5",
+  "version": "1.9.0",
   "description": "vet your AI-generated code — one command, one score card, one letter grade",
   "type": "module",
   "bin": {