claude-memory-layer 1.0.6 → 1.0.8

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "claude-memory-layer",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Claude Code plugin that learns from conversations to provide personalized assistance",
   "main": "dist/index.js",
   "bin": {
-    "code-memory": "dist/cli/index.js"
+    "claude-memory-layer": "dist/cli/index.js"
   },
   "type": "module",
   "scripts": {
@@ -29,10 +29,12 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
+    "@hono/node-server": "^1.13.0",
     "@lancedb/lancedb": "^0.5.0",
     "@xenova/transformers": "^2.17.0",
     "commander": "^12.0.0",
     "duckdb": "^0.10.0",
+    "hono": "^4.0.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {

package/scripts/build.ts

@@ -1,5 +1,5 @@
 /**
- * Build script for code-memory plugin
+ * Build script for claude-memory-layer plugin
  * Uses esbuild for fast bundling
  */
 
@@ -23,11 +23,16 @@ const commonOptions: esbuild.BuildOptions = {
   format: 'esm',
   sourcemap: true,
   external: [
+    '@hono/node-server',
+    '@hono/node-server/serve-static',
     '@lancedb/lancedb',
     '@xenova/transformers',
     'duckdb',
     'commander',
-    'zod'
+    'zod',
+    'hono',
+    'hono/cors',
+    'hono/logger'
   ],
   banner: {
     js: `import { createRequire } from 'module';
@@ -40,7 +45,7 @@ const __dirname = dirname(__filename);`
 };
 
 async function build() {
-  console.log('🔨 Building code-memory plugin...\n');
+  console.log('🔨 Building claude-memory-layer plugin...\n');
 
   // Build CLI
   console.log('📦 Building CLI...');
@@ -83,16 +88,41 @@ async function build() {
     outfile: 'dist/services/memory-service.js'
   });
 
+  // Build server
+  console.log('📦 Building server...');
+  await esbuild.build({
+    ...commonOptions,
+    entryPoints: ['src/server/index.ts'],
+    outfile: 'dist/server/index.js',
+    external: [...(commonOptions.external || []), 'hono']
+  });
+
+  // Build server API
+  await esbuild.build({
+    ...commonOptions,
+    entryPoints: ['src/server/api/index.ts'],
+    outfile: 'dist/server/api/index.js',
+    external: [...(commonOptions.external || []), 'hono']
+  });
+
   // Copy plugin manifest
   console.log('📋 Copying plugin files...');
   fs.cpSync('.claude-plugin', path.join(outdir, '.claude-plugin'), { recursive: true });
 
+  // Copy UI files
+  console.log('📋 Copying UI files...');
+  if (fs.existsSync('src/ui')) {
+    fs.cpSync('src/ui', path.join(outdir, 'ui'), { recursive: true });
+  }
+
   console.log('\n✅ Build complete!');
   console.log(`\nOutput: ${outdir}/`);
   console.log('  - cli/index.js');
   console.log('  - hooks/*.js');
   console.log('  - core/index.js');
   console.log('  - services/memory-service.js');
+  console.log('  - server/index.js');
+  console.log('  - ui/index.html');
   console.log('  - .claude-plugin/');
 }
 

package/src/cli/index.ts

@@ -5,19 +5,247 @@
  */
 
 import { Command } from 'commander';
+import { exec } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 import {
   getDefaultMemoryService,
   getMemoryServiceForProject
 } from '../services/memory-service.js';
 import { createSessionHistoryImporter } from '../services/session-history-importer.js';
+import { startServer, stopServer, isServerRunning } from '../server/index.js';
+
+// ============================================================
+// Hook Installation Utilities
+// ============================================================
+
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+
+interface ClaudeSettings {
+  hooks?: {
+    UserPromptSubmit?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
+    PostToolUse?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
+    SessionStart?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
+    Stop?: Array<{ matcher: string; hooks: Array<{ type: string; command: string }> }>;
+  };
+  [key: string]: unknown;
+}
+
+function getPluginPath(): string {
+  // Try to find the dist directory
+  const possiblePaths = [
+    path.join(__dirname, '..'),  // When running from dist/cli
+    path.join(__dirname, '../..', 'dist'),  // When running from src
+    path.join(process.cwd(), 'dist'),  // Current working directory
+  ];
+
+  for (const p of possiblePaths) {
+    const hooksPath = path.join(p, 'hooks', 'user-prompt-submit.js');
+    if (fs.existsSync(hooksPath)) {
+      return p;
+    }
+  }
+
+  // Fallback to npm global installation path
+  return path.join(os.homedir(), '.npm-global', 'lib', 'node_modules', 'claude-memory-layer', 'dist');
+}
+
+function loadClaudeSettings(): ClaudeSettings {
+  try {
+    if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+      const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8');
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.error('Warning: Could not read existing settings:', error);
+  }
+  return {};
+}
+
+function saveClaudeSettings(settings: ClaudeSettings): void {
+  const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Atomic write
+  const tempPath = CLAUDE_SETTINGS_PATH + '.tmp';
+  fs.writeFileSync(tempPath, JSON.stringify(settings, null, 2));
+  fs.renameSync(tempPath, CLAUDE_SETTINGS_PATH);
+}
+
+function getHooksConfig(pluginPath: string): ClaudeSettings['hooks'] {
+  return {
+    UserPromptSubmit: [
+      {
+        matcher: '',
+        hooks: [
+          {
+            type: 'command',
+            command: `node ${path.join(pluginPath, 'hooks', 'user-prompt-submit.js')}`
+          }
+        ]
+      }
+    ],
+    PostToolUse: [
+      {
+        matcher: '',
+        hooks: [
+          {
+            type: 'command',
+            command: `node ${path.join(pluginPath, 'hooks', 'post-tool-use.js')}`
+          }
+        ]
+      }
+    ]
+  };
+}
 
 const program = new Command();
 
 program
-  .name('code-memory')
+  .name('claude-memory-layer')
   .description('Claude Code Memory Plugin CLI')
   .version('1.0.0');
 
+// ============================================================
+// Install / Uninstall Commands
+// ============================================================
+
+/**
+ * Install command - register hooks with Claude Code
+ */
+program
+  .command('install')
+  .description('Install hooks into Claude Code settings')
+  .option('--path <path>', 'Custom plugin path (defaults to auto-detect)')
+  .action(async (options) => {
+    try {
+      const pluginPath = options.path || getPluginPath();
+
+      // Verify hooks exist
+      const userPromptHook = path.join(pluginPath, 'hooks', 'user-prompt-submit.js');
+      if (!fs.existsSync(userPromptHook)) {
+        console.error(`\n❌ Hook files not found at: ${pluginPath}`);
+        console.error('   Make sure you have built the plugin with "npm run build"');
+        process.exit(1);
+      }
+
+      // Load existing settings
+      const settings = loadClaudeSettings();
+
+      // Add hooks (merge with existing)
+      const newHooks = getHooksConfig(pluginPath);
+      settings.hooks = {
+        ...settings.hooks,
+        ...newHooks
+      };
+
+      // Save settings
+      saveClaudeSettings(settings);
+
+      console.log('\n✅ Claude Memory Layer installed!\n');
+      console.log('Hooks registered:');
+      console.log('  - UserPromptSubmit: Memory retrieval on user input');
+      console.log('  - PostToolUse: Store tool observations\n');
+      console.log('Plugin path:', pluginPath);
+      console.log('\n⚠️  Restart Claude Code for changes to take effect.\n');
+      console.log('Commands:');
+      console.log('  claude-memory-layer dashboard  - Open web dashboard');
+      console.log('  claude-memory-layer search     - Search memories');
+      console.log('  claude-memory-layer stats      - View statistics');
+      console.log('  claude-memory-layer uninstall  - Remove hooks\n');
+    } catch (error) {
+      console.error('Install failed:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Uninstall command - remove hooks from Claude Code
+ */
+program
+  .command('uninstall')
+  .description('Remove hooks from Claude Code settings')
+  .action(async () => {
+    try {
+      // Load existing settings
+      const settings = loadClaudeSettings();
+
+      if (!settings.hooks) {
+        console.log('\n📋 No hooks installed.\n');
+        return;
+      }
+
+      // Remove our hooks
+      delete settings.hooks.UserPromptSubmit;
+      delete settings.hooks.PostToolUse;
+
+      // Clean up empty hooks object
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+
+      // Save settings
+      saveClaudeSettings(settings);
+
+      console.log('\n✅ Claude Memory Layer uninstalled!\n');
+      console.log('Hooks removed from Claude Code settings.');
+      console.log('Your memory data is preserved and can be accessed with:');
+      console.log('  claude-memory-layer dashboard\n');
+      console.log('⚠️  Restart Claude Code for changes to take effect.\n');
+    } catch (error) {
+      console.error('Uninstall failed:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Status command - check installation status
+ */
+program
+  .command('status')
+  .description('Check plugin installation status')
+  .action(async () => {
+    try {
+      const settings = loadClaudeSettings();
+      const pluginPath = getPluginPath();
+
+      console.log('\n🧠 Claude Memory Layer Status\n');
+
+      // Check hooks
+      const hasUserPromptHook = settings.hooks?.UserPromptSubmit?.some(h =>
+        h.hooks?.some(hook => hook.command?.includes('user-prompt-submit'))
+      );
+      const hasPostToolHook = settings.hooks?.PostToolUse?.some(h =>
+        h.hooks?.some(hook => hook.command?.includes('post-tool-use'))
+      );
+
+      console.log('Hooks:');
+      console.log(`  UserPromptSubmit: ${hasUserPromptHook ? '✅ Installed' : '❌ Not installed'}`);
+      console.log(`  PostToolUse: ${hasPostToolHook ? '✅ Installed' : '❌ Not installed'}`);
+
+      // Check plugin files
+      const hooksExist = fs.existsSync(path.join(pluginPath, 'hooks', 'user-prompt-submit.js'));
+      console.log(`\nPlugin files: ${hooksExist ? '✅ Found' : '❌ Not found'}`);
+      console.log(`  Path: ${pluginPath}`);
+
+      // Check dashboard
+      const dashboardRunning = await isServerRunning(37777);
+      console.log(`\nDashboard: ${dashboardRunning ? '✅ Running at http://localhost:37777' : '⏹️  Not running'}`);
+
+      if (!hasUserPromptHook || !hasPostToolHook) {
+        console.log('\n💡 Run "claude-memory-layer install" to set up hooks.\n');
+      } else {
+        console.log('\n✅ Plugin is fully installed and configured.\n');
+      }
+    } catch (error) {
+      console.error('Status check failed:', error);
+      process.exit(1);
+    }
+  });
+
 /**
  * Search command
  */
@@ -349,7 +577,7 @@ program
         console.log(`... and ${sessions.length - 20} more sessions`);
       }
 
-      console.log('\nUse "code-memory import --session <path>" to import a specific session');
+      console.log('\nUse "claude-memory-layer import --session <path>" to import a specific session');
     } catch (error) {
       console.error('List failed:', error);
       process.exit(1);
@@ -389,7 +617,7 @@ endlessCmd
       console.log('  - Working Set: Recent context kept active');
       console.log('  - Consolidation: Automatic memory integration');
       console.log('  - Continuity: Seamless context transitions\n');
-      console.log('Use "code-memory endless status" to view current state');
+      console.log('Use "claude-memory-layer endless status" to view current state');
 
       await service.shutdown();
     } catch (error) {
@@ -462,7 +690,7 @@ endlessCmd
         }
       } else {
         console.log('Endless Mode is disabled.');
-        console.log('Use "code-memory endless enable" to activate.');
+        console.log('Use "claude-memory-layer endless enable" to activate.');
       }
 
       await service.shutdown();
@@ -488,7 +716,7 @@ endlessCmd
 
       if (!service.isEndlessModeActive()) {
         console.log('\n⚠️  Endless Mode is not active');
-        console.log('Use "code-memory endless enable" first');
+        console.log('Use "claude-memory-layer endless enable" first');
         process.exit(1);
       }
 
@@ -527,7 +755,7 @@ endlessCmd
 
       if (!service.isEndlessModeActive()) {
         console.log('\n⚠️  Endless Mode is not active');
-        console.log('Use "code-memory endless enable" first');
+        console.log('Use "claude-memory-layer endless enable" first');
         process.exit(1);
       }
 
@@ -628,4 +856,81 @@ endlessCmd
     }
   });
 
+/**
+ * Dashboard command - start web dashboard
+ */
+program
+  .command('dashboard')
+  .description('Open memory dashboard in browser')
+  .option('-p, --port <port>', 'Server port', '37777')
+  .option('--no-open', 'Do not auto-open browser')
+  .action(async (options) => {
+    const port = parseInt(options.port, 10);
+
+    try {
+      // Check if server is already running
+      const running = await isServerRunning(port);
+      if (running) {
+        console.log(`\n🧠 Dashboard already running at http://localhost:${port}\n`);
+        if (options.open) {
+          openBrowser(`http://localhost:${port}`);
+        }
+        return;
+      }
+
+      // Start the server
+      console.log('\n🧠 Starting Code Memory Dashboard...\n');
+      startServer(port);
+
+      // Open browser
+      if (options.open) {
+        setTimeout(() => {
+          openBrowser(`http://localhost:${port}`);
+        }, 500);
+      }
+
+      console.log(`\n📊 Dashboard: http://localhost:${port}`);
+      console.log('Press Ctrl+C to stop the server\n');
+
+      // Handle graceful shutdown
+      const shutdown = () => {
+        console.log('\n\n👋 Shutting down dashboard...');
+        stopServer();
+        process.exit(0);
+      };
+
+      process.on('SIGINT', shutdown);
+      process.on('SIGTERM', shutdown);
+
+      // Keep process alive
+      await new Promise(() => {});
+    } catch (error) {
+      console.error('Dashboard failed:', error);
+      process.exit(1);
+    }
+  });
+
+/**
+ * Open URL in default browser
+ */
+function openBrowser(url: string): void {
+  const platform = process.platform;
+  let command: string;
+
+  if (platform === 'darwin') {
+    command = `open "${url}"`;
+  } else if (platform === 'win32') {
+    command = `start "" "${url}"`;
+  } else {
+    command = `xdg-open "${url}"`;
+  }
+
+  exec(command, (error) => {
+    if (error) {
+      console.log(`\n⚠️  Could not open browser automatically.`);
+      console.log(`   Please open ${url} manually.\n`);
+    }
+  });
+}
+
 program.parse();

package/src/core/db-wrapper.ts

@@ -37,10 +37,17 @@ export function toDate(value: unknown): Date {
   return new Date(String(value));
 }
 
+export interface DatabaseOptions {
+  readOnly?: boolean;
+}
+
 /**
  * Creates a new DuckDB database with Promise-based API
  */
-export function createDatabase(path: string): Database {
+export function createDatabase(path: string, options?: DatabaseOptions): Database {
+  if (options?.readOnly) {
+    return new duckdb.Database(path, { access_mode: 'READ_ONLY' });
+  }
   return new duckdb.Database(path);
 }
 

package/src/core/event-store.ts

@@ -12,14 +12,20 @@ import {
   OutboxItem
 } from './types.js';
 import { makeCanonicalKey, makeDedupeKey } from './canonical-key.js';
-import { createDatabase, dbRun, dbAll, dbClose, toDate, type Database } from './db-wrapper.js';
+import { createDatabase, dbRun, dbAll, dbClose, toDate, type Database, type DatabaseOptions } from './db-wrapper.js';
+
+export interface EventStoreOptions extends DatabaseOptions {
+  // Additional options can be added here
+}
 
 export class EventStore {
   private db: Database;
   private initialized = false;
+  private readonly readOnly: boolean;
 
-  constructor(private dbPath: string) {
-    this.db = createDatabase(dbPath);
+  constructor(private dbPath: string, options?: EventStoreOptions) {
+    this.readOnly = options?.readOnly ?? false;
+    this.db = createDatabase(dbPath, { readOnly: this.readOnly });
   }
 
   /**
@@ -28,6 +34,12 @@ export class EventStore {
   async initialize(): Promise<void> {
     if (this.initialized) return;
 
+    // In read-only mode, skip schema creation (tables already exist)
+    if (this.readOnly) {
+      this.initialized = true;
+      return;
+    }
+
     // L0 EventStore: Single Source of Truth (immutable, append-only)
     await dbRun(this.db, `
       CREATE TABLE IF NOT EXISTS events (
@@ -611,6 +623,43 @@ export class EventStore {
     return rows;
   }
 
+  /**
+   * Get events by memory level
+   */
+  async getEventsByLevel(level: string, options?: { limit?: number; offset?: number }): Promise<MemoryEvent[]> {
+    await this.initialize();
+
+    const limit = options?.limit || 50;
+    const offset = options?.offset || 0;
+
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
+      `SELECT e.* FROM events e
+       INNER JOIN memory_levels ml ON e.id = ml.event_id
+       WHERE ml.level = ?
+       ORDER BY e.timestamp DESC
+       LIMIT ? OFFSET ?`,
+      [level, limit, offset]
+    );
+
+    return rows.map(row => this.rowToEvent(row));
+  }
+
+  /**
+   * Get memory level for a specific event
+   */
+  async getEventLevel(eventId: string): Promise<string | null> {
+    await this.initialize();
+
+    const rows = await dbAll<{ level: string }>(
+      this.db,
+      `SELECT level FROM memory_levels WHERE event_id = ?`,
+      [eventId]
+    );
+
+    return rows.length > 0 ? rows[0].level : null;
+  }
+
   // ============================================================
   // Endless Mode Helper Methods
   // ============================================================