@su-record/vibe 0.1.2 → 0.1.4

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

@@ -1,38 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-// 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

@@ -1,138 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-// 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

@@ -1,113 +0,0 @@
-#!/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

@@ -1,109 +0,0 @@
-// 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

@@ -1,40 +0,0 @@
-// 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'}` }]
-        };
-    }
-}

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

@@ -1,69 +0,0 @@
-// Memory management tool - SQLite based (v1.3)
-import { MemoryManager } from '../../lib/MemoryManager.js';
-export const restoreSessionContextDefinition = {
-    name: 'restore_session_context',
-    description: 'restore|revert|go back|복원|되돌려 - Restore previous session context',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sessionId: { type: 'string', description: 'Session ID to restore' },
-            restoreLevel: { type: 'string', description: 'Level of detail to restore', enum: ['essential', 'detailed', 'complete'] },
-            filterType: { type: 'string', description: 'Filter context by type', enum: ['all', 'progress', 'decisions', 'code-snippets', 'debugging', 'planning'] }
-        },
-        required: ['sessionId']
-    },
-    annotations: {
-        title: 'Restore Session',
-        audience: ['user', 'assistant']
-    }
-};
-export async function restoreSessionContext(args) {
-    const { sessionId, restoreLevel = 'detailed', filterType = 'all' } = args;
-    try {
-        const memoryManager = MemoryManager.getInstance();
-        // Get all context memories
-        let memories = memoryManager.list('context');
-        // Filter by session ID
-        memories = memories.filter(m => m.key.includes(sessionId));
-        // Filter by context type if not 'all'
-        if (filterType !== 'all') {
-            memories = memories.filter(m => {
-                try {
-                    const contextData = JSON.parse(m.value);
-                    return contextData.contextType === filterType;
-                }
-                catch {
-                    return false;
-                }
-            });
-        }
-        const maxItems = restoreLevel === 'essential' ? 3 : restoreLevel === 'detailed' ? 10 : 20;
-        const limitedMemories = memories.slice(0, maxItems);
-        if (limitedMemories.length === 0) {
-            return {
-                content: [{ type: 'text', text: `✗ No context found for session: ${sessionId}` }]
-            };
-        }
-        let response = `✓ Restored ${limitedMemories.length} context item(s) for session: ${sessionId}\n`;
-        limitedMemories.forEach(m => {
-            try {
-                const data = JSON.parse(m.value);
-                response += `\n• ${data.contextType || 'context'} (${data.urgency || 'medium'})`;
-                if (data.summary)
-                    response += `: ${data.summary}`;
-                response += `\n  Time: ${new Date(m.timestamp).toLocaleString()}`;
-            }
-            catch {
-                response += `\n• ${m.key}\n  Time: ${new Date(m.timestamp).toLocaleString()}`;
-            }
-        });
-        return {
-            content: [{ type: 'text', text: response }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}

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

@@ -1,34 +0,0 @@
-// Memory management tool - SQLite based (v1.3)
-import { MemoryManager } from '../../lib/MemoryManager.js';
-export const saveMemoryDefinition = {
-    name: 'save_memory',
-    description: '기억해|remember|저장해|save|memorize|keep - Save to long-term memory',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            key: { type: 'string', description: 'Memory key/identifier' },
-            value: { type: 'string', description: 'Information to save' },
-            category: { type: 'string', description: 'Memory category', enum: ['project', 'personal', 'code', 'notes'] }
-        },
-        required: ['key', 'value']
-    },
-    annotations: {
-        title: 'Save Memory',
-        audience: ['user', 'assistant']
-    }
-};
-export async function saveMemory(args) {
-    const { key: memoryKey, value: memoryValue, category = 'general' } = args;
-    try {
-        const memoryManager = MemoryManager.getInstance();
-        memoryManager.save(memoryKey, memoryValue, category);
-        return {
-            content: [{ type: 'text', text: `✓ Saved: ${memoryKey}\nCategory: ${category}` }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}

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

@@ -1,37 +0,0 @@
-// Memory management tool - completely independent
-import { MemoryManager } from '../../lib/MemoryManager.js';
-export const searchMemoriesDefinition = {
-    name: 'search_memories',
-    description: '찾아|검색|기억 중에|search|find|look for - Search memories by content',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            query: { type: 'string', description: 'Search query' },
-            category: { type: 'string', description: 'Category to search in' }
-        },
-        required: ['query']
-    },
-    annotations: {
-        title: 'Search Memories',
-        audience: ['user', 'assistant']
-    }
-};
-export async function searchMemoriesHandler(args) {
-    const { query, category: searchCategory } = args;
-    try {
-        const mm = MemoryManager.getInstance();
-        const results = mm.search(query);
-        const resultList = results.map(m => `• ${m.key} (${m.category}): ${m.value.substring(0, 100)}${m.value.length > 100 ? '...' : ''}`).join('\n');
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✓ Found ${results.length} matches for "${query}":\n${resultList || 'None'}`
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}` }]
-        };
-    }
-}