@trlc/super-memory 1.0.0 → 1.1.0

package/dist/commands/dashboard.js

@@ -0,0 +1,165 @@
+/**
+ * Dashboard Command
+ * Starts a local web server with the Super Memory dashboard
+ */
+import { spawn, execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import net from 'net';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Get dashboard directory (relative to compiled output)
+function getDashboardDir() {
+    // When running from dist/, dashboard is at ../dashboard
+    const fromDist = join(__dirname, '..', '..', 'dashboard');
+    if (existsSync(fromDist)) {
+        return fromDist;
+    }
+    // When running from src/, dashboard is at ../../dashboard
+    const fromSrc = join(__dirname, '..', '..', 'dashboard');
+    if (existsSync(fromSrc)) {
+        return fromSrc;
+    }
+    throw new Error('Dashboard directory not found');
+}
+// Get config
+function loadConfig() {
+    const configPath = join(homedir(), '.openclaw', 'workspace', '.super-memory', 'config.json');
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+// Check if a port is available
+async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+// Find an available port
+async function findAvailablePort(startPort) {
+    for (let port = startPort; port < startPort + 100; port++) {
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    return startPort; // fallback
+}
+// Open browser
+function openBrowser(url) {
+    try {
+        const platform = process.platform;
+        let command;
+        if (platform === 'darwin') {
+            command = `open "${url}"`;
+        }
+        else if (platform === 'win32') {
+            command = `start "" "${url}"`;
+        }
+        else {
+            // Linux - try various commands
+            const browsers = ['xdg-open', 'sensible-browser', 'x-www-browser', 'gnome-open'];
+            for (const browser of browsers) {
+                try {
+                    execSync(`which ${browser}`, { stdio: 'ignore' });
+                    command = `${browser} "${url}"`;
+                    break;
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!command) {
+                console.log(`💡 Open your browser to: ${url}`);
+                return;
+            }
+        }
+        execSync(command, { stdio: 'ignore' });
+    }
+    catch {
+        console.log(`💡 Open your browser to: ${url}`);
+    }
+}
+export async function startDashboard(options = {}) {
+    const config = loadConfig();
+    console.log(`
+🦞 ============================================
+   SUPER MEMORY DASHBOARD
+   The Red Lobster Cartel
+   ============================================
+`);
+    if (!config) {
+        console.log('⚠️  Not initialized yet. The dashboard will show setup instructions.');
+        console.log('   Run: super-memory init --license=YOUR_KEY\n');
+    }
+    const dashboardDir = getDashboardDir();
+    const packageJsonPath = join(dashboardDir, 'package.json');
+    const nodeModulesPath = join(dashboardDir, 'node_modules');
+    // Check if dependencies are installed
+    if (!existsSync(nodeModulesPath)) {
+        console.log('📦 Installing dashboard dependencies...');
+        try {
+            execSync('npm install', {
+                cwd: dashboardDir,
+                stdio: 'inherit',
+            });
+            console.log('✅ Dependencies installed\n');
+        }
+        catch (error) {
+            console.error('❌ Failed to install dependencies');
+            process.exit(1);
+        }
+    }
+    // Find available port
+    const defaultPort = options.port || 8765;
+    const port = await findAvailablePort(defaultPort);
+    if (port !== defaultPort) {
+        console.log(`⚠️  Port ${defaultPort} is in use, using ${port} instead\n`);
+    }
+    // Start the server
+    console.log('🚀 Starting dashboard server...\n');
+    const serverPath = join(dashboardDir, 'server.js');
+    const server = spawn('node', [serverPath], {
+        cwd: dashboardDir,
+        env: {
+            ...process.env,
+            SUPER_MEMORY_PORT: port.toString(),
+        },
+        stdio: 'inherit',
+    });
+    // Wait a bit for server to start
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    const url = `http://localhost:${port}`;
+    // Open browser
+    if (!options.noBrowser) {
+        console.log(`🌐 Opening browser to ${url}\n`);
+        openBrowser(url);
+    }
+    // Handle server exit
+    server.on('close', (code) => {
+        if (code !== 0) {
+            console.error(`\n❌ Dashboard server exited with code ${code}`);
+            process.exit(code || 1);
+        }
+    });
+    // Handle SIGINT
+    process.on('SIGINT', () => {
+        console.log('\n\n👋 Shutting down dashboard...');
+        server.kill();
+        process.exit(0);
+    });
+    // Keep process alive
+    await new Promise(() => { });
+}

package/dist/commands/flush.js

@@ -0,0 +1,70 @@
+/**
+ * Flush Command
+ * Saves critical context before session compaction
+ */
+import { loadConfig, getConvexUrl } from '../utils/config.js';
+export async function cmdFlush(args) {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ Not initialized. Run: super-memory init --license=YOUR_KEY');
+        process.exit(1);
+    }
+    // Get context from args or prompt
+    let context = args.find(arg => !arg.startsWith('--'));
+    let title = args.find(arg => arg.startsWith('--title='))?.split('=')[1];
+    if (!context) {
+        const readline = await import('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        context = await new Promise((resolve) => {
+            rl.question('📝 Enter context to flush (critical info to save): ', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+    }
+    if (!context) {
+        console.error('❌ No context provided');
+        process.exit(1);
+    }
+    console.log('\n🚨 Flushing critical context...\n');
+    try {
+        const response = await fetch(`${getConvexUrl()}/api/mutation`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'sync:flush',
+                args: {
+                    licenseKey: config.licenseKey,
+                    context,
+                    title,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status}`);
+        }
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.errorMessage || 'Unknown error');
+        }
+        const data = result.value;
+        if (data.success) {
+            console.log('✅ Context flushed successfully!\n');
+            console.log(`   Memory ID: ${data.memoryId}`);
+            console.log(`   Title: ${title || 'Flushed Context'}`);
+            console.log('\n💡 This context is now safely stored in Layer 1 (Session)');
+            console.log('   and will be preserved even if your session context overflows.\n');
+        }
+        else {
+            console.error('❌ Failed to flush context');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/indexUpdate.js

@@ -0,0 +1,57 @@
+/**
+ * Index Update Command
+ * Creates progressive memory index (~70% token savings)
+ * Now includes AUTO-CURATE automatically!
+ */
+import { loadConfig, getConvexUrl } from '../utils/config.js';
+import { cmdCurate } from './curate.js';
+export async function cmdIndexUpdate(args = []) {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ Not initialized. Run: super-memory init --license=YOUR_KEY');
+        process.exit(1);
+    }
+    const skipCurate = args.includes('--skip-curate');
+    console.log('\n📚 Updating memory index...\n');
+    try {
+        const response = await fetch(`${getConvexUrl()}/api/mutation`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'sync:indexUpdate',
+                args: { licenseKey: config.licenseKey },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status}`);
+        }
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.errorMessage || 'Unknown error');
+        }
+        const data = result.value;
+        if (data.success) {
+            console.log('✅ Index updated successfully!\n');
+            console.log(`   Entries indexed: ${data.entriesAdded}`);
+            console.log(`   Index size: ${data.indexSize.toLocaleString()} chars`);
+            console.log(`   Estimated savings: ${data.estimatedSavings}`);
+            console.log('\n💡 The progressive index provides ~70% token savings');
+            console.log('   when searching and reviewing your memories.\n');
+            // AUTO-CURATE: Run automatically after index update
+            if (!skipCurate) {
+                console.log('────────────────────────────────────────');
+                console.log('🧠 Running AUTO-CURATE...\n');
+                await cmdCurate(['--silent']);
+                console.log('✅ Auto-curate completed! MEMORY.md updated.\n');
+            }
+        }
+        else {
+            console.error('❌ Failed to update index');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/commands/maintenance.js

@@ -0,0 +1,68 @@
+/**
+ * Maintenance Command
+ * Weekly review with smart suggestions
+ */
+import { loadConfig, getConvexUrl } from '../utils/config.js';
+export async function cmdMaintenance() {
+    const config = loadConfig();
+    if (!config) {
+        console.error('❌ Not initialized. Run: super-memory init --license=YOUR_KEY');
+        process.exit(1);
+    }
+    console.log('\n🔧 Running maintenance check...\n');
+    try {
+        const response = await fetch(`${getConvexUrl()}/api/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: 'dashboard:getMaintenance',
+                args: { licenseKey: config.licenseKey },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`API error: ${response.status}`);
+        }
+        const result = await response.json();
+        if (result.status === 'error') {
+            throw new Error(result.errorMessage || 'Unknown error');
+        }
+        const data = result.value;
+        if (data.success) {
+            console.log('📊 Memory Statistics');
+            console.log('===================');
+            console.log(`Total Memories: ${data.stats.totalMemories}`);
+            console.log(`Average per Day: ${data.stats.avgMemoriesPerDay}`);
+            console.log(`Oldest Memory: ${data.stats.oldestMemoryDays} days old`);
+            console.log('');
+            console.log('Category Balance:');
+            console.log(`  🔴 Gotchas: ${data.stats.categoryBalance.gotcha}`);
+            console.log(`  🟡 Problem-Fix: ${data.stats.categoryBalance.problem}`);
+            console.log(`  🟤 Decisions: ${data.stats.categoryBalance.decision}`);
+            console.log(`  🟣 Discoveries: ${data.stats.categoryBalance.discovery}`);
+            console.log('');
+            if (data.suggestions.length === 0) {
+                console.log('✅ No maintenance suggestions - your memory is healthy!\n');
+            }
+            else {
+                console.log('🔍 Suggestions');
+                console.log('===============');
+                for (const suggestion of data.suggestions) {
+                    const priorityEmoji = suggestion.priority === 'high' ? '🔴' :
+                        suggestion.priority === 'medium' ? '🟡' : '🟢';
+                    console.log(`${priorityEmoji} ${suggestion.title}`);
+                    console.log(`   ${suggestion.description}`);
+                    console.log(`   Action: ${suggestion.action}`);
+                    console.log('');
+                }
+            }
+        }
+        else {
+            console.error('❌ Failed to get maintenance suggestions');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -9,8 +9,16 @@
  *   super-memory search "query term"
  *   super-memory sync
  *   super-memory status
+ *   super-memory dashboard [--port=8765] [--no-browser]
+ *   super-memory curate [--days=7] [--dry-run]  ← NEW!
  */
 import { execSync } from 'child_process';
+import { startDashboard } from './commands/dashboard.js';
+import { cmdIndexUpdate } from './commands/indexUpdate.js';
+import { cmdFlush } from './commands/flush.js';
+import { cmdMaintenance } from './commands/maintenance.js';
+import { cmdCategorize } from './commands/categorize.js';
+import { cmdCurate } from './commands/curate.js';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
@@ -193,6 +201,45 @@ async function cmdInit(args) {
 
 ---
 
+*Powered by The Red Lobster Cartel 🦞*
+`);
+        }
+        // Create MEMORY.md (Long-Term Memory) - Layer 3
+        const baseDir = getBaseDir();
+        const longTermPath = join(baseDir, 'MEMORY.md');
+        if (!existsSync(longTermPath)) {
+            writeFileSync(longTermPath, `# 🧠 Long-Term Memory
+
+**Installed:** ${today}
+**Plan:** ${validation.plan}
+**System:** Super Memory 5-Layer Architecture
+
+---
+
+## 👤 User Identity
+
+*Add your personal information, preferences, and context here.*
+
+---
+
+## 🎯 Current Projects
+
+*Track your active projects and their status.*
+
+---
+
+## 🔴 Gotchas & Learnings
+
+*Important lessons, pitfalls, and discoveries.*
+
+---
+
+## 📊 System Status
+
+**Last Updated:** ${today}
+
+---
+
 *Powered by The Red Lobster Cartel 🦞*
 `);
         }
@@ -390,6 +437,23 @@ COMMANDS:
 
   status                       Show status and stats
 
+  index-update                 Update progressive MEMORY_INDEX.md (Layer 4)
+                               Also auto-curates to MEMORY.md
+
+  curate                       Auto-curate important entries to MEMORY.md (Layer 3)
+                               Extracts gotchas, problems, decisions, discoveries
+                               from recent daily logs automatically
+
+  flush <context>              Save critical context before compaction
+
+  maintenance                  Run weekly review and get suggestions
+
+  categorize <id>              Auto-categorize memory entry
+
+  dashboard                    Open web dashboard
+    --port=8765               Custom port
+    --no-browser              Don't auto-open browser
+
   help                         Show this help
 
 EXAMPLES:
@@ -398,11 +462,22 @@ EXAMPLES:
   super-memory search "cors error"
   super-memory sync
   super-memory status
+  super-memory dashboard
+  super-memory dashboard --port=3000 --no-browser
 
 WEBSITE: https://theredlobstercartel.com/super-memory
 SUPPORT: support@theredlobstercartel.com
 `);
 }
+// COMMAND: dashboard
+async function cmdDashboard(args) {
+    const portArg = args.find(arg => arg.startsWith('--port='))?.split('=')[1];
+    const noBrowser = args.includes('--no-browser');
+    await startDashboard({
+        port: portArg ? parseInt(portArg, 10) : undefined,
+        noBrowser,
+    });
+}
 // Main
 async function main() {
     const args = process.argv.slice(2);
@@ -424,6 +499,24 @@ async function main() {
         case 'status':
             await cmdStatus(cmdArgs);
             break;
+        case 'dashboard':
+            await cmdDashboard(cmdArgs);
+            break;
+        case 'index-update':
+            await cmdIndexUpdate(cmdArgs);
+            break;
+        case 'curate':
+            await cmdCurate(cmdArgs);
+            break;
+        case 'flush':
+            await cmdFlush(cmdArgs);
+            break;
+        case 'maintenance':
+            await cmdMaintenance();
+            break;
+        case 'categorize':
+            await cmdCategorize(cmdArgs);
+            break;
         case 'help':
         case '--help':
         case '-h':

package/dist/utils/config.js

@@ -0,0 +1,44 @@
+/**
+ * Config utilities
+ */
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const CONVEX_URL = 'https://clear-lemming-473.convex.cloud';
+export function getBaseDir() {
+    return join(homedir(), '.openclaw', 'workspace');
+}
+export function getMemoryDir() {
+    return join(getBaseDir(), 'memory');
+}
+export function getConfigDir() {
+    return join(getBaseDir(), '.super-memory');
+}
+export function getConfigPath() {
+    return join(getConfigDir(), 'config.json');
+}
+export function getConvexUrl() {
+    return CONVEX_URL;
+}
+export function loadConfig() {
+    const configPath = getConfigPath();
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    const configDir = getConfigDir();
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    writeFileSync(getConfigPath(), JSON.stringify(config, null, 2));
+}
+export function isValidLicenseKey(key) {
+    return /^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/.test(key);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trlc/super-memory",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Super Memory CLI - AI-powered persistent memory by The Red Lobster Cartel",
   "main": "dist/index.js",
   "bin": {
@@ -9,6 +9,8 @@
   "type": "module",
   "scripts": {
     "build": "tsc",
+    "postinstall": "cd dashboard && npm install --silent || true",
+    "dashboard": "node dashboard/server.js",
     "prepublishOnly": "npm run build",
     "test": "node dist/index.js --help"
   },