compress-claude 1.0.0

package/dist/hooks.d.ts

@@ -0,0 +1,2 @@
+export declare function installHooks(cwd: string): Promise<void>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.js

@@ -0,0 +1,101 @@
+"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.installHooks = installHooks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const logger_1 = require("./utils/logger");
+// --- Hooks Installer ---
+async function installHooks(cwd) {
+    (0, logger_1.log)('HOOKS', 'start', 'Installing hooks');
+    // Ensure .claude directory exists
+    const settingsDir = path.join(cwd, '.claude');
+    if (!fs.existsSync(settingsDir)) {
+        fs.mkdirSync(settingsDir, { recursive: true });
+    }
+    const settingsFile = path.join(settingsDir, 'settings.json');
+    let settings = {};
+    try {
+        settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
+    }
+    catch {
+        settings = {};
+    }
+    // Add post-session hook to run learn
+    if (!settings.hooks)
+        settings.hooks = {};
+    const learnCmd = 'npx compress-claude --learn 2>/dev/null || true';
+    if (!settings.hooks.stop)
+        settings.hooks.stop = [];
+    const hasLearnHook = settings.hooks.stop.some((h) => h.command && h.command.includes('compress-claude --learn'));
+    if (!hasLearnHook) {
+        settings.hooks.stop.push({
+            matcher: '',
+            command: learnCmd,
+        });
+        (0, logger_1.log)('HOOKS', 'install', 'Added post-session learn hook');
+    }
+    else {
+        (0, logger_1.log)('HOOKS', 'skip', 'Post-session learn hook already installed');
+    }
+    fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2), 'utf8');
+    (0, logger_1.log)('HOOKS', 'save', `Settings saved to ${settingsFile}`);
+    // Set up global peak hours awareness script
+    const globalSettingsDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(globalSettingsDir)) {
+        fs.mkdirSync(globalSettingsDir, { recursive: true });
+    }
+    const scriptsDir = path.join(os.homedir(), '.compress-claude');
+    if (!fs.existsSync(scriptsDir)) {
+        fs.mkdirSync(scriptsDir, { recursive: true });
+    }
+    const peakScript = path.join(scriptsDir, 'peak-check.sh');
+    const peakContent = [
+        '#!/bin/bash',
+        '# Peak hours check -- Anthropic throttles 10AM-4PM EST',
+        'HOUR_EST=$(TZ="America/New_York" date +%H)',
+        'if [ "$HOUR_EST" -ge 10 ] && [ "$HOUR_EST" -lt 16 ]; then',
+        '  echo "[compress-claude] Peak hours (${HOUR_EST}:00 EST). Expect tighter rate limits. Consider using --proxy for compression."',
+        'fi',
+    ].join('\n') + '\n';
+    fs.writeFileSync(peakScript, peakContent, { mode: 0o755 });
+    (0, logger_1.log)('HOOKS', 'install', `Peak hours check script at ${peakScript}`);
+    (0, logger_1.log)('HOOKS', 'done', 'Installed hooks:');
+    (0, logger_1.log)('HOOKS', 'info', 'Post-session: Auto-runs --learn when you close a session');
+    (0, logger_1.log)('HOOKS', 'info', 'Peak check: Warns about Anthropic throttling during peak EST hours');
+    (0, logger_1.log)('HOOKS', 'info', `Hooks config: ${settingsFile}`);
+}
+//# sourceMappingURL=hooks.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+const scanner_1 = require("./scanner");
+const generator_1 = require("./generator");
+const server_1 = require("./proxy/server");
+const learning_1 = require("./learning");
+const hooks_1 = require("./hooks");
+const doctor_1 = require("./doctor");
+const logger_1 = require("./utils/logger");
+async function main() {
+    const opts = (0, cli_1.parseArgs)(process.argv.slice(2));
+    if (opts.help) {
+        (0, cli_1.showHelp)();
+        return;
+    }
+    if (opts.proxy) {
+        (0, server_1.startProxy)({ port: opts.port || 4800, verbose: opts.verbose });
+        return;
+    }
+    if (opts.learn) {
+        await (0, learning_1.runLearn)(process.cwd());
+        return;
+    }
+    if (opts.hooks) {
+        await (0, hooks_1.installHooks)(process.cwd());
+        return;
+    }
+    if (opts.doctor) {
+        (0, doctor_1.runDoctor)();
+        return;
+    }
+    // Default: scan and generate
+    const stack = (0, scanner_1.detectStack)(process.cwd());
+    (0, generator_1.generateContextFiles)(process.cwd(), stack, { force: opts.force, dryRun: opts.dryRun });
+}
+main().catch((err) => {
+    (0, logger_1.logError)('CLI', 'fatal', err.message);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/learning.d.ts

@@ -0,0 +1,78 @@
+export interface ToolInput {
+    command?: string;
+    file_path?: string;
+    pattern?: string;
+    [key: string]: unknown;
+}
+export interface ToolCall {
+    name: string;
+    input?: ToolInput;
+}
+export interface ToolPair {
+    tool: ToolCall;
+    resultText: string;
+    contentSize: number;
+    isError: boolean;
+}
+export interface ErrorFix {
+    tool: string;
+    failed: string;
+    fixed: string;
+    error: string;
+}
+export interface LargeResult {
+    tool: string;
+    input: string;
+    size: number;
+    tokens: number;
+}
+export interface FailedSearch {
+    tool: string;
+    input?: ToolInput;
+}
+export interface RetrySpiral {
+    command: string;
+    count: number;
+}
+export interface ToolStats {
+    calls: number;
+    tokens: number;
+}
+export interface Patterns {
+    errorFixes: ErrorFix[];
+    readStorms: Record<string, number>;
+    retrySpirals: RetrySpiral[];
+    largeResults: LargeResult[];
+    failedSearches: FailedSearch[];
+    totalToolCalls: number;
+    totalResultTokens: number;
+    toolBreakdown: Record<string, ToolStats>;
+}
+export interface Learning {
+    type: 'mistake' | 'optimization';
+    severity: 'high' | 'medium' | 'low';
+    text: string;
+    failed?: string;
+    fixed?: string;
+}
+export interface ApplyResult {
+    applied: number;
+    files: string[];
+}
+export interface TranscriptMessage {
+    role: string;
+    content: unknown;
+}
+export declare function findTranscripts(projectDir: string): string[];
+export declare function parseTranscript(filePath: string): TranscriptMessage[];
+export declare function extractToolPairs(messages: TranscriptMessage[]): ToolPair[];
+export declare function getProjectDir(cwd: string): string | null;
+export declare function getAllProjectDirs(): string[];
+export declare function findPatterns(pairs: ToolPair[]): Patterns;
+export declare function generateLearnings(allPatterns: Patterns[]): Learning[];
+export declare function applyLearnings(cwd: string, learnings: Learning[]): ApplyResult;
+export interface LearnOptions {
+    all?: boolean;
+}
+export declare function runLearn(cwd: string, opts?: LearnOptions): Promise<void>;
+//# sourceMappingURL=learning.d.ts.map