@alucardeht/claude-memory 1.0.3 → 2.0.1

package/README.md

@@ -0,0 +1,205 @@
+# claude-memory
+
+Automatic, invisible memory for Claude Code. Never lose context after `/compact` again.
+
+## What it does
+
+claude-memory automatically:
+1. **Saves conversations** before `/compact` clears context
+2. **Injects relevant context** into every prompt based on what you're working on
+3. **Works invisibly** - install once, forget about it
+
+## Installation
+
+```bash
+npm install -g @alucardeht/claude-memory
+```
+
+> **Note**: The `claude-memory install` command runs automatically after npm install.
+
+That's it. The installer automatically:
+- Downloads the correct binary for your platform
+- Configures Claude Code hooks
+- Creates the memory database
+
+## How it works
+
+```
+┌─ Session Start ─────────────────────────────────┐
+│ Loads project core memory                       │
+│ → "You're working on X, preferences are Y..."   │
+└─────────────────────────────────────────────────┘
+                        ↓
+┌─ Every Prompt ──────────────────────────────────┐
+│ 1. Extracts entities (files, functions, errors) │
+│ 2. Searches for relevant past context           │
+│ 3. Injects as system message (~4000 tokens)     │
+│ Performance: <5ms total                         │
+└─────────────────────────────────────────────────┘
+                        ↓
+┌─ Before /compact ───────────────────────────────┐
+│ Saves entire conversation with importance scores│
+│ → Context preserved for future sessions         │
+└─────────────────────────────────────────────────┘
+```
+
+### What gets saved
+
+Both your messages AND Claude's responses are saved, including:
+- Files and functions mentioned
+- Errors discussed
+- Decisions made
+
+### What gets injected
+
+On each prompt, the system searches your past conversations and injects relevant context. Example of what Claude sees:
+
+```
+## Relevant History
+[user, 3 days ago]
+How do I fix the auth bug?
+Files: auth/login.go
+
+[assistant, 3 days ago]
+The issue is in line 45, the token wasn't being validated...
+Decisions: Use JWT instead of sessions
+```
+
+### In practice
+
+- You mention `auth/login.go` → System finds past discussions about that file
+- You ask "what was that bug?" → System finds error-related conversations
+- You start fresh session → Claude already has context from days ago
+
+### Context Budget
+
+Claude-memory automatically manages context size to prevent token overflow:
+
+| Component | Token Budget | Max Size |
+|-----------|--------------|----------|
+| Core Memory | 500 tokens | ~2KB |
+| Retrieved Context | 3500 tokens | ~14KB |
+| **Total** | **4000 tokens** | **~16KB** |
+
+**Safety features:**
+- Automatic truncation when limits are exceeded
+- Warning logs via `slog` when approaching limits
+- Hard safety net at 20KB (user prompts) / 10KB (session start)
+
+This is transparent and requires no configuration.
+
+### Privacy
+
+All data stays local in `~/.claude-memory/`. No cloud, no sync, no network calls.
+
+## Commands
+
+```bash
+# Install hooks (done automatically on npm install)
+claude-memory install
+
+# Uninstall hooks
+claude-memory install --uninstall
+
+# Search your memory manually
+claude-memory search "auth bug"
+claude-memory search "database migration" --project /path/to/project
+
+# Show version
+claude-memory --version
+```
+
+## Search options
+
+```bash
+claude-memory search [query] [flags]
+
+Flags:
+  -n, --limit int      Maximum results (default 10)
+  -p, --project path   Search specific project
+  -s, --scores         Show relevance scores
+```
+
+## How scoring works
+
+| Content Type | Score Boost |
+|--------------|-------------|
+| File mentions (src/auth.go) | +3 |
+| Function mentions (validateToken) | +2 |
+| Error patterns | +3 |
+| Decision phrases ("vamos usar", "let's use") | +2 |
+| Short/filler messages ("ok", "got it") | -2 |
+
+Recency also matters:
+- Last hour: 2x boost
+- Last day: 1.5x boost
+- Last week: 1.2x boost
+- Older than month: 0.8x penalty
+
+## Storage
+
+Memory is stored in `~/.claude-memory/memory.db` (SQLite with FTS5).
+
+Each project has isolated memory based on its absolute path.
+
+## Performance
+
+| Operation | Target | Actual |
+|-----------|--------|--------|
+| Entity extraction | <1ms | ~170µs |
+| FTS search | <1ms | ~200µs |
+| Context injection | <5ms | ~160µs |
+| Session start | <1ms | ~30µs |
+
+## Requirements
+
+- Claude Code CLI
+- Node.js 16+ (for npm installation)
+- macOS, Linux, or Windows
+
+## Windows Support
+
+claude-memory has full support for Windows 10 and Windows 11.
+
+### Installation (same as other platforms)
+
+```powershell
+npm install -g @alucardeht/claude-memory
+claude-memory install
+```
+
+### Windows-specific paths
+
+| Data | Location |
+|------|----------|
+| Claude settings | `%APPDATA%\Claude\settings.json` |
+| claude-memory database | `%APPDATA%\claude-memory\memory.db` |
+| claude-memory config | `%APPDATA%\claude-memory\config.json` |
+
+> **Note**: On Windows, `%APPDATA%` typically resolves to `C:\Users\YourUsername\AppData\Roaming\`
+
+### Requirements for Windows
+
+- Node.js 16+ (download from [nodejs.org](https://nodejs.org))
+- Git for Windows (recommended, includes Git Bash)
+- Claude Code CLI installed and configured
+
+### Troubleshooting
+
+If you encounter issues:
+
+1. **Binary not found**: Try reinstalling with `npm install -g @alucardeht/claude-memory`
+2. **Permission errors**: Run PowerShell/CMD as Administrator
+3. **Path issues**: Ensure `%APPDATA%\npm` is in your system PATH
+
+## Uninstall
+
+```bash
+npm uninstall -g @alucardeht/claude-memory
+```
+
+This removes the CLI and hooks. Memory database remains in `~/.claude-memory/`.
+
+## License
+
+MIT

package/bin/claude-memory.cmd

@@ -0,0 +1,25 @@
+@echo off
+setlocal EnableDelayedExpansion
+
+REM Claude Memory - Windows Wrapper
+REM Executes the claude-memory binary with all arguments
+
+set "SCRIPT_DIR=%~dp0"
+
+REM Remove trailing backslash
+if "%SCRIPT_DIR:~-1%"=="\" set "SCRIPT_DIR=%SCRIPT_DIR:~0,-1%"
+
+REM Check if Windows binary exists
+if exist "%SCRIPT_DIR%\claude-memory.exe" (
+    "%SCRIPT_DIR%\claude-memory.exe" %*
+    exit /b %ERRORLEVEL%
+)
+
+REM Binary not found - show error
+echo Error: claude-memory.exe binary not found in %SCRIPT_DIR% >&2
+echo. >&2
+echo Try reinstalling: npm install -g @alucardeht/claude-memory >&2
+echo. >&2
+echo If the problem persists, please report at: >&2
+echo https://github.com/alucardeht/claude-memory/issues >&2
+exit /b 1

package/install.js

@@ -1,127 +1,211 @@
 #!/usr/bin/env node
 
-const { execSync, spawn } = require('child_process');
+const https = require('https');
 const fs = require('fs');
 const path = require('path');
-const https = require('https');
+const { spawnSync } = require('child_process');
 const os = require('os');
 
 const VERSION = require('./package.json').version;
-const REPO = 'alucardeht/claude-memory';
-
-function getPlatform() {
-  const platform = os.platform();
-  const arch = os.arch();
-
-  const platformMap = {
-    darwin: 'darwin',
-    linux: 'linux',
-    win32: 'windows',
-  };
-
-  const archMap = {
-    x64: 'amd64',
-    arm64: 'arm64',
-  };
-
-  const p = platformMap[platform];
-  const a = archMap[arch];
-
-  if (!p || !a) {
-    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+const BIN_DIR = path.join(__dirname, 'bin');
+const HOME_DIR = os.homedir();
+const OLD_HOOKS_DIR = path.join(HOME_DIR, '.claude', 'hooks');
+const OLD_DB_DIR = path.join(HOME_DIR, '.claude-memory');
+
+const PLATFORM_MAP = {
+  darwin: 'darwin',
+  linux: 'linux',
+  win32: 'windows'
+};
+
+const ARCH_MAP = {
+  x64: 'amd64',
+  arm64: 'arm64'
+};
+
+function getPlatformArch() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+
+  if (!platform || !arch) {
+    return null;
   }
 
-  return { platform: p, arch: a };
-}
-
-function getBinaryName() {
-  const { platform, arch } = getPlatform();
-  const ext = platform === 'windows' ? '.exe' : '';
-  return `claude-memory-${platform}-${arch}${ext}`;
-}
-
-function getDownloadUrl() {
-  const binaryName = getBinaryName();
-  return `https://github.com/${REPO}/releases/download/v${VERSION}/${binaryName}`;
+  return { platform, arch };
 }
 
-function download(url, dest) {
+function downloadBinary(url, destPath) {
   return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
+    const file = fs.createWriteStream(destPath);
 
-    const request = (url) => {
-      https.get(url, (response) => {
-        if (response.statusCode === 302 || response.statusCode === 301) {
-          request(response.headers.location);
+    https
+      .get(url, (response) => {
+        if (response.statusCode === 404) {
+          reject(new Error('Binary not found. Platform or architecture may not be supported.'));
           return;
         }
 
         if (response.statusCode !== 200) {
-          reject(new Error(`Failed to download: ${response.statusCode}`));
+          reject(new Error(`Download failed with status ${response.statusCode}`));
           return;
         }
 
         response.pipe(file);
-        file.on('finish', () => {
-          file.close();
-          resolve();
-        });
-      }).on('error', (err) => {
-        fs.unlink(dest, () => {});
+      })
+      .on('error', (err) => {
+        fs.unlink(destPath, () => {});
         reject(err);
       });
-    };
 
-    request(url);
+    file.on('finish', () => {
+      file.close();
+      resolve();
+    });
+
+    file.on('error', (err) => {
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
   });
 }
 
-async function main() {
-  const binDir = path.join(__dirname, 'bin');
-  const { platform } = getPlatform();
-  const binaryName = platform === 'windows' ? 'claude-memory.exe' : 'claude-memory';
-  const binaryPath = path.join(binDir, binaryName);
+function makeExecutable(filePath) {
+  if (process.platform !== 'win32') {
+    fs.chmodSync(filePath, '0755');
+  }
+}
+
+function runCommand(command, args, description) {
+  console.log(`\n→ ${description}`);
+
+  const result = spawnSync(command, args, {
+    stdio: 'inherit',
+    shell: process.platform === 'win32'
+  });
 
-  if (!fs.existsSync(binDir)) {
-    fs.mkdirSync(binDir, { recursive: true });
+  if (result.error) {
+    throw new Error(`${description} failed: ${result.error.message}`);
   }
 
-  const url = getDownloadUrl();
-  console.log(`Downloading claude-memory from ${url}...`);
+  if (result.status !== 0) {
+    throw new Error(`${description} failed with exit code ${result.status}`);
+  }
+}
+
+function isOldInstallationPresent() {
+  const hasOldHooks = fs.existsSync(OLD_HOOKS_DIR);
+  const hasOldDb = fs.existsSync(OLD_DB_DIR);
+  return hasOldHooks || hasOldDb;
+}
+
+function removeOldHooks() {
+  if (!fs.existsSync(OLD_HOOKS_DIR)) {
+    return;
+  }
+
+  const hookFiles = ['user-prompt-submit.sh', 'pre-compact.sh', 'session-end.sh'];
+
+  for (const hookFile of hookFiles) {
+    const hookPath = path.join(OLD_HOOKS_DIR, hookFile);
+    if (fs.existsSync(hookPath)) {
+      fs.unlinkSync(hookPath);
+    }
+  }
 
   try {
-    await download(url, binaryPath);
+    if (fs.readdirSync(OLD_HOOKS_DIR).length === 0) {
+      fs.rmdirSync(OLD_HOOKS_DIR);
+    }
   } catch (err) {
-    console.error(`Failed to download binary: ${err.message}`);
-    console.error('');
-    console.error('You can manually install by:');
-    console.error('1. Download from: https://github.com/' + REPO + '/releases');
-    console.error('2. Place the binary in your PATH');
-    process.exit(1);
+    // Directory might not be empty, that's okay
   }
+}
 
-  if (platform !== 'windows') {
-    fs.chmodSync(binaryPath, 0o755);
+function migrateDatabase(binaryWrapper) {
+  if (!fs.existsSync(OLD_DB_DIR)) {
+    return;
   }
 
-  console.log('Binary installed successfully!');
-  console.log('');
-
-  console.log('Configuring Claude Code hooks...');
   try {
-    const result = spawn(binaryPath, ['install'], { stdio: 'inherit' });
-    result.on('close', (code) => {
-      if (code !== 0) {
-        console.error('Failed to configure hooks. Run "claude-memory install" manually.');
-      }
+    const result = spawnSync(binaryWrapper, ['migrate'], {
+      stdio: 'inherit',
+      shell: process.platform === 'win32'
     });
+
+    if (result.error) {
+      console.log('⚠️  Database migration skipped (binary not yet available)');
+    }
   } catch (err) {
-    console.error('Failed to run install command:', err.message);
-    console.error('Run "claude-memory install" manually after installation.');
+    console.log('⚠️  Database migration skipped');
+  }
+}
+
+async function main() {
+  try {
+    const isUpgrade = isOldInstallationPresent();
+
+    if (isUpgrade) {
+      console.log('⚠️  Upgrading from hook-based version...\n');
+    } else {
+      console.log('Installing claude-memory...\n');
+    }
+
+    const platformArch = getPlatformArch();
+    if (!platformArch) {
+      console.error(
+        'Error: Unsupported platform or architecture.\n' +
+          'Supported combinations:\n' +
+          '  - darwin (x64, arm64)\n' +
+          '  - linux (x64, arm64)\n' +
+          '  - win32 (x64, arm64)'
+      );
+      process.exit(1);
+    }
+
+    const { platform, arch } = platformArch;
+    const isWindows = process.platform === 'win32';
+    const binaryName = isWindows ? 'claude-memory.exe' : 'claude-memory';
+    const binaryPath = path.join(BIN_DIR, binaryName);
+    const downloadUrl = `https://github.com/alucardeht/claude-memory/releases/download/v${VERSION}/claude-memory-${platform}-${arch}${isWindows ? '.exe' : ''}`;
+
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+
+    console.log(`Downloading claude-memory for ${platform}-${arch}...`);
+    await downloadBinary(downloadUrl, binaryPath);
+    makeExecutable(binaryPath);
+    console.log('✓ Binary downloaded');
+
+    const binaryWrapper = isWindows ? path.join(BIN_DIR, 'claude-memory.cmd') : path.join(BIN_DIR, 'claude-memory');
+
+    if (isUpgrade) {
+      console.log('\n→ Removing old hooks...');
+      removeOldHooks();
+      console.log('✓ Old hooks removed');
+
+      console.log('\n→ Migrating database...');
+      migrateDatabase(binaryWrapper);
+      console.log('✓ Database migrated');
+    }
+
+    runCommand(binaryWrapper, ['install'], 'Installing Claude Code hooks');
+    console.log('✓ Hooks installed');
+
+    runCommand(binaryWrapper, ['daemon:install'], 'Starting memory daemon');
+    console.log('✓ Daemon registered');
+
+    if (isUpgrade) {
+      console.log('\n✅ Upgrade complete!');
+    } else {
+      console.log('\n✅ claude-memory installed successfully!');
+    }
+    console.log('The daemon will start automatically on login.\n');
+  } catch (error) {
+    console.error('\n❌ Installation failed:', error.message);
+    console.log('\nYou can try to manually install by running:');
+    console.log('  claude-memory install');
+    console.log('  claude-memory daemon:install\n');
+    process.exit(1);
   }
 }
 
-main().catch((err) => {
-  console.error('Installation failed:', err.message);
-  process.exit(1);
-});
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alucardeht/claude-memory",
-  "version": "1.0.3",
+  "version": "2.0.1",
   "description": "Automatic context persistence for Claude Code",
   "keywords": [
     "claude",
@@ -20,7 +20,7 @@
     "claude-memory": "./bin/claude-memory"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "postinstall": "node install.js || true"
   },
   "os": [
     "darwin",
@@ -35,7 +35,10 @@
     "node": ">=14"
   },
   "files": [
+    "README.md",
     "bin",
+    "bin/claude-memory",
+    "bin/claude-memory.cmd",
     "install.js"
   ]
 }