@stackmemoryai/stackmemory 0.2.6 → 0.2.8

package/dist/src/core/config/types.js

@@ -0,0 +1,127 @@
+/**
+ * Configuration types for StackMemory
+ */
+export const DEFAULT_WEIGHTS = {
+    base: 0.4,
+    impact: 0.3,
+    persistence: 0.2,
+    reference: 0.1,
+};
+export const DEFAULT_TOOL_SCORES = {
+    search: 0.95,
+    task_creation: 0.9,
+    decision_recording: 0.9,
+    context_retrieval: 0.85,
+    write: 0.75,
+    edit: 0.5,
+    test: 0.45,
+    bash: 0.4,
+    read: 0.25,
+    grep: 0.15,
+};
+export const PRESET_PROFILES = {
+    default: {
+        name: 'default',
+        description: 'Balanced configuration for general use',
+        scoring: {
+            weights: DEFAULT_WEIGHTS,
+            tool_scores: DEFAULT_TOOL_SCORES,
+        },
+    },
+    'security-focused': {
+        name: 'security-focused',
+        description: 'Prioritizes security decisions and audit trails',
+        scoring: {
+            weights: {
+                base: 0.2,
+                impact: 0.5,
+                persistence: 0.2,
+                reference: 0.1,
+            },
+            tool_scores: {
+                decision_recording: 0.95,
+                bash: 0.8, // Security-critical commands
+                test: 0.7, // Security tests important
+            },
+        },
+        retention: {
+            local: {
+                young: '7d',
+                mature: '30d',
+                old: '90d', // Keep security decisions longer
+                max_size: '100MB',
+            },
+        },
+    },
+    'exploration-heavy': {
+        name: 'exploration-heavy',
+        description: 'Optimized for codebase exploration and learning',
+        scoring: {
+            weights: {
+                base: 0.3,
+                impact: 0.1,
+                persistence: 0.1,
+                reference: 0.5, // Discovery paths matter most
+            },
+            tool_scores: {
+                search: 0.99,
+                grep: 0.3, // Grep more valuable during exploration
+                read: 0.4,
+            },
+        },
+        performance: {
+            retrieval_timeout_ms: 1000, // Allow deeper searches
+        },
+    },
+    'production-system': {
+        name: 'production-system',
+        description: 'For production environments with stability focus',
+        scoring: {
+            weights: {
+                base: 0.2,
+                impact: 0.4,
+                persistence: 0.3, // Permanent changes critical
+                reference: 0.1,
+            },
+            tool_scores: {
+                write: 0.9, // File changes very important
+                edit: 0.85,
+                test: 0.8, // Testing critical
+                bash: 0.7, // Deploy commands
+            },
+        },
+    },
+};
+export const DEFAULT_CONFIG = {
+    version: '1.0',
+    scoring: {
+        weights: DEFAULT_WEIGHTS,
+        tool_scores: DEFAULT_TOOL_SCORES,
+    },
+    retention: {
+        local: {
+            young: '1d',
+            mature: '7d',
+            old: '30d',
+            max_size: '2GB',
+        },
+        remote: {
+            enabled: true,
+            endpoint: 'api.stackmemory.io',
+            retention: 'infinite',
+        },
+        generational_gc: {
+            young_strategy: 'keep_all',
+            mature_strategy: 'digest_only',
+            old_strategy: 'anchors_only',
+        },
+    },
+    performance: {
+        max_stack_depth: 10000,
+        max_frame_events: 5000,
+        retrieval_timeout_ms: 500,
+        batch_upload_size: 100,
+    },
+    profiles: PRESET_PROFILES,
+};
+//# sourceMappingURL=types.js.map

package/dist/src/core/config/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/core/config/types.ts"],"names":[],"mappings":"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"}

package/dist/src/core/context/auto-context.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Auto-context management
+ * Automatically creates and manages context frames
+ */
+import { FrameManager } from './frame-manager.js';
+export declare class AutoContext {
+    private frameManager;
+    constructor(frameManager: FrameManager);
+    /**
+     * Initialize a session context
+     */
+    initializeSession(command?: string): void;
+    /**
+     * Create a command context
+     */
+    createCommandContext(command: string, args?: any): string | null;
+    /**
+     * Auto-save important context
+     */
+    autoSaveContext(data: any, importance?: number): void;
+}
+//# sourceMappingURL=auto-context.d.ts.map

package/dist/src/core/context/auto-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-context.d.ts","sourceRoot":"","sources":["../../../../src/core/context/auto-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,qBAAa,WAAW;IACtB,OAAO,CAAC,YAAY,CAAe;gBAEvB,YAAY,EAAE,YAAY;IAItC;;OAEG;IACH,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAsBzC;;OAEG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,MAAM,GAAG,IAAI;IAqBhE;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,GAAG,EAAE,UAAU,GAAE,MAAU,GAAG,IAAI;CAezD"}

package/dist/src/core/context/auto-context.js

@@ -0,0 +1,77 @@
+/**
+ * Auto-context management
+ * Automatically creates and manages context frames
+ */
+import { logger } from '../monitoring/logger.js';
+export class AutoContext {
+    frameManager;
+    constructor(frameManager) {
+        this.frameManager = frameManager;
+    }
+    /**
+     * Initialize a session context
+     */
+    initializeSession(command) {
+        try {
+            // Create a root session frame
+            const sessionFrame = this.frameManager.createFrame({
+                type: 'task',
+                name: 'Session',
+                inputs: {
+                    command,
+                    timestamp: new Date().toISOString(),
+                    cwd: process.cwd(),
+                }
+            });
+            logger.info('Session context initialized', {
+                frameId: sessionFrame,
+                depth: this.frameManager.getStackDepth()
+            });
+        }
+        catch (error) {
+            logger.error('Failed to initialize session context', error);
+        }
+    }
+    /**
+     * Create a command context
+     */
+    createCommandContext(command, args) {
+        try {
+            const frameId = this.frameManager.createFrame({
+                type: 'tool_scope',
+                name: command,
+                inputs: args
+            });
+            logger.info('Command context created', {
+                frameId,
+                command,
+                depth: this.frameManager.getStackDepth()
+            });
+            return frameId;
+        }
+        catch (error) {
+            logger.error('Failed to create command context', error);
+            return null;
+        }
+    }
+    /**
+     * Auto-save important context
+     */
+    autoSaveContext(data, importance = 5) {
+        try {
+            const currentFrame = this.frameManager.getCurrentFrameId();
+            if (currentFrame) {
+                this.frameManager.addEvent('observation', {
+                    type: 'context_save',
+                    data,
+                    importance,
+                    timestamp: new Date().toISOString()
+                }, currentFrame);
+            }
+        }
+        catch (error) {
+            logger.error('Failed to auto-save context', error);
+        }
+    }
+}
+//# sourceMappingURL=auto-context.js.map

package/dist/src/core/context/auto-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-context.js","sourceRoot":"","sources":["../../../../src/core/context/auto-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD,MAAM,OAAO,WAAW;IACd,YAAY,CAAe;IAEnC,YAAY,YAA0B;QACpC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,OAAgB;QAChC,IAAI,CAAC;YACH,8BAA8B;YAC9B,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;gBACjD,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,SAAS;gBACf,MAAM,EAAE;oBACN,OAAO;oBACP,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;oBACnC,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;iBACnB;aACF,CAAC,CAAC;YAEH,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE;gBACzC,OAAO,EAAE,YAAY;gBACrB,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE;aACzC,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAc,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,oBAAoB,CAAC,OAAe,EAAE,IAAU;QAC9C,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;gBAC5C,IAAI,EAAE,YAAY;gBAClB,IAAI,EAAE,OAAO;gBACb,MAAM,EAAE,IAAI;aACb,CAAC,CAAC;YAEH,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE;gBACrC,OAAO;gBACP,OAAO;gBACP,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE;aACzC,CAAC,CAAC;YAEH,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,kCAAkC,EAAE,KAAc,CAAC,CAAC;YACjE,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,IAAS,EAAE,aAAqB,CAAC;QAC/C,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,CAAC;YAC3D,IAAI,YAAY,EAAE,CAAC;gBACjB,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,EAAE;oBACxC,IAAI,EAAE,cAAc;oBACpB,IAAI;oBACJ,UAAU;oBACV,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;iBACpC,EAAE,YAAY,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,6BAA6B,EAAE,KAAc,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;CACF"}

package/dist/src/core/context/compaction-handler.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Compaction Handler for Claude Code Autocompaction
+ * Preserves critical context across token limit boundaries
+ */
+import { FrameManager } from './frame-manager.js';
+export interface CompactionMetrics {
+    estimatedTokens: number;
+    warningThreshold: number;
+    criticalThreshold: number;
+    lastCompactionAt?: number;
+    anchorsPreserved: number;
+}
+export interface ToolCallSummary {
+    tool: string;
+    timestamp: number;
+    key_inputs: Record<string, any>;
+    key_outputs: Record<string, any>;
+    files_affected: string[];
+    success: boolean;
+    error?: string;
+}
+export interface CriticalContextAnchor {
+    anchor_id: string;
+    type: 'COMPACTION_PRESERVE';
+    priority: 10;
+    content: {
+        tool_calls: ToolCallSummary[];
+        decisions: string[];
+        file_operations: FileOperation[];
+        error_resolutions: ErrorPattern[];
+    };
+    created_at: number;
+    token_estimate: number;
+}
+export interface FileOperation {
+    type: 'read' | 'write' | 'edit' | 'delete' | 'create';
+    path: string;
+    timestamp: number;
+    success: boolean;
+    error?: string;
+}
+export interface ErrorPattern {
+    error: string;
+    resolution: string;
+    tool_sequence: string[];
+    timestamp: number;
+}
+export declare class CompactionHandler {
+    private frameManager;
+    private metrics;
+    private tokenAccumulator;
+    private preservedAnchors;
+    constructor(frameManager: FrameManager);
+    /**
+     * Track token usage from a message
+     */
+    trackTokens(content: string): void;
+    /**
+     * Check if approaching compaction threshold
+     */
+    isApproachingCompaction(): boolean;
+    /**
+     * Check if past critical threshold
+     */
+    isPastCriticalThreshold(): boolean;
+    /**
+     * Detect if compaction likely occurred
+     */
+    detectCompactionEvent(content: string): boolean;
+    /**
+     * Preserve critical context before compaction
+     */
+    preserveCriticalContext(): Promise<void>;
+    /**
+     * Extract tool calls from events
+     */
+    private extractToolCalls;
+    /**
+     * Extract key inputs from tool call
+     */
+    private extractKeyInputs;
+    /**
+     * Extract key outputs from tool result
+     */
+    private extractKeyOutputs;
+    /**
+     * Extract affected files from tool events
+     */
+    private extractAffectedFiles;
+    /**
+     * Extract file operations from events
+     */
+    private extractFileOperations;
+    /**
+     * Map tool name to file operation type
+     */
+    private mapToolToOperation;
+    /**
+     * Extract decisions from events
+     */
+    private extractDecisions;
+    /**
+     * Extract error patterns and resolutions
+     */
+    private extractErrorPatterns;
+    /**
+     * Restore context after compaction detected
+     */
+    restoreContext(): Promise<void>;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): CompactionMetrics;
+    /**
+     * Reset token counter (e.g., at session start)
+     */
+    resetTokenCount(): void;
+}
+//# sourceMappingURL=compaction-handler.d.ts.map

package/dist/src/core/context/compaction-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compaction-handler.d.ts","sourceRoot":"","sources":["../../../../src/core/context/compaction-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAiB,MAAM,oBAAoB,CAAC;AAGjE,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,QAAQ,EAAE,EAAE,CAAC;IACb,OAAO,EAAE;QACP,UAAU,EAAE,eAAe,EAAE,CAAC;QAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,eAAe,EAAE,aAAa,EAAE,CAAC;QACjC,iBAAiB,EAAE,YAAY,EAAE,CAAC;KACnC,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,gBAAgB,CAAiD;gBAE7D,YAAY,EAAE,YAAY;IAUtC;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAYlC;;OAEG;IACH,uBAAuB,IAAI,OAAO;IAIlC;;OAEG;IACH,uBAAuB,IAAI,OAAO;IAIlC;;OAEG;IACH,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAgB/C;;OAEG;IACG,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC;IAwD9C;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA+BxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA4B7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA2B5B;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAkErC;;OAEG;IACH,UAAU,IAAI,iBAAiB;IAI/B;;OAEG;IACH,eAAe,IAAI,IAAI;CAKxB"}

package/dist/src/core/context/compaction-handler.js

@@ -0,0 +1,306 @@
+/**
+ * Compaction Handler for Claude Code Autocompaction
+ * Preserves critical context across token limit boundaries
+ */
+import { logger } from '../monitoring/logger.js';
+export class CompactionHandler {
+    frameManager;
+    metrics;
+    tokenAccumulator = 0;
+    preservedAnchors = new Map();
+    constructor(frameManager) {
+        this.frameManager = frameManager;
+        this.metrics = {
+            estimatedTokens: 0,
+            warningThreshold: 150000, // 150K tokens
+            criticalThreshold: 170000, // 170K tokens
+            anchorsPreserved: 0,
+        };
+    }
+    /**
+     * Track token usage from a message
+     */
+    trackTokens(content) {
+        // Rough estimation: 1 token ≈ 4 characters
+        const estimatedTokens = Math.ceil(content.length / 4);
+        this.tokenAccumulator += estimatedTokens;
+        this.metrics.estimatedTokens += estimatedTokens;
+        // Check thresholds
+        if (this.isApproachingCompaction()) {
+            this.preserveCriticalContext();
+        }
+    }
+    /**
+     * Check if approaching compaction threshold
+     */
+    isApproachingCompaction() {
+        return this.metrics.estimatedTokens >= this.metrics.warningThreshold;
+    }
+    /**
+     * Check if past critical threshold
+     */
+    isPastCriticalThreshold() {
+        return this.metrics.estimatedTokens >= this.metrics.criticalThreshold;
+    }
+    /**
+     * Detect if compaction likely occurred
+     */
+    detectCompactionEvent(content) {
+        const compactionIndicators = [
+            'earlier in this conversation',
+            'previously discussed',
+            'as mentioned before',
+            'summarized for brevity',
+            '[conversation compressed]',
+            '[context truncated]',
+        ];
+        const lowerContent = content.toLowerCase();
+        return compactionIndicators.some((indicator) => lowerContent.includes(indicator));
+    }
+    /**
+     * Preserve critical context before compaction
+     */
+    async preserveCriticalContext() {
+        try {
+            const currentFrameId = this.frameManager.getCurrentFrameId();
+            if (!currentFrameId) {
+                logger.warn('No active frame to preserve context from');
+                return;
+            }
+            // Get events from current frame
+            const events = this.frameManager.getFrameEvents(currentFrameId);
+            // Extract critical information
+            const toolCalls = this.extractToolCalls(events);
+            const fileOps = this.extractFileOperations(events);
+            const decisions = this.extractDecisions(events);
+            const errorPatterns = this.extractErrorPatterns(events);
+            // Create preservation anchor
+            const anchor = {
+                anchor_id: `compact_${Date.now()}`,
+                type: 'COMPACTION_PRESERVE',
+                priority: 10,
+                content: {
+                    tool_calls: toolCalls,
+                    file_operations: fileOps,
+                    decisions: decisions,
+                    error_resolutions: errorPatterns,
+                },
+                created_at: Date.now(),
+                token_estimate: this.metrics.estimatedTokens,
+            };
+            // Store in frame manager as high-priority anchor
+            this.frameManager.addAnchor('CONSTRAINT', // Using CONSTRAINT type for now
+            JSON.stringify(anchor), 10, {
+                compaction_preserve: true,
+                token_count: this.metrics.estimatedTokens,
+            }, currentFrameId);
+            // Store locally for quick access
+            this.preservedAnchors.set(anchor.anchor_id, anchor);
+            this.metrics.anchorsPreserved++;
+            logger.info(`Preserved critical context at ${this.metrics.estimatedTokens} tokens`);
+        }
+        catch (error) {
+            logger.error('Failed to preserve critical context:', error);
+        }
+    }
+    /**
+     * Extract tool calls from events
+     */
+    extractToolCalls(events) {
+        const toolCalls = [];
+        const toolEvents = events.filter((e) => e.event_type === 'tool_call');
+        for (const event of toolEvents) {
+            const resultEvent = events.find((e) => e.event_type === 'tool_result' &&
+                e.seq > event.seq &&
+                e.payload.tool_name === event.payload.tool_name);
+            toolCalls.push({
+                tool: event.payload.tool_name || 'unknown',
+                timestamp: event.ts,
+                key_inputs: this.extractKeyInputs(event.payload),
+                key_outputs: resultEvent
+                    ? this.extractKeyOutputs(resultEvent.payload)
+                    : {},
+                files_affected: this.extractAffectedFiles(event.payload, resultEvent?.payload),
+                success: resultEvent ? !resultEvent.payload.error : false,
+                error: resultEvent?.payload.error,
+            });
+        }
+        return toolCalls;
+    }
+    /**
+     * Extract key inputs from tool call
+     */
+    extractKeyInputs(payload) {
+        const keys = [
+            'file_path',
+            'command',
+            'query',
+            'path',
+            'pattern',
+            'content',
+        ];
+        const result = {};
+        for (const key of keys) {
+            if (payload.arguments?.[key]) {
+                result[key] = payload.arguments[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * Extract key outputs from tool result
+     */
+    extractKeyOutputs(payload) {
+        return {
+            success: !payload.error,
+            error: payload.error,
+            result_type: payload.result_type,
+            files_created: payload.files_created,
+            files_modified: payload.files_modified,
+        };
+    }
+    /**
+     * Extract affected files from tool events
+     */
+    extractAffectedFiles(callPayload, resultPayload) {
+        const files = new Set();
+        // From tool call
+        if (callPayload?.arguments?.file_path) {
+            files.add(callPayload.arguments.file_path);
+        }
+        if (callPayload?.arguments?.path) {
+            files.add(callPayload.arguments.path);
+        }
+        // From tool result
+        if (resultPayload?.files_created) {
+            resultPayload.files_created.forEach((f) => files.add(f));
+        }
+        if (resultPayload?.files_modified) {
+            resultPayload.files_modified.forEach((f) => files.add(f));
+        }
+        return Array.from(files);
+    }
+    /**
+     * Extract file operations from events
+     */
+    extractFileOperations(events) {
+        const fileOps = [];
+        const fileTools = ['Read', 'Write', 'Edit', 'MultiEdit', 'Delete'];
+        const toolEvents = events.filter((e) => e.event_type === 'tool_call' && fileTools.includes(e.payload.tool_name));
+        for (const event of toolEvents) {
+            const operation = this.mapToolToOperation(event.payload.tool_name);
+            const path = event.payload.arguments?.file_path ||
+                event.payload.arguments?.path ||
+                'unknown';
+            fileOps.push({
+                type: operation,
+                path: path,
+                timestamp: event.ts,
+                success: true, // Will be updated from result
+                error: undefined,
+            });
+        }
+        return fileOps;
+    }
+    /**
+     * Map tool name to file operation type
+     */
+    mapToolToOperation(toolName) {
+        const mapping = {
+            Read: 'read',
+            Write: 'write',
+            Edit: 'edit',
+            MultiEdit: 'edit',
+            Delete: 'delete',
+        };
+        return mapping[toolName] || 'read';
+    }
+    /**
+     * Extract decisions from events
+     */
+    extractDecisions(events) {
+        const decisions = [];
+        const decisionEvents = events.filter((e) => e.event_type === 'decision');
+        for (const event of decisionEvents) {
+            if (event.payload.text) {
+                decisions.push(event.payload.text);
+            }
+        }
+        return decisions;
+    }
+    /**
+     * Extract error patterns and resolutions
+     */
+    extractErrorPatterns(events) {
+        const patterns = [];
+        // Find tool results with errors
+        const errorEvents = events.filter((e) => e.event_type === 'tool_result' && e.payload.error);
+        for (const errorEvent of errorEvents) {
+            // Look for subsequent successful tool calls that might be resolutions
+            const subsequentTools = events
+                .filter((e) => e.event_type === 'tool_call' && e.seq > errorEvent.seq)
+                .slice(0, 3); // Next 3 tools might be resolution attempts
+            if (subsequentTools.length > 0) {
+                patterns.push({
+                    error: errorEvent.payload.error,
+                    resolution: `Attempted resolution with ${subsequentTools.map((t) => t.payload.tool_name).join(', ')}`,
+                    tool_sequence: subsequentTools.map((t) => t.payload.tool_name),
+                    timestamp: errorEvent.ts,
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Restore context after compaction detected
+     */
+    async restoreContext() {
+        if (this.preservedAnchors.size === 0) {
+            logger.warn('No preserved anchors to restore from');
+            return;
+        }
+        // Get the most recent anchor
+        const anchors = Array.from(this.preservedAnchors.values());
+        anchors.sort((a, b) => b.created_at - a.created_at);
+        const latestAnchor = anchors[0];
+        // Create restoration frame
+        const restorationFrame = this.frameManager.createFrame({
+            type: 'review',
+            name: 'Context Restoration After Compaction',
+            inputs: { reason: 'autocompaction_detected' },
+        });
+        // Add restoration anchor
+        this.frameManager.addAnchor('FACT', `Context restored from token position ${latestAnchor.token_estimate}`, 10, { restoration: true }, restorationFrame);
+        // Add tool sequence summary
+        const toolSequence = latestAnchor.content.tool_calls
+            .map((t) => t.tool)
+            .join(' → ');
+        this.frameManager.addAnchor('FACT', `Tool sequence: ${toolSequence}`, 9, {}, restorationFrame);
+        // Add file operations summary
+        const files = new Set();
+        latestAnchor.content.file_operations.forEach((op) => files.add(op.path));
+        if (files.size > 0) {
+            this.frameManager.addAnchor('FACT', `Files touched: ${Array.from(files).join(', ')}`, 8, {}, restorationFrame);
+        }
+        // Add decisions
+        for (const decision of latestAnchor.content.decisions) {
+            this.frameManager.addAnchor('DECISION', decision, 7, {}, restorationFrame);
+        }
+        logger.info('Context restored after compaction detection');
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Reset token counter (e.g., at session start)
+     */
+    resetTokenCount() {
+        this.metrics.estimatedTokens = 0;
+        this.tokenAccumulator = 0;
+        this.metrics.lastCompactionAt = undefined;
+    }
+}
+//# sourceMappingURL=compaction-handler.js.map