anchi-kit 2.2.0 → 2.3.0

package/src/commands/memory.js

@@ -0,0 +1,158 @@
+// =============================================================================
+// anchi-kit Memory CLI Command
+// =============================================================================
+
+const { loadMemory, saveMemory, clearMemory, getMemorySummary, addNote, addDecision } = require('../lib/memoryManager');
+
+async function memory(action = 'show', arg = null) {
+    const targetDir = process.cwd();
+
+    console.log('');
+    console.log('🧠 anchi-kit Memory');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+
+    switch (action) {
+        case 'show':
+        case undefined:
+            showMemory(targetDir);
+            break;
+
+        case 'save':
+            saveProjectMemory(targetDir, arg);
+            break;
+
+        case 'load':
+            loadProjectMemory(targetDir);
+            break;
+
+        case 'clear':
+            clearProjectMemory(targetDir);
+            break;
+
+        case 'add':
+            addToMemory(targetDir, arg);
+            break;
+
+        default:
+            console.log('Usage:');
+            console.log('  npx anchi-kit memory show     Show current memory');
+            console.log('  npx anchi-kit memory save     Save context');
+            console.log('  npx anchi-kit memory load     Load context');
+            console.log('  npx anchi-kit memory clear    Clear memory');
+            console.log('  npx anchi-kit memory add "note"  Add a note');
+            break;
+    }
+
+    console.log('');
+}
+
+function showMemory(targetDir) {
+    const memory = loadMemory(targetDir);
+
+    console.log('📂 Project:');
+    if (memory.project.name) {
+        console.log(`   Name: ${memory.project.name}`);
+        if (memory.project.description) {
+            console.log(`   Description: ${memory.project.description}`);
+        }
+        if (memory.project.tech_stack.length > 0) {
+            console.log(`   Tech: ${memory.project.tech_stack.join(', ')}`);
+        }
+        if (memory.project.architecture) {
+            console.log(`   Architecture: ${memory.project.architecture}`);
+        }
+    } else {
+        console.log('   (No project info saved)');
+    }
+
+    console.log('');
+    console.log('📌 Last Session:');
+    if (memory.session.last_task) {
+        console.log(`   Task: ${memory.session.last_task}`);
+        if (memory.session.current_phase) {
+            console.log(`   Phase: ${memory.session.current_phase}`);
+        }
+        console.log(`   Last accessed: ${memory.session.last_accessed || 'Never'}`);
+    } else {
+        console.log('   (No session info)');
+    }
+
+    console.log('');
+    console.log('🧠 Decisions:');
+    if (memory.decisions.length > 0) {
+        const recent = memory.decisions.slice(-5);
+        for (const d of recent) {
+            console.log(`   • ${d.decision}`);
+        }
+        if (memory.decisions.length > 5) {
+            console.log(`   ... and ${memory.decisions.length - 5} more`);
+        }
+    } else {
+        console.log('   (No decisions recorded)');
+    }
+
+    console.log('');
+    console.log('📝 Notes:');
+    if (memory.notes.length > 0) {
+        const recent = memory.notes.slice(-5);
+        for (const n of recent) {
+            console.log(`   • ${n.note}`);
+        }
+        if (memory.notes.length > 5) {
+            console.log(`   ... and ${memory.notes.length - 5} more`);
+        }
+    } else {
+        console.log('   (No notes)');
+    }
+}
+
+function saveProjectMemory(targetDir, note) {
+    const memory = loadMemory(targetDir);
+    if (note) {
+        memory.notes.push({
+            id: Date.now(),
+            note: note,
+            category: 'session',
+            timestamp: new Date().toISOString(),
+        });
+    }
+    const path = saveMemory(targetDir, memory);
+    console.log('✅ Memory saved!');
+    console.log(`   Location: ${path}`);
+    console.log(`   Stats:`);
+    console.log(`     • Decisions: ${memory.decisions.length}`);
+    console.log(`     • Notes: ${memory.notes.length}`);
+    console.log(`     • Entities: ${Object.keys(memory.entities).length}`);
+}
+
+function loadProjectMemory(targetDir) {
+    const summary = getMemorySummary(targetDir);
+    console.log(summary);
+    console.log('');
+    console.log('✅ Context loaded! AI now remembers your project.');
+}
+
+function clearProjectMemory(targetDir) {
+    clearMemory(targetDir);
+    console.log('✅ Memory cleared!');
+    console.log('   All project context has been reset.');
+}
+
+function addToMemory(targetDir, content) {
+    if (!content) {
+        console.log('Usage: npx anchi-kit memory add "your note"');
+        return;
+    }
+
+    if (content.startsWith('decision:')) {
+        const parts = content.slice(9).split(' - ');
+        addDecision(targetDir, parts[0].trim(), parts[1] || '');
+        console.log('✅ Decision recorded!');
+    } else {
+        addNote(targetDir, content);
+        console.log('✅ Note added!');
+    }
+}
+
+module.exports = { memory };

package/src/lib/contextDatabase.js

@@ -0,0 +1,362 @@
+// =============================================================================
+// anchi-kit SQLite Context Database
+// Phase 2: Persistent storage with relationships
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+const DB_DIR = '.cursor/context';
+const DB_FILE = 'context.db';
+
+// SQLite schema for context database
+const SCHEMA = `
+-- Project information
+CREATE TABLE IF NOT EXISTS project (
+  id INTEGER PRIMARY KEY,
+  name TEXT,
+  description TEXT,
+  tech_stack TEXT,
+  architecture TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Session history
+CREATE TABLE IF NOT EXISTS sessions (
+  id INTEGER PRIMARY KEY,
+  task TEXT,
+  phase TEXT,
+  files_opened TEXT,
+  started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  ended_at DATETIME
+);
+
+-- Decisions log
+CREATE TABLE IF NOT EXISTS decisions (
+  id INTEGER PRIMARY KEY,
+  decision TEXT NOT NULL,
+  reason TEXT,
+  files_affected TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Notes
+CREATE TABLE IF NOT EXISTS notes (
+  id INTEGER PRIMARY KEY,
+  note TEXT NOT NULL,
+  category TEXT DEFAULT 'general',
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Entities (knowledge graph nodes)
+CREATE TABLE IF NOT EXISTS entities (
+  id INTEGER PRIMARY KEY,
+  name TEXT UNIQUE NOT NULL,
+  type TEXT,
+  description TEXT,
+  metadata TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Entity relationships (knowledge graph edges)
+CREATE TABLE IF NOT EXISTS relations (
+  id INTEGER PRIMARY KEY,
+  source_id INTEGER NOT NULL,
+  target_id INTEGER NOT NULL,
+  relation_type TEXT NOT NULL,
+  metadata TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (source_id) REFERENCES entities(id),
+  FOREIGN KEY (target_id) REFERENCES entities(id)
+);
+
+-- File analysis cache
+CREATE TABLE IF NOT EXISTS file_cache (
+  id INTEGER PRIMARY KEY,
+  file_path TEXT UNIQUE NOT NULL,
+  summary TEXT,
+  entities TEXT,
+  last_modified DATETIME,
+  analyzed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+`;
+
+/**
+ * Get database path
+ */
+function getDbPath(targetDir) {
+    return path.join(targetDir, DB_DIR, DB_FILE);
+}
+
+/**
+ * Get database directory
+ */
+function getDbDir(targetDir) {
+    return path.join(targetDir, DB_DIR);
+}
+
+/**
+ * Check if better-sqlite3 is available
+ */
+function hasSqlite() {
+    try {
+        require('better-sqlite3');
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Initialize database (creates if not exists)
+ * Note: Requires better-sqlite3 package
+ */
+function initDatabase(targetDir) {
+    if (!hasSqlite()) {
+        console.log('SQLite not available. Using JSON fallback.');
+        return null;
+    }
+
+    const Database = require('better-sqlite3');
+    const dbDir = getDbDir(targetDir);
+    const dbPath = getDbPath(targetDir);
+
+    if (!fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    const db = new Database(dbPath);
+    db.exec(SCHEMA);
+
+    return db;
+}
+
+/**
+ * Get or create database instance
+ */
+let _db = null;
+function getDatabase(targetDir) {
+    if (!_db) {
+        _db = initDatabase(targetDir);
+    }
+    return _db;
+}
+
+/**
+ * Close database connection
+ */
+function closeDatabase() {
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+}
+
+// =============================================================================
+// CRUD Operations
+// =============================================================================
+
+/**
+ * Set project info
+ */
+function setProject(targetDir, info) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT OR REPLACE INTO project (id, name, description, tech_stack, architecture, updated_at)
+    VALUES (1, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `);
+
+    stmt.run(
+        info.name,
+        info.description,
+        JSON.stringify(info.tech_stack || []),
+        info.architecture
+    );
+
+    return info;
+}
+
+/**
+ * Get project info
+ */
+function getProject(targetDir) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const row = db.prepare('SELECT * FROM project WHERE id = 1').get();
+    if (!row) return null;
+
+    return {
+        name: row.name,
+        description: row.description,
+        tech_stack: JSON.parse(row.tech_stack || '[]'),
+        architecture: row.architecture,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+
+/**
+ * Add decision
+ */
+function addDecisionDb(targetDir, decision, reason = '', filesAffected = []) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO decisions (decision, reason, files_affected)
+    VALUES (?, ?, ?)
+  `);
+
+    const result = stmt.run(decision, reason, JSON.stringify(filesAffected));
+    return result.lastInsertRowid;
+}
+
+/**
+ * Get recent decisions
+ */
+function getDecisions(targetDir, limit = 10) {
+    const db = getDatabase(targetDir);
+    if (!db) return [];
+
+    return db.prepare(`
+    SELECT * FROM decisions ORDER BY created_at DESC LIMIT ?
+  `).all(limit);
+}
+
+/**
+ * Add note
+ */
+function addNoteDb(targetDir, note, category = 'general') {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO notes (note, category) VALUES (?, ?)
+  `);
+
+    const result = stmt.run(note, category);
+    return result.lastInsertRowid;
+}
+
+/**
+ * Get recent notes
+ */
+function getNotes(targetDir, category = null, limit = 10) {
+    const db = getDatabase(targetDir);
+    if (!db) return [];
+
+    if (category) {
+        return db.prepare(`
+      SELECT * FROM notes WHERE category = ? ORDER BY created_at DESC LIMIT ?
+    `).all(category, limit);
+    }
+
+    return db.prepare(`
+    SELECT * FROM notes ORDER BY created_at DESC LIMIT ?
+  `).all(limit);
+}
+
+/**
+ * Upsert entity
+ */
+function upsertEntityDb(targetDir, name, type, description = '', metadata = {}) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO entities (name, type, description, metadata, updated_at)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(name) DO UPDATE SET
+      type = excluded.type,
+      description = excluded.description,
+      metadata = excluded.metadata,
+      updated_at = CURRENT_TIMESTAMP
+  `);
+
+    stmt.run(name, type, description, JSON.stringify(metadata));
+    return name;
+}
+
+/**
+ * Get entity
+ */
+function getEntityDb(targetDir, name) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const row = db.prepare('SELECT * FROM entities WHERE name = ?').get(name);
+    if (!row) return null;
+
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        description: row.description,
+        metadata: JSON.parse(row.metadata || '{}'),
+    };
+}
+
+/**
+ * Add relation between entities
+ */
+function addRelation(targetDir, sourceName, targetName, relationType, metadata = {}) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const source = db.prepare('SELECT id FROM entities WHERE name = ?').get(sourceName);
+    const target = db.prepare('SELECT id FROM entities WHERE name = ?').get(targetName);
+
+    if (!source || !target) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO relations (source_id, target_id, relation_type, metadata)
+    VALUES (?, ?, ?, ?)
+  `);
+
+    const result = stmt.run(source.id, target.id, relationType, JSON.stringify(metadata));
+    return result.lastInsertRowid;
+}
+
+/**
+ * Get relations for entity
+ */
+function getRelations(targetDir, entityName) {
+    const db = getDatabase(targetDir);
+    if (!db) return [];
+
+    return db.prepare(`
+    SELECT 
+      r.*,
+      s.name as source_name,
+      t.name as target_name
+    FROM relations r
+    JOIN entities s ON r.source_id = s.id
+    JOIN entities t ON r.target_id = t.id
+    WHERE s.name = ? OR t.name = ?
+  `).all(entityName, entityName);
+}
+
+module.exports = {
+    SCHEMA,
+    getDbPath,
+    initDatabase,
+    getDatabase,
+    closeDatabase,
+    hasSqlite,
+    // CRUD
+    setProject,
+    getProject,
+    addDecisionDb,
+    getDecisions,
+    addNoteDb,
+    getNotes,
+    upsertEntityDb,
+    getEntityDb,
+    addRelation,
+    getRelations,
+};