compress-claude 1.0.0

package/dist/learning.js

@@ -0,0 +1,488 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTranscripts = findTranscripts;
+exports.parseTranscript = parseTranscript;
+exports.extractToolPairs = extractToolPairs;
+exports.getProjectDir = getProjectDir;
+exports.getAllProjectDirs = getAllProjectDirs;
+exports.findPatterns = findPatterns;
+exports.generateLearnings = generateLearnings;
+exports.applyLearnings = applyLearnings;
+exports.runLearn = runLearn;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger_1 = require("./utils/logger");
+// --- Helpers ---
+function isErrorContent(text) {
+    const errorPatterns = [
+        /error/i, /exception/i, /traceback/i, /failed/i,
+        /ENOENT/, /EACCES/, /SyntaxError/, /TypeError/,
+        /ReferenceError/, /command not found/,
+    ];
+    return errorPatterns.some((p) => p.test(text));
+}
+function findTranscripts(projectDir) {
+    const sessionsDir = path.join(projectDir, 'sessions');
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const entries = fs.readdirSync(sessionsDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const transcript = path.join(sessionsDir, entry.name, 'transcript.jsonl');
+            if (fs.existsSync(transcript))
+                files.push(transcript);
+        }
+    }
+    return files;
+}
+function parseTranscript(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw
+        .split('\n')
+        .filter((line) => line.trim().length > 0)
+        .map((line) => JSON.parse(line));
+}
+function extractToolPairs(messages) {
+    const pairs = [];
+    for (const msg of messages) {
+        if (typeof msg.content !== 'object' || !Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block.type === 'tool_result' || block.type === 'tool_use') {
+                // Simplified extraction
+                const toolName = block.name || '';
+                const input = block.input || {};
+                const resultText = typeof block.content === 'string'
+                    ? block.content
+                    : JSON.stringify(block.content || '');
+                const isError = !!(block.is_error);
+                pairs.push({
+                    tool: { name: toolName, input },
+                    resultText,
+                    contentSize: resultText.length,
+                    isError,
+                });
+            }
+        }
+    }
+    return pairs;
+}
+function getProjectDir(cwd) {
+    const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(claudeDir))
+        return null;
+    // Hash-based project directory lookup
+    const safeName = cwd.replace(/\//g, '-').replace(/^-/, '');
+    const candidates = fs.readdirSync(claudeDir).filter((d) => d.includes(safeName) || d === safeName);
+    if (candidates.length > 0)
+        return path.join(claudeDir, candidates[0]);
+    return null;
+}
+function getAllProjectDirs() {
+    const claudeDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!fs.existsSync(claudeDir))
+        return [];
+    return fs.readdirSync(claudeDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => path.join(claudeDir, d.name));
+}
+// --- Pattern Detection ---
+function findPatterns(pairs) {
+    const patterns = {
+        errorFixes: [],
+        readStorms: {},
+        retrySpirals: [],
+        largeResults: [],
+        failedSearches: [],
+        totalToolCalls: pairs.length,
+        totalResultTokens: 0,
+        toolBreakdown: {},
+    };
+    for (let i = 0; i < pairs.length; i++) {
+        const p = pairs[i];
+        const estTokens = Math.round(p.contentSize / 4);
+        patterns.totalResultTokens += estTokens;
+        // Tool breakdown
+        const tn = p.tool.name;
+        if (!patterns.toolBreakdown[tn])
+            patterns.toolBreakdown[tn] = { calls: 0, tokens: 0 };
+        patterns.toolBreakdown[tn].calls++;
+        patterns.toolBreakdown[tn].tokens += estTokens;
+        // Error -> Fix patterns
+        if (p.isError || isErrorContent(p.resultText)) {
+            for (let j = i + 1; j < Math.min(i + 10, pairs.length); j++) {
+                if (pairs[j].tool.name === p.tool.name && !pairs[j].isError && !isErrorContent(pairs[j].resultText)) {
+                    const failedInput = p.tool.name === 'Bash'
+                        ? (p.tool.input?.command || '')
+                        : JSON.stringify(p.tool.input || {}).substring(0, 200);
+                    const fixedInput = pairs[j].tool.name === 'Bash'
+                        ? (pairs[j].tool.input?.command || '')
+                        : JSON.stringify(pairs[j].tool.input || {}).substring(0, 200);
+                    // Extract clean error lines
+                    const errorMsg = p.resultText.split('\n')
+                        .map((l) => l.replace(/^\s*\d+[|\u2192\u2502]\s*/, '').trim())
+                        .filter((l) => l.length > 5 && l.length < 200 && isErrorContent(l))
+                        .slice(0, 2).join(' | ');
+                    if (errorMsg.length > 10) {
+                        patterns.errorFixes.push({
+                            tool: p.tool.name,
+                            failed: failedInput.substring(0, 300),
+                            fixed: fixedInput.substring(0, 300),
+                            error: errorMsg.substring(0, 200),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+        // Read storms (same file read 3+ times)
+        if (p.tool.name === 'Read' && p.tool.input?.file_path) {
+            const fp = p.tool.input.file_path;
+            patterns.readStorms[fp] = (patterns.readStorms[fp] || 0) + 1;
+        }
+        // Large results
+        if (p.contentSize > 5000) {
+            patterns.largeResults.push({
+                tool: p.tool.name,
+                input: p.tool.name === 'Bash'
+                    ? (p.tool.input?.command || '').substring(0, 100)
+                    : JSON.stringify(p.tool.input || {}).substring(0, 100),
+                size: p.contentSize,
+                tokens: estTokens,
+            });
+        }
+        // Failed searches (grep/glob with empty results)
+        if ((p.tool.name === 'Grep' || p.tool.name === 'Glob') && p.resultText.trim().length < 10) {
+            patterns.failedSearches.push({
+                tool: p.tool.name,
+                input: p.tool.input,
+            });
+        }
+    }
+    // Filter read storms to 3+
+    const stormEntries = Object.entries(patterns.readStorms).filter((e) => e[1] >= 3);
+    patterns.readStorms = {};
+    for (const [file, count] of stormEntries) {
+        patterns.readStorms[file] = count;
+    }
+    // Find retry spirals (same bash command 3+ times)
+    const bashCmds = pairs
+        .filter((pp) => pp.tool.name === 'Bash')
+        .map((pp) => (pp.tool.input?.command || '').trim().split('\n')[0]);
+    const cmdCounts = {};
+    for (const cmd of bashCmds) {
+        if (cmd)
+            cmdCounts[cmd] = (cmdCounts[cmd] || 0) + 1;
+    }
+    patterns.retrySpirals = Object.entries(cmdCounts)
+        .filter((e) => e[1] >= 3)
+        .map((e) => ({ command: e[0], count: e[1] }));
+    return patterns;
+}
+// --- Learning Generation ---
+function generateLearnings(allPatterns) {
+    const learnings = [];
+    const seen = {};
+    for (const patterns of allPatterns) {
+        // Error->Fix learnings
+        for (const ef of patterns.errorFixes) {
+            const key = `${ef.tool}:${ef.error.substring(0, 50)}`;
+            if (seen[key])
+                continue;
+            seen[key] = true;
+            learnings.push({
+                type: 'mistake',
+                severity: 'high',
+                text: `When using ${ef.tool}: "${ef.error.substring(0, 120)}" -- Fix: use the corrected approach instead of retrying the same thing.`,
+                failed: ef.failed.substring(0, 150),
+                fixed: ef.fixed.substring(0, 150),
+            });
+        }
+        // Read storm learnings
+        const stormFiles = Object.entries(patterns.readStorms);
+        for (const [file, count] of stormFiles) {
+            const key2 = `readstorm:${file}`;
+            if (seen[key2])
+                continue;
+            seen[key2] = true;
+            learnings.push({
+                type: 'optimization',
+                severity: 'medium',
+                text: `File "${file}" was read ${count} times in one session. Read once and reference from context.`,
+            });
+        }
+        // Retry spirals
+        for (const rs of patterns.retrySpirals) {
+            const key3 = `retry:${rs.command.substring(0, 50)}`;
+            if (seen[key3])
+                continue;
+            seen[key3] = true;
+            learnings.push({
+                type: 'mistake',
+                severity: 'medium',
+                text: `Command retried ${rs.count} times: "${rs.command.substring(0, 100)}". Diagnose the root cause instead of retrying.`,
+            });
+        }
+    }
+    // Deduplicate by similar text
+    const unique = [];
+    const seenTexts = {};
+    for (const learning of learnings) {
+        const normalized = learning.text.substring(0, 80).toLowerCase();
+        if (!seenTexts[normalized]) {
+            seenTexts[normalized] = true;
+            unique.push(learning);
+        }
+    }
+    return unique;
+}
+// --- Apply Learnings to Files ---
+function applyLearnings(cwd, learnings) {
+    if (learnings.length === 0)
+        return { applied: 0, files: [] };
+    const files = [];
+    const mistakesPath = path.join(cwd, 'ai-docs', 'MISTAKES.md');
+    const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+    const globalClaudeMd = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+    const mistakeEntries = learnings.filter((l) => l.type === 'mistake');
+    const highSeverity = learnings.filter((l) => l.severity === 'high');
+    // Append to MISTAKES.md
+    if (mistakeEntries.length > 0 && fs.existsSync(path.join(cwd, 'ai-docs'))) {
+        let existing = '';
+        try {
+            existing = fs.readFileSync(mistakesPath, 'utf8');
+        }
+        catch {
+            existing = '# MISTAKES.md -- Learned from Sessions\n\n';
+        }
+        let newSection = `\n## Auto-learned (${new Date().toISOString().split('T')[0]})\n\n`;
+        for (const m of mistakeEntries) {
+            if (existing.includes(m.text.substring(0, 60)))
+                continue;
+            newSection += `- ${m.text}\n`;
+            if (m.failed)
+                newSection += `  - Failed: \`${m.failed.substring(0, 120)}\`\n`;
+            if (m.fixed)
+                newSection += `  - Fixed: \`${m.fixed.substring(0, 120)}\`\n`;
+        }
+        if (newSection.split('\n').length > 3) {
+            const dir = path.dirname(mistakesPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(mistakesPath, existing + newSection, 'utf8');
+            files.push('ai-docs/MISTAKES.md');
+        }
+    }
+    // Append critical learnings to CLAUDE.md
+    if (highSeverity.length > 0 && fs.existsSync(claudeMdPath)) {
+        let claudeContent = fs.readFileSync(claudeMdPath, 'utf8');
+        const learnedHeader = '\n## Learned from Sessions\n';
+        if (!claudeContent.includes('## Learned from Sessions')) {
+            claudeContent += learnedHeader;
+        }
+        let newItems = '';
+        for (const hs of highSeverity) {
+            const shortText = hs.text.substring(0, 150);
+            if (claudeContent.includes(shortText.substring(0, 60)))
+                continue;
+            newItems += `- ${shortText}\n`;
+        }
+        if (newItems) {
+            claudeContent = claudeContent.replace('## Learned from Sessions\n', `## Learned from Sessions\n${newItems}`);
+            fs.writeFileSync(claudeMdPath, claudeContent, 'utf8');
+            files.push('CLAUDE.md');
+        }
+    }
+    // Write to memory dir if it exists
+    let memoryDir = null;
+    const projectDir = getProjectDir(cwd);
+    if (projectDir) {
+        memoryDir = path.join(projectDir, 'memory');
+        if (!fs.existsSync(memoryDir)) {
+            try {
+                fs.mkdirSync(memoryDir, { recursive: true });
+            }
+            catch {
+                memoryDir = null;
+            }
+        }
+    }
+    if (memoryDir) {
+        const memoryFile = path.join(memoryDir, 'session-learnings.md');
+        let memContent = '';
+        try {
+            memContent = fs.readFileSync(memoryFile, 'utf8');
+        }
+        catch {
+            memContent = '# Session Learnings\n\nAuto-generated by compress-claude --learn. Claude reads this every session.\n\n';
+        }
+        let newMemory = '';
+        for (const learning of learnings) {
+            if (memContent.includes(learning.text.substring(0, 60)))
+                continue;
+            newMemory += `- ${learning.text}\n`;
+        }
+        if (newMemory) {
+            fs.writeFileSync(memoryFile, memContent + newMemory, 'utf8');
+            files.push('~/.claude/projects/.../memory/session-learnings.md');
+        }
+    }
+    // Write critical patterns to global CLAUDE.md
+    if (highSeverity.length > 0) {
+        let globalContent = '';
+        try {
+            globalContent = fs.readFileSync(globalClaudeMd, 'utf8');
+        }
+        catch {
+            globalContent = '';
+        }
+        if (!globalContent.includes('## Session Learnings (global)')) {
+            globalContent += '\n## Session Learnings (global)\n';
+        }
+        let globalNew = '';
+        for (const hs of highSeverity) {
+            const gText = hs.text.substring(0, 150);
+            if (globalContent.includes(gText.substring(0, 60)))
+                continue;
+            globalNew += `- ${gText}\n`;
+        }
+        if (globalNew) {
+            globalContent = globalContent.replace('## Session Learnings (global)\n', `## Session Learnings (global)\n${globalNew}`);
+            fs.writeFileSync(globalClaudeMd, globalContent, 'utf8');
+            files.push('~/.claude/CLAUDE.md');
+        }
+    }
+    return { applied: learnings.length, files };
+}
+async function runLearn(cwd, opts) {
+    const options = opts || {};
+    const allProjects = options.all || false;
+    (0, logger_1.log)('LEARN', 'start', 'Starting learn analysis');
+    let dirs = [];
+    if (allProjects) {
+        dirs = getAllProjectDirs();
+        (0, logger_1.log)('LEARN', 'scan', `Scanning all projects (${dirs.length} found)`);
+    }
+    else {
+        const projDir = getProjectDir(cwd);
+        if (!projDir) {
+            (0, logger_1.logWarn)('LEARN', 'scan', 'No Claude Code sessions found for this project');
+            return;
+        }
+        dirs = [projDir];
+    }
+    const allPatterns = [];
+    let totalTranscripts = 0;
+    let totalPairs = 0;
+    for (const dir of dirs) {
+        const transcripts = findTranscripts(dir);
+        for (const transcript of transcripts) {
+            totalTranscripts++;
+            try {
+                const messages = parseTranscript(transcript);
+                const pairs = extractToolPairs(messages);
+                totalPairs += pairs.length;
+                if (pairs.length > 0) {
+                    const patterns = findPatterns(pairs);
+                    allPatterns.push(patterns);
+                }
+            }
+            catch {
+                // Skip corrupt transcripts
+            }
+        }
+    }
+    (0, logger_1.log)('LEARN', 'analyzed', `Sessions: ${totalTranscripts}, Tool calls: ${totalPairs}`);
+    if (allPatterns.length === 0) {
+        (0, logger_1.logWarn)('LEARN', 'result', 'No patterns found yet. Use Claude Code more, then run --learn again.');
+        return;
+    }
+    // Aggregate stats
+    let totalTokensInResults = 0;
+    let totalErrorFixes = 0;
+    let totalReadStorms = 0;
+    let totalRetries = 0;
+    let totalLargeResults = 0;
+    const toolBreakdown = {};
+    for (const p of allPatterns) {
+        totalTokensInResults += p.totalResultTokens;
+        totalErrorFixes += p.errorFixes.length;
+        totalReadStorms += Object.keys(p.readStorms).length;
+        totalRetries += p.retrySpirals.length;
+        totalLargeResults += p.largeResults.length;
+        for (const [key, stats] of Object.entries(p.toolBreakdown)) {
+            if (!toolBreakdown[key])
+                toolBreakdown[key] = { calls: 0, tokens: 0 };
+            toolBreakdown[key].calls += stats.calls;
+            toolBreakdown[key].tokens += stats.tokens;
+        }
+    }
+    (0, logger_1.log)('LEARN', 'tokens', `Result tokens: ~${totalTokensInResults.toLocaleString()}`);
+    // Show tool breakdown
+    (0, logger_1.log)('LEARN', 'breakdown', 'Token usage by tool:');
+    const sorted = Object.entries(toolBreakdown).sort((a, b) => b[1].tokens - a[1].tokens);
+    for (const [name, stats] of sorted) {
+        const pct = Math.round((stats.tokens / totalTokensInResults) * 100) || 0;
+        (0, logger_1.log)('LEARN', 'tool', `${name.padEnd(14)} ${stats.tokens.toLocaleString()} tokens  ${stats.calls} calls  ${pct}%`);
+    }
+    (0, logger_1.log)('LEARN', 'patterns', `Error->Fix: ${totalErrorFixes}, Read storms: ${totalReadStorms}, Retry spirals: ${totalRetries}, Oversized: ${totalLargeResults}`);
+    // Generate and apply learnings
+    const learnings = generateLearnings(allPatterns);
+    if (learnings.length === 0) {
+        (0, logger_1.log)('LEARN', 'result', 'No new learnings to apply -- sessions look clean.');
+        return;
+    }
+    (0, logger_1.log)('LEARN', 'generated', `Generated ${learnings.length} learnings`);
+    for (let i = 0; i < Math.min(learnings.length, 10); i++) {
+        const severity = learnings[i].severity === 'high' ? '!!' : ' !';
+        (0, logger_1.log)('LEARN', 'learning', `${severity} ${learnings[i].text.substring(0, 120)}`);
+    }
+    if (learnings.length > 10) {
+        (0, logger_1.log)('LEARN', 'learning', `... and ${learnings.length - 10} more`);
+    }
+    // Apply
+    const result = applyLearnings(cwd, learnings);
+    if (result.files.length > 0) {
+        (0, logger_1.log)('LEARN', 'applied', `Applied to: ${result.files.join(', ')}`);
+        (0, logger_1.log)('LEARN', 'info', 'Claude will see these learnings in every future session. Run --learn weekly.');
+    }
+    else {
+        (0, logger_1.log)('LEARN', 'result', 'All learnings already applied. Nothing new to add.');
+    }
+}
+//# sourceMappingURL=learning.js.map

package/dist/license.d.ts

@@ -0,0 +1,7 @@
+export interface LicenseConfig {
+    key?: string;
+}
+export declare function getLicenseKey(): string | undefined;
+export declare function isLicensed(): boolean;
+export declare function saveLicenseKey(key: string): void;
+//# sourceMappingURL=license.d.ts.map

package/dist/license.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLicenseKey = getLicenseKey;
+exports.isLicensed = isLicensed;
+exports.saveLicenseKey = saveLicenseKey;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = path.join(os.homedir(), '.compress-claude');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+function getLicenseKey() {
+    // Check env var COMPRESS_CLAUDE_KEY first, then ~/.compress-claude/config.json
+    return process.env.COMPRESS_CLAUDE_KEY || readConfigKey();
+}
+function isLicensed() {
+    return !!getLicenseKey();
+}
+function readConfigKey() {
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+        const config = JSON.parse(raw);
+        return config.key;
+    }
+    catch {
+        return undefined;
+    }
+}
+function saveLicenseKey(key) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    let config = {};
+    try {
+        config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+    catch {
+        config = {};
+    }
+    config.key = key;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+//# sourceMappingURL=license.js.map

package/dist/proxy/compressors.d.ts

@@ -0,0 +1,5 @@
+export declare function compressContent(content: string): string;
+export declare function isErrorContent(text: string): boolean;
+export declare function compressToolResult(content: string, toolName?: string): string;
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=compressors.d.ts.map