@su-record/vibe 0.1.0

package/mcp/dist/tools/memory/database.js

@@ -0,0 +1,123 @@
+// SQLite database connection and schema management
+import Database from 'better-sqlite3';
+import path from 'path';
+import { getMemoryDir } from './memoryConfig.js';
+import { existsSync, mkdirSync } from 'fs';
+class MemoryDatabase {
+    db = null;
+    dbPath;
+    constructor() {
+        const memoryDir = getMemoryDir();
+        // Ensure directory exists
+        if (!existsSync(memoryDir)) {
+            mkdirSync(memoryDir, { recursive: true });
+        }
+        this.dbPath = path.join(memoryDir, 'memories.db');
+    }
+    /**
+     * Get database connection (lazy initialization)
+     */
+    getConnection() {
+        if (!this.db) {
+            // Ensure directory exists before opening database
+            const memoryDir = getMemoryDir();
+            if (!existsSync(memoryDir)) {
+                mkdirSync(memoryDir, { recursive: true });
+            }
+            this.db = new Database(this.dbPath);
+            // Enable WAL mode for better concurrency
+            this.db.pragma('journal_mode = WAL');
+            // Initialize schema
+            this.initSchema();
+        }
+        return this.db;
+    }
+    /**
+     * Initialize database schema
+     */
+    initSchema() {
+        const db = this.db;
+        // Memories table
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        key TEXT UNIQUE NOT NULL,
+        value TEXT NOT NULL,
+        category TEXT NOT NULL DEFAULT 'general',
+        timestamp TEXT NOT NULL,
+        lastAccessed TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
+      CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+      CREATE INDEX IF NOT EXISTS idx_memories_lastAccessed ON memories(lastAccessed);
+    `);
+        // Sessions table
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        sessionId TEXT NOT NULL,
+        contextType TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        urgency TEXT NOT NULL,
+        currentTask TEXT,
+        codeChanges TEXT,
+        decisions TEXT,
+        blockers TEXT,
+        nextSteps TEXT,
+        timestamp TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sessions_sessionId ON sessions(sessionId);
+      CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_sessions_urgency ON sessions(urgency);
+    `);
+        // Guides table (for coding guides)
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS guides (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        category TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_guides_name ON guides(name);
+      CREATE INDEX IF NOT EXISTS idx_guides_category ON guides(category);
+    `);
+    }
+    /**
+     * Close database connection
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    /**
+     * Run a checkpoint to merge WAL file
+     */
+    checkpoint() {
+        if (this.db) {
+            this.db.pragma('wal_checkpoint(TRUNCATE)');
+        }
+    }
+}
+// Singleton instance
+export const memoryDB = new MemoryDatabase();
+// Cleanup on process exit
+process.on('exit', () => {
+    memoryDB.checkpoint();
+    memoryDB.close();
+});
+process.on('SIGINT', () => {
+    memoryDB.checkpoint();
+    memoryDB.close();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    memoryDB.checkpoint();
+    memoryDB.close();
+    process.exit(0);
+});

package/mcp/dist/tools/memory/deleteMemory.js

@@ -0,0 +1,39 @@
+// Memory management tool - completely independent
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const deleteMemoryDefinition = {
+    name: 'delete_memory',
+    description: '잊어|삭제해|지워|forget|delete|remove|erase - Delete specific memory',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'Memory key to delete' }
+        },
+        required: ['key']
+    },
+    annotations: {
+        title: 'Delete Memory',
+        audience: ['user', 'assistant']
+    }
+};
+export async function deleteMemory(args) {
+    const { key: deleteKey } = args;
+    try {
+        const mm = MemoryManager.getInstance();
+        const deleted = mm.delete(deleteKey);
+        if (deleted) {
+            return {
+                content: [{ type: 'text', text: `✓ Deleted memory: "${deleteKey}"` }]
+            };
+        }
+        else {
+            return {
+                content: [{ type: 'text', text: `✗ Memory not found: "${deleteKey}"` }]
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}

package/mcp/dist/tools/memory/listMemories.js

@@ -0,0 +1,38 @@
+// Memory management tool - completely independent
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const listMemoriesDefinition = {
+    name: 'list_memories',
+    description: '뭐 있었지|저장된 거|목록|what did I save|list memories|show saved - List saved memories',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            category: { type: 'string', description: 'Filter by category' },
+            limit: { type: 'number', description: 'Maximum number of results' }
+        },
+        required: []
+    },
+    annotations: {
+        title: 'List Memories',
+        audience: ['user', 'assistant']
+    }
+};
+export async function listMemories(args) {
+    const { category: listCategory, limit = 10 } = args;
+    try {
+        const mm = MemoryManager.getInstance();
+        const allMemories = mm.list(listCategory);
+        const limitedMemories = allMemories.slice(0, limit);
+        const memoryList = limitedMemories.map(m => `• ${m.key} (${m.category}): ${m.value.substring(0, 50)}${m.value.length > 50 ? '...' : ''}`).join('\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✓ Found ${allMemories.length} memories${listCategory ? ` in '${listCategory}'` : ''}:\n${memoryList || 'None'}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}

package/mcp/dist/tools/memory/memoryConfig.js

@@ -0,0 +1,27 @@
+// Memory configuration - centralized path management
+import path from 'path';
+/**
+ * Get memory directory path
+ * Respects HI_AI_MEMORY_DIR environment variable
+ */
+export function getMemoryDir() {
+    return process.env.HI_AI_MEMORY_DIR || path.join(process.cwd(), 'memories');
+}
+/**
+ * Get memory file path
+ */
+export function getMemoryFile() {
+    return path.join(getMemoryDir(), 'memories.json');
+}
+/**
+ * Get session context directory
+ */
+export function getSessionDir() {
+    return path.join(getMemoryDir(), 'sessions');
+}
+/**
+ * Get guides directory
+ */
+export function getGuidesDir() {
+    return process.env.HI_AI_GUIDES_DIR || path.join(process.cwd(), 'guides');
+}

package/mcp/dist/tools/memory/memorySQLite.js

@@ -0,0 +1,138 @@
+// SQLite-based memory operations
+import { memoryDB } from './database.js';
+/**
+ * Save or update memory
+ */
+export function saveMemory(key, value, category = 'general') {
+    const db = memoryDB.getConnection();
+    const timestamp = new Date().toISOString();
+    const stmt = db.prepare(`
+    INSERT INTO memories (key, value, category, timestamp, lastAccessed)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(key) DO UPDATE SET
+      value = excluded.value,
+      category = excluded.category,
+      timestamp = excluded.timestamp,
+      lastAccessed = excluded.lastAccessed
+  `);
+    stmt.run(key, value, category, timestamp, timestamp);
+}
+/**
+ * Get memory by key
+ */
+export function getMemory(key) {
+    const db = memoryDB.getConnection();
+    const stmt = db.prepare('SELECT * FROM memories WHERE key = ?');
+    const memory = stmt.get(key);
+    // Update last accessed time
+    if (memory) {
+        const updateStmt = db.prepare('UPDATE memories SET lastAccessed = ? WHERE key = ?');
+        updateStmt.run(new Date().toISOString(), key);
+    }
+    return memory;
+}
+/**
+ * List memories with optional filtering
+ */
+export function listMemories(options) {
+    const db = memoryDB.getConnection();
+    const { category, limit = 10, offset = 0 } = options;
+    let whereClause = '';
+    const params = [];
+    if (category) {
+        whereClause = 'WHERE category = ?';
+        params.push(category);
+    }
+    // Get total count
+    const countStmt = db.prepare(`SELECT COUNT(*) as count FROM memories ${whereClause}`);
+    const { count } = countStmt.get(...params);
+    // Get paginated results
+    const stmt = db.prepare(`
+    SELECT * FROM memories ${whereClause}
+    ORDER BY lastAccessed DESC
+    LIMIT ? OFFSET ?
+  `);
+    const memories = stmt.all(...params, limit, offset);
+    return { memories, total: count };
+}
+/**
+ * Search memories by content
+ */
+export function searchMemories(query, options) {
+    const db = memoryDB.getConnection();
+    const { category, limit = 20 } = options || {};
+    let whereClause = 'WHERE (key LIKE ? OR value LIKE ?)';
+    const params = [`%${query}%`, `%${query}%`];
+    if (category) {
+        whereClause += ' AND category = ?';
+        params.push(category);
+    }
+    const stmt = db.prepare(`
+    SELECT * FROM memories ${whereClause}
+    ORDER BY lastAccessed DESC
+    LIMIT ?
+  `);
+    return stmt.all(...params, limit);
+}
+/**
+ * Delete memory by key
+ */
+export function deleteMemory(key) {
+    const db = memoryDB.getConnection();
+    const stmt = db.prepare('DELETE FROM memories WHERE key = ?');
+    const result = stmt.run(key);
+    return result.changes > 0;
+}
+/**
+ * Update memory
+ */
+export function updateMemory(key, value, append = false) {
+    const db = memoryDB.getConnection();
+    if (append) {
+        const existing = getMemory(key);
+        if (existing) {
+            value = existing.value + '\n' + value;
+        }
+    }
+    const stmt = db.prepare(`
+    UPDATE memories
+    SET value = ?, lastAccessed = ?
+    WHERE key = ?
+  `);
+    const result = stmt.run(value, new Date().toISOString(), key);
+    return result.changes > 0;
+}
+/**
+ * Get memory statistics
+ */
+export function getMemoryStats() {
+    const db = memoryDB.getConnection();
+    // Total count
+    const totalStmt = db.prepare('SELECT COUNT(*) as count FROM memories');
+    const { count: totalMemories } = totalStmt.get();
+    // By category
+    const categoryStmt = db.prepare(`
+    SELECT category, COUNT(*) as count
+    FROM memories
+    GROUP BY category
+  `);
+    const categoryResults = categoryStmt.all();
+    const byCategory = Object.fromEntries(categoryResults.map(r => [r.category, r.count]));
+    // Recently accessed
+    const recentStmt = db.prepare(`
+    SELECT * FROM memories
+    ORDER BY lastAccessed DESC
+    LIMIT 10
+  `);
+    const recentlyAccessed = recentStmt.all();
+    return { totalMemories, byCategory, recentlyAccessed };
+}
+/**
+ * Clear all memories (use with caution!)
+ */
+export function clearAllMemories() {
+    const db = memoryDB.getConnection();
+    const stmt = db.prepare('DELETE FROM memories');
+    const result = stmt.run();
+    return result.changes;
+}

package/mcp/dist/tools/memory/memoryUtils.js

@@ -0,0 +1,34 @@
+// Shared memory utilities
+import { promises as fs } from 'fs';
+import { getMemoryDir, getMemoryFile } from './memoryConfig.js';
+/**
+ * Ensure memory directory exists
+ */
+export async function ensureMemoryDir() {
+    try {
+        await fs.access(getMemoryDir());
+    }
+    catch {
+        await fs.mkdir(getMemoryDir(), { recursive: true });
+    }
+}
+/**
+ * Load all memories from file
+ */
+export async function loadMemories() {
+    try {
+        await ensureMemoryDir();
+        const data = await fs.readFile(getMemoryFile(), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Save memories to file
+ */
+export async function saveMemories(memories) {
+    await ensureMemoryDir();
+    await fs.writeFile(getMemoryFile(), JSON.stringify(memories, null, 2));
+}

package/mcp/dist/tools/memory/migrate.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+// Migration utility to convert JSON memories to SQLite
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { getMemoryDir } from './memoryConfig.js';
+import { saveMemory } from './memorySQLite.js';
+import { memoryDB } from './database.js';
+/**
+ * Migrate from JSON to SQLite
+ */
+export async function migrateFromJSON() {
+    const memoryDir = getMemoryDir();
+    const jsonPath = path.join(memoryDir, 'memories.json');
+    const result = {
+        success: false,
+        migrated: 0,
+        errors: []
+    };
+    // Check if JSON file exists
+    if (!existsSync(jsonPath)) {
+        result.errors.push('No legacy memories.json file found');
+        return result;
+    }
+    try {
+        // Read JSON file
+        const jsonData = readFileSync(jsonPath, 'utf-8');
+        const memories = JSON.parse(jsonData);
+        console.log(`Found ${memories.length} memories to migrate`);
+        // Migrate each memory
+        for (const memory of memories) {
+            try {
+                saveMemory(memory.key, memory.value, memory.category);
+                result.migrated++;
+            }
+            catch (error) {
+                result.errors.push(`Failed to migrate key "${memory.key}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        result.success = true;
+        console.log(`✅ Successfully migrated ${result.migrated} memories`);
+        if (result.errors.length > 0) {
+            console.warn(`⚠️  ${result.errors.length} errors occurred during migration:`);
+            result.errors.forEach(err => console.warn(`   ${err}`));
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to read JSON file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    return result;
+}
+/**
+ * Export SQLite database to JSON (for backup)
+ */
+export async function exportToJSON(outputPath) {
+    const db = memoryDB.getConnection();
+    const stmt = db.prepare('SELECT * FROM memories');
+    const memories = stmt.all();
+    const exportPath = outputPath || path.join(getMemoryDir(), `backup-${Date.now()}.json`);
+    try {
+        const { writeFileSync } = await import('fs');
+        writeFileSync(exportPath, JSON.stringify(memories, null, 2));
+        return {
+            success: true,
+            exported: memories.length,
+            path: exportPath
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to export: ${error instanceof Error ? error.message : 'Unknown'}`);
+    }
+}
+// CLI interface
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const command = process.argv[2];
+    switch (command) {
+        case 'migrate':
+            console.log('🔄 Starting migration from JSON to SQLite...');
+            migrateFromJSON().then(result => {
+                if (result.success) {
+                    console.log(`\n✅ Migration completed: ${result.migrated} memories migrated`);
+                    process.exit(0);
+                }
+                else {
+                    console.error('\n❌ Migration failed');
+                    process.exit(1);
+                }
+            });
+            break;
+        case 'export':
+            console.log('📦 Exporting SQLite to JSON...');
+            exportToJSON().then(result => {
+                console.log(`\n✅ Export completed: ${result.exported} memories exported to ${result.path}`);
+                process.exit(0);
+            }).catch(error => {
+                console.error(`\n❌ Export failed: ${error.message}`);
+                process.exit(1);
+            });
+            break;
+        default:
+            console.log(`
+Hi-AI Memory Migration Tool
+
+Usage:
+  node dist/tools/memory/migrate.js migrate    Migrate from JSON to SQLite
+  node dist/tools/memory/migrate.js export     Export SQLite to JSON backup
+
+Options:
+  migrate    Convert memories.json to SQLite database
+  export     Create JSON backup of SQLite database
+      `);
+            break;
+    }
+}

package/mcp/dist/tools/memory/prioritizeMemory.js

@@ -0,0 +1,109 @@
+// Memory management tool - completely independent
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const prioritizeMemoryDefinition = {
+    name: 'prioritize_memory',
+    description: '중요한 거|우선순위|prioritize|important|what matters|priority - Prioritize memories by importance',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            currentTask: { type: 'string', description: 'Current task description' },
+            criticalDecisions: { type: 'array', items: { type: 'string' }, description: 'List of critical decisions made' },
+            codeChanges: { type: 'array', items: { type: 'string' }, description: 'Important code changes' },
+            blockers: { type: 'array', items: { type: 'string' }, description: 'Current blockers or issues' },
+            nextSteps: { type: 'array', items: { type: 'string' }, description: 'Planned next steps' }
+        },
+        required: ['currentTask']
+    },
+    annotations: {
+        title: 'Prioritize Memory',
+        audience: ['user', 'assistant']
+    }
+};
+export async function prioritizeMemory(args) {
+    const { currentTask, criticalDecisions = [], codeChanges = [], blockers = [], nextSteps = [] } = args;
+    try {
+        const mm = MemoryManager.getInstance();
+        const allMemories = mm.list();
+        const prioritizedMemories = [];
+        for (const memory of allMemories) {
+            let priority = 0;
+            let reason = '';
+            // Analyze importance based on content
+            if (memory.value.includes('error') || memory.value.includes('Error')) {
+                priority = 0.9;
+                reason = 'error info';
+            }
+            else if (memory.value.includes('decision') || memory.value.includes('Decision')) {
+                priority = 0.8;
+                reason = 'decision';
+            }
+            else if (memory.value.includes('code') || memory.value.includes('function')) {
+                priority = 0.7;
+                reason = 'code-related';
+            }
+            else if (memory.category === 'context') {
+                priority = 0.6;
+                reason = 'context';
+            }
+            else if (memory.category === 'project') {
+                priority = 0.7;
+                reason = 'project';
+            }
+            else {
+                priority = 0.5;
+                reason = 'general';
+            }
+            // Boost priority for memories related to current task
+            if (memory.value.toLowerCase().includes(currentTask.toLowerCase())) {
+                priority += 0.2;
+                reason += ' +task';
+            }
+            // Boost priority for critical decisions
+            for (const decision of criticalDecisions) {
+                if (memory.value.toLowerCase().includes(decision.toLowerCase())) {
+                    priority += 0.15;
+                    reason += ' +critical';
+                    break;
+                }
+            }
+            // Boost priority for code changes
+            for (const change of codeChanges) {
+                if (memory.value.toLowerCase().includes(change.toLowerCase())) {
+                    priority += 0.1;
+                    reason += ' +change';
+                    break;
+                }
+            }
+            // Boost priority for blockers
+            for (const blocker of blockers) {
+                if (memory.value.toLowerCase().includes(blocker.toLowerCase())) {
+                    priority += 0.25;
+                    reason += ' +blocker';
+                    break;
+                }
+            }
+            // Cap priority at 1.0
+            priority = Math.min(1.0, priority);
+            if (priority >= 0.6) {
+                prioritizedMemories.push({ memory, priority, reason });
+                // Update priority in database
+                mm.setPriority(memory.key, Math.floor(priority * 100));
+            }
+        }
+        const sortedMemories = prioritizedMemories
+            .sort((a, b) => b.priority - a.priority)
+            .slice(0, 20);
+        const resultList = sortedMemories.map(pm => `• [${(pm.priority * 100).toFixed(0)}%] ${pm.memory.key} (${pm.reason}): ${pm.memory.value.substring(0, 60)}${pm.memory.value.length > 60 ? '...' : ''}`).join('\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✓ Prioritized ${sortedMemories.length} memories for "${currentTask}":\n${resultList || 'None'}`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}

package/mcp/dist/tools/memory/recallMemory.js

@@ -0,0 +1,40 @@
+// Memory management tool - SQLite based (v1.3)
+import { MemoryManager } from '../../lib/MemoryManager.js';
+export const recallMemoryDefinition = {
+    name: 'recall_memory',
+    description: '떠올려|recall|기억나|remember what|what was|remind - Retrieve from memory',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'Memory key to retrieve' },
+            category: { type: 'string', description: 'Memory category to search in' }
+        },
+        required: ['key']
+    },
+    annotations: {
+        title: 'Recall Memory',
+        audience: ['user', 'assistant']
+    }
+};
+export async function recallMemory(args) {
+    const { key: recallKey } = args;
+    try {
+        const memoryManager = MemoryManager.getInstance();
+        const memory = memoryManager.recall(recallKey);
+        if (memory) {
+            return {
+                content: [{ type: 'text', text: `${memory.key}: ${memory.value}\n[${memory.category}]` }]
+            };
+        }
+        else {
+            return {
+                content: [{ type: 'text', text: `✗ Not found: "${recallKey}"` }]
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
+        };
+    }
+}