claude-mem 3.0.2 → 3.0.4

package/dist/types.js

@@ -0,0 +1,78 @@
+export class HookError extends Error {
+    hookType;
+    payload;
+    code;
+    constructor(message, hookType, payload, code) {
+        super(message);
+        this.hookType = hookType;
+        this.payload = payload;
+        this.code = code;
+        this.name = 'HookError';
+    }
+}
+export class CompressionError extends Error {
+    transcriptPath;
+    stage;
+    constructor(message, transcriptPath, stage) {
+        super(message);
+        this.transcriptPath = transcriptPath;
+        this.stage = stage;
+        this.name = 'CompressionError';
+    }
+}
+export class FileLogger {
+    logFile;
+    enableDebug;
+    constructor(logFile, enableDebug = false) {
+        this.logFile = logFile;
+        this.enableDebug = enableDebug;
+    }
+    info(message, meta) {
+        this.log('INFO', message, meta);
+    }
+    warn(message, meta) {
+        this.log('WARN', message, meta);
+    }
+    error(message, error, meta) {
+        const errorMeta = error ? { error: error.message, stack: error.stack } : {};
+        this.log('ERROR', message, { ...meta, ...errorMeta });
+    }
+    debug(message, meta) {
+        if (this.enableDebug) {
+            this.log('DEBUG', message, meta);
+        }
+    }
+    log(level, message, meta) {
+        const timestamp = new Date().toISOString();
+        const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+        const logLine = `[${timestamp}] ${level}: ${message}${metaStr}\n`;
+        console.error(logLine);
+    }
+}
+export function validateHookPayload(payload, expectedType) {
+    if (!payload || typeof payload !== 'object') {
+        throw new HookError(`Invalid payload: expected object, got ${typeof payload}`, expectedType);
+    }
+    const hookPayload = payload;
+    if (!hookPayload.session_id || typeof hookPayload.session_id !== 'string') {
+        throw new HookError('Missing or invalid session_id', expectedType, hookPayload);
+    }
+    if (!hookPayload.transcript_path ||
+        typeof hookPayload.transcript_path !== 'string') {
+        throw new HookError('Missing or invalid transcript_path', expectedType, hookPayload);
+    }
+    return hookPayload;
+}
+export function createSuccessResponse(additionalData) {
+    return {
+        continue: true,
+        ...additionalData,
+    };
+}
+export function createErrorResponse(reason, additionalData) {
+    return {
+        continue: false,
+        stopReason: reason,
+        ...additionalData,
+    };
+}

package/dist/utils/HookDetector.d.ts

@@ -0,0 +1,64 @@
+import { ClaudeSettings } from './SettingsManager.js';
+export type HookType = 'PreCompact' | 'SessionStart' | 'SessionEnd';
+export interface HookDetectionResult {
+    hasPreCompact: boolean;
+    hasSessionStart: boolean;
+    hasSessionEnd: boolean;
+    hasAny: boolean;
+}
+export interface HookInfo {
+    name: string;
+    path: string;
+    exists: boolean;
+    executable: boolean;
+}
+/**
+ * Utility for detecting and managing claude-mem hooks in Claude settings
+ */
+export declare class HookDetector {
+    /**
+     * Check if settings contain any of our hooks
+     */
+    static hasOurHooks(settings: ClaudeSettings): HookDetectionResult;
+    /**
+     * Check if settings contain our hook for a specific hook type
+     */
+    static hasOurHookType(settings: ClaudeSettings, hookType: HookType): boolean;
+    /**
+     * Filter out our hooks from the settings
+     */
+    static filterOurHooks(settings: ClaudeSettings): ClaudeSettings;
+    /**
+     * Add our hooks to the settings with the correct configuration format
+     */
+    static addOurHooks(settings: ClaudeSettings, hooks: {
+        preCompactScript?: string;
+        sessionStartScript?: string;
+        sessionEndScript?: string;
+    }): ClaudeSettings;
+    /**
+     * Get hook configuration for display purposes
+     */
+    static getHookInfo(settings: ClaudeSettings): {
+        totalHookTypes: number;
+        hookTypesList: string[];
+        hasPreCompact: boolean;
+        hasSessionStart: boolean;
+        hasSessionEnd: boolean;
+        hasAny: boolean;
+    };
+    /**
+     * Get hook file info including existence and executable status
+     */
+    static getHookFileInfo(hookName: string): HookInfo;
+    /**
+     * Check all hook file statuses
+     */
+    static getAllHookFileStatuses(): {
+        [key: string]: HookInfo;
+    };
+    /**
+     * Check if settings contain our hooks (legacy method for compatibility)
+     */
+    static hasOurHooksLegacy(settings: any, hookType: string): boolean;
+}

package/dist/utils/HookDetector.js

@@ -0,0 +1,213 @@
+import { existsSync, statSync } from 'fs';
+import { PathResolver } from './PathResolver.js';
+import { PACKAGE_NAME } from '../config.js';
+/**
+ * Utility for detecting and managing claude-mem hooks in Claude settings
+ */
+export class HookDetector {
+    /**
+     * Check if settings contain any of our hooks
+     */
+    static hasOurHooks(settings) {
+        const hasPreCompact = this.hasOurHookType(settings, 'PreCompact');
+        const hasSessionStart = this.hasOurHookType(settings, 'SessionStart');
+        const hasSessionEnd = this.hasOurHookType(settings, 'SessionEnd');
+        return {
+            hasPreCompact,
+            hasSessionStart,
+            hasSessionEnd,
+            hasAny: hasPreCompact || hasSessionStart || hasSessionEnd
+        };
+    }
+    /**
+     * Check if settings contain our hook for a specific hook type
+     */
+    static hasOurHookType(settings, hookType) {
+        const configs = settings.hooks?.[hookType];
+        if (!configs)
+            return false;
+        // Natural iteration - check each hook command directly
+        for (const config of configs) {
+            if (!config.hooks)
+                continue;
+            for (const hook of config.hooks) {
+                const command = hook.command;
+                if (command && (command.includes(PACKAGE_NAME) ||
+                    command.includes('pre-compact.js') ||
+                    command.includes('session-start.js') ||
+                    command.includes('session-end.js'))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Filter out our hooks from the settings
+     */
+    static filterOurHooks(settings) {
+        const filteredSettings = { ...settings };
+        if (!filteredSettings.hooks) {
+            return filteredSettings;
+        }
+        // Filter each hook type
+        const hookTypes = ['PreCompact', 'SessionStart', 'SessionEnd'];
+        for (const hookType of hookTypes) {
+            if (filteredSettings.hooks[hookType]) {
+                filteredSettings.hooks[hookType] = filteredSettings.hooks[hookType].filter((config) => {
+                    // Natural check - if no hooks, keep the config
+                    if (!config.hooks)
+                        return true;
+                    // Check if any hook contains our commands
+                    for (const hook of config.hooks) {
+                        const command = hook.command;
+                        if (command && (command.includes(PACKAGE_NAME) ||
+                            command.includes('pre-compact.js') ||
+                            command.includes('session-start.js') ||
+                            command.includes('session-end.js'))) {
+                            return false; // Filter out this config
+                        }
+                    }
+                    return true; // Keep this config
+                });
+                // Remove the hook type array if it's empty
+                if (filteredSettings.hooks[hookType].length === 0) {
+                    delete filteredSettings.hooks[hookType];
+                }
+            }
+        }
+        return filteredSettings;
+    }
+    /**
+     * Add our hooks to the settings with the correct configuration format
+     */
+    static addOurHooks(settings, hooks) {
+        const updatedSettings = { ...settings };
+        if (!updatedSettings.hooks) {
+            updatedSettings.hooks = {};
+        }
+        // Add PreCompact hook if script provided
+        if (hooks.preCompactScript) {
+            if (!updatedSettings.hooks.PreCompact) {
+                updatedSettings.hooks.PreCompact = [];
+            }
+            // Add echo command first to show message, then actual hook
+            updatedSettings.hooks.PreCompact.push({
+                hooks: [
+                    {
+                        type: "command",
+                        command: `echo '{"systemMessage": "Compressing memories..."}'`
+                    },
+                    {
+                        type: "command",
+                        command: hooks.preCompactScript,
+                        timeout: 180000
+                    }
+                ]
+            });
+        }
+        // Add SessionStart hook if script provided
+        if (hooks.sessionStartScript) {
+            if (!updatedSettings.hooks.SessionStart) {
+                updatedSettings.hooks.SessionStart = [];
+            }
+            // Add echo command first to show message, then actual hook
+            updatedSettings.hooks.SessionStart.push({
+                hooks: [
+                    {
+                        type: "command",
+                        command: `echo '{"systemMessage": "Remembering..."}'`
+                    },
+                    {
+                        type: "command",
+                        command: hooks.sessionStartScript,
+                        timeout: 30000
+                    }
+                ]
+            });
+        }
+        // Add SessionEnd hook if script provided
+        if (hooks.sessionEndScript) {
+            if (!updatedSettings.hooks.SessionEnd) {
+                updatedSettings.hooks.SessionEnd = [];
+            }
+            updatedSettings.hooks.SessionEnd.push({
+                hooks: [{
+                        type: "command",
+                        command: hooks.sessionEndScript,
+                        timeout: 180000
+                    }]
+            });
+        }
+        return updatedSettings;
+    }
+    /**
+     * Get hook configuration for display purposes
+     */
+    static getHookInfo(settings) {
+        const detection = this.hasOurHooks(settings);
+        const hookTypes = Object.keys(settings.hooks || {});
+        return {
+            ...detection,
+            totalHookTypes: hookTypes.length,
+            hookTypesList: hookTypes
+        };
+    }
+    /**
+     * Get hook file info including existence and executable status
+     */
+    static getHookFileInfo(hookName) {
+        const path = PathResolver.resolveHookPath(hookName);
+        const exists = existsSync(path);
+        let executable = false;
+        if (exists) {
+            try {
+                const stats = statSync(path);
+                executable = (stats.mode & 0o111) !== 0;
+            }
+            catch (error) {
+                // Ignore stat errors
+            }
+        }
+        return {
+            name: hookName,
+            path,
+            exists,
+            executable
+        };
+    }
+    /**
+     * Check all hook file statuses
+     */
+    static getAllHookFileStatuses() {
+        const hooks = ['pre-compact.js', 'session-start.js', 'session-end.js'];
+        const statuses = {};
+        hooks.forEach(hookName => {
+            statuses[hookName] = this.getHookFileInfo(hookName);
+        });
+        return statuses;
+    }
+    /**
+     * Check if settings contain our hooks (legacy method for compatibility)
+     */
+    static hasOurHooksLegacy(settings, hookType) {
+        const matchers = settings.hooks?.[hookType];
+        if (!matchers)
+            return false;
+        // Natural iteration - check each hook command directly
+        for (const matcher of matchers) {
+            if (!matcher.hooks)
+                continue;
+            for (const hook of matcher.hooks) {
+                const command = hook.command;
+                if (command && (command.includes('pre-compact.js') ||
+                    command.includes('session-start.js') ||
+                    command.includes('session-end.js') ||
+                    command.includes(PACKAGE_NAME))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

package/dist/utils/PathResolver.d.ts

@@ -0,0 +1,16 @@
+/**
+ * PathResolver utility for managing claude-mem file system paths
+ */
+export declare class PathResolver {
+    private baseDir;
+    constructor();
+    getConfigDir(): string;
+    getIndexDir(): string;
+    getIndexPath(): string;
+    getArchiveDir(): string;
+    getProjectArchiveDir(projectName: string): string;
+    getLogsDir(): string;
+    static ensureDirectory(dirPath: string): void;
+    static ensureDirectories(dirPaths: string[]): void;
+    static extractProjectName(transcriptPath: string): string;
+}

package/dist/utils/PathResolver.js

@@ -0,0 +1,55 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync, mkdirSync } from 'fs';
+/**
+ * PathResolver utility for managing claude-mem file system paths
+ */
+export class PathResolver {
+    baseDir;
+    constructor() {
+        this.baseDir = join(homedir(), '.claude-mem');
+    }
+    getConfigDir() {
+        return this.baseDir;
+    }
+    getIndexDir() {
+        return this.baseDir;
+    }
+    getIndexPath() {
+        return join(this.baseDir, 'index.jsonl');
+    }
+    getArchiveDir() {
+        return join(this.baseDir, 'archives');
+    }
+    getProjectArchiveDir(projectName) {
+        return join(this.getArchiveDir(), projectName);
+    }
+    getLogsDir() {
+        return join(this.baseDir, 'logs');
+    }
+    static ensureDirectory(dirPath) {
+        if (!existsSync(dirPath)) {
+            mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    static ensureDirectories(dirPaths) {
+        dirPaths.forEach(dirPath => PathResolver.ensureDirectory(dirPath));
+    }
+    static extractProjectName(transcriptPath) {
+        // Try to extract project name from path
+        const pathParts = transcriptPath.split('/');
+        // Look for common project indicators
+        const projectIndicators = ['src', 'lib', 'app', 'project', 'workspace'];
+        for (let i = pathParts.length - 1; i >= 0; i--) {
+            if (projectIndicators.includes(pathParts[i]) && i > 0) {
+                return pathParts[i - 1];
+            }
+        }
+        // Fallback to directory name containing the transcript
+        if (pathParts.length > 1) {
+            return pathParts[pathParts.length - 2];
+        }
+        // Ultimate fallback
+        return 'unknown-project';
+    }
+}

package/dist/utils/SettingsManager.d.ts

@@ -0,0 +1,63 @@
+import { type SettingsLocation } from './PathResolver.js';
+export interface ClaudeSettings {
+    hooks?: {
+        [hookType: string]: Array<{
+            hooks: Array<{
+                type?: string;
+                command: string;
+                args?: string[];
+                timeout?: number;
+            }>;
+            matcher?: any;
+        }>;
+    };
+    [key: string]: any;
+}
+export interface SettingsResult {
+    settings: ClaudeSettings;
+    location: SettingsLocation;
+    existed: boolean;
+}
+/**
+ * Utility for managing Claude settings files
+ */
+export declare class SettingsManager {
+    /**
+     * Read settings from the specified location
+     */
+    static readSettings(options: {
+        user?: boolean;
+        global?: boolean;
+        project?: boolean;
+        local?: boolean;
+    }): SettingsResult;
+    /**
+     * Write settings to the specified location
+     */
+    static writeSettings(settings: ClaudeSettings, location: SettingsLocation): void;
+    /**
+     * Read settings from all possible locations for status checking
+     */
+    static readAllSettings(): SettingsResult[];
+    /**
+     * Update settings by applying a transformation function
+     */
+    static updateSettings(options: {
+        user?: boolean;
+        global?: boolean;
+        project?: boolean;
+        local?: boolean;
+    }, updateFn: (settings: ClaudeSettings) => ClaudeSettings): SettingsResult;
+    /**
+     * Simple settings file reader with error handling (path-based)
+     */
+    static readSettingsFromPath(settingsPath: string): any;
+    /**
+     * Simple settings file writer with proper formatting (path-based)
+     */
+    static writeSettingsToPath(settingsPath: string, settings: any): void;
+    /**
+     * Merge settings objects safely with deep merge
+     */
+    static mergeSettings(base: any, updates: any): any;
+}

package/dist/utils/SettingsManager.js

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { PathResolver } from './PathResolver.js';
+import { log } from './logger.js';
+/**
+ * Utility for managing Claude settings files
+ */
+export class SettingsManager {
+    /**
+     * Read settings from the specified location
+     */
+    static readSettings(options) {
+        const location = PathResolver.getSettingsLocation(options);
+        let settings = {};
+        let existed = false;
+        if (existsSync(location.fullPath)) {
+            existed = true;
+            try {
+                const content = readFileSync(location.fullPath, 'utf8');
+                settings = JSON.parse(content);
+            }
+            catch (error) {
+                log.warning(`Creating new settings file (could not parse existing): ${error.message}`);
+                settings = {};
+            }
+        }
+        // Ensure hooks structure exists
+        if (!settings.hooks) {
+            settings.hooks = {};
+        }
+        return {
+            settings,
+            location,
+            existed
+        };
+    }
+    /**
+     * Write settings to the specified location
+     */
+    static writeSettings(settings, location) {
+        // Ensure directory exists
+        PathResolver.ensureDirectory(location.directory);
+        // Write settings file
+        writeFileSync(location.fullPath, JSON.stringify(settings, null, 2));
+    }
+    /**
+     * Read settings from all possible locations for status checking
+     */
+    static readAllSettings() {
+        const locations = PathResolver.getAllSettingsLocations();
+        return locations.map(location => {
+            let settings = {};
+            let existed = false;
+            if (existsSync(location.fullPath)) {
+                existed = true;
+                try {
+                    const content = readFileSync(location.fullPath, 'utf8');
+                    settings = JSON.parse(content);
+                }
+                catch (error) {
+                    // Don't log errors for status checking, just mark as unreadable
+                    settings = { _error: error.message };
+                }
+            }
+            return {
+                settings,
+                location,
+                existed
+            };
+        });
+    }
+    /**
+     * Update settings by applying a transformation function
+     */
+    static updateSettings(options, updateFn) {
+        const result = this.readSettings(options);
+        const updatedSettings = updateFn(result.settings);
+        this.writeSettings(updatedSettings, result.location);
+        return {
+            settings: updatedSettings,
+            location: result.location,
+            existed: result.existed
+        };
+    }
+    /**
+     * Simple settings file reader with error handling (path-based)
+     */
+    static readSettingsFromPath(settingsPath) {
+        if (!existsSync(settingsPath)) {
+            return {};
+        }
+        try {
+            const content = readFileSync(settingsPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            log.warning(`Could not parse settings file: ${error}`);
+            return {};
+        }
+    }
+    /**
+     * Simple settings file writer with proper formatting (path-based)
+     */
+    static writeSettingsToPath(settingsPath, settings) {
+        const settingsDir = dirname(settingsPath);
+        // Ensure directory exists
+        if (!existsSync(settingsDir)) {
+            mkdirSync(settingsDir, { recursive: true });
+        }
+        try {
+            const content = JSON.stringify(settings, null, 2);
+            writeFileSync(settingsPath, content, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to write settings file: ${error}`);
+        }
+    }
+    /**
+     * Merge settings objects safely with deep merge
+     */
+    static mergeSettings(base, updates) {
+        const merged = { ...base };
+        Object.keys(updates).forEach(key => {
+            if (updates[key] && typeof updates[key] === 'object' && !Array.isArray(updates[key])) {
+                merged[key] = this.mergeSettings(merged[key] || {}, updates[key]);
+            }
+            else {
+                merged[key] = updates[key];
+            }
+        });
+        return merged;
+    }
+}