@soulcraft/brainy 3.19.0 → 3.20.0

package/dist/cli/commands/vfs.js

@@ -0,0 +1,372 @@
+/**
+ * VFS CLI Commands - Virtual File System Operations
+ *
+ * Complete filesystem-like interface for Brainy's VFS
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { Brainy } from '../../brainy.js';
+let brainyInstance = null;
+const getBrainy = () => {
+    if (!brainyInstance) {
+        brainyInstance = new Brainy();
+    }
+    return brainyInstance;
+};
+const formatOutput = (data, options) => {
+    if (options.json) {
+        console.log(options.pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data));
+    }
+};
+const formatBytes = (bytes) => {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+const formatDate = (date) => {
+    return date.toLocaleString();
+};
+export const vfsCommands = {
+    /**
+     * Read file from VFS
+     */
+    async read(path, options) {
+        const spinner = ora('Reading file...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const buffer = await vfs.readFile(path, {
+                encoding: options.encoding
+            });
+            spinner.succeed('File read successfully');
+            if (options.output) {
+                // Write to local filesystem
+                writeFileSync(options.output, buffer);
+                console.log(chalk.green(`✓ Saved to: ${options.output}`));
+            }
+            else if (!options.json) {
+                // Display content
+                console.log('\n' + buffer.toString());
+            }
+            else {
+                formatOutput({ path, content: buffer.toString(), size: buffer.length }, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to read file');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * Write file to VFS
+     */
+    async write(path, options) {
+        const spinner = ora('Writing file...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            let data;
+            if (options.file) {
+                // Read from local file
+                data = readFileSync(options.file, 'utf-8');
+            }
+            else if (options.content) {
+                data = options.content;
+            }
+            else {
+                spinner.fail('Must provide --content or --file');
+                process.exit(1);
+            }
+            await vfs.writeFile(path, data, {
+                encoding: options.encoding
+            });
+            spinner.succeed('File written successfully');
+            if (!options.json) {
+                console.log(chalk.green(`✓ Written to: ${path}`));
+                console.log(chalk.dim(`  Size: ${formatBytes(Buffer.byteLength(data))}`));
+            }
+            else {
+                formatOutput({ path, size: Buffer.byteLength(data) }, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to write file');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * List directory contents
+     */
+    async ls(path, options) {
+        const spinner = ora('Listing directory...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const entries = await vfs.readdir(path, { withFileTypes: true });
+            spinner.succeed(`Found ${Array.isArray(entries) ? entries.length : 0} items`);
+            if (!options.json) {
+                if (!Array.isArray(entries) || entries.length === 0) {
+                    console.log(chalk.yellow('Directory is empty'));
+                    return;
+                }
+                if (options.long) {
+                    // Long format with details
+                    const table = new Table({
+                        head: [chalk.cyan('Type'), chalk.cyan('Size'), chalk.cyan('Modified'), chalk.cyan('Name')],
+                        style: { head: [], border: [] }
+                    });
+                    for (const entry of entries) {
+                        if (!options.all && entry.name.startsWith('.'))
+                            continue;
+                        const stat = await vfs.stat(`${path}/${entry.name}`);
+                        table.push([
+                            entry.isDirectory() ? chalk.blue('DIR') : 'FILE',
+                            entry.isDirectory() ? '-' : formatBytes(stat.size),
+                            formatDate(stat.mtime),
+                            entry.name
+                        ]);
+                    }
+                    console.log('\n' + table.toString());
+                }
+                else {
+                    // Simple format
+                    console.log();
+                    for (const entry of entries) {
+                        if (!options.all && entry.name.startsWith('.'))
+                            continue;
+                        if (entry.isDirectory()) {
+                            console.log(chalk.blue(entry.name + '/'));
+                        }
+                        else {
+                            console.log(entry.name);
+                        }
+                    }
+                }
+            }
+            else {
+                formatOutput(entries, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to list directory');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * Get file/directory stats
+     */
+    async stat(path, options) {
+        const spinner = ora('Getting file stats...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const stats = await vfs.stat(path);
+            spinner.succeed('Stats retrieved');
+            if (!options.json) {
+                console.log(chalk.cyan('\nFile Statistics:'));
+                console.log(`  Path: ${path}`);
+                console.log(`  Type: ${stats.isDirectory() ? chalk.blue('Directory') : 'File'}`);
+                console.log(`  Size: ${formatBytes(stats.size)}`);
+                console.log(`  Created: ${formatDate(stats.birthtime)}`);
+                console.log(`  Modified: ${formatDate(stats.mtime)}`);
+                console.log(`  Accessed: ${formatDate(stats.atime)}`);
+            }
+            else {
+                formatOutput(stats, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to get stats');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * Create directory
+     */
+    async mkdir(path, options) {
+        const spinner = ora('Creating directory...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            await vfs.mkdir(path, { recursive: options.parents });
+            spinner.succeed('Directory created');
+            if (!options.json) {
+                console.log(chalk.green(`✓ Created: ${path}`));
+            }
+            else {
+                formatOutput({ path, created: true }, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to create directory');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * Remove file or directory
+     */
+    async rm(path, options) {
+        const spinner = ora('Removing...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const stats = await vfs.stat(path);
+            if (stats.isDirectory()) {
+                await vfs.rmdir(path, { recursive: options.recursive });
+            }
+            else {
+                await vfs.unlink(path);
+            }
+            spinner.succeed('Removed successfully');
+            if (!options.json) {
+                console.log(chalk.green(`✓ Removed: ${path}`));
+            }
+            else {
+                formatOutput({ path, removed: true }, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to remove');
+            console.error(chalk.red(error.message));
+            if (!options.force) {
+                process.exit(1);
+            }
+        }
+    },
+    /**
+     * Search files by content
+     */
+    async search(query, options) {
+        const spinner = ora('Searching files...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const results = await vfs.search(query, {
+                path: options.path,
+                limit: options.limit ? parseInt(options.limit) : 10
+            });
+            spinner.succeed(`Found ${results.length} results`);
+            if (!options.json) {
+                if (results.length === 0) {
+                    console.log(chalk.yellow('No results found'));
+                }
+                else {
+                    console.log(chalk.cyan('\n📄 Search Results:\n'));
+                    results.forEach((result, i) => {
+                        console.log(chalk.bold(`${i + 1}. ${result.path}`));
+                        if (result.score) {
+                            console.log(chalk.dim(`   Score: ${(result.score * 100).toFixed(1)}%`));
+                        }
+                        if (result.excerpt) {
+                            console.log(chalk.dim(`   ${result.excerpt}`));
+                        }
+                        console.log();
+                    });
+                }
+            }
+            else {
+                formatOutput(results, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Search failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * Find similar files
+     */
+    async similar(path, options) {
+        const spinner = ora('Finding similar files...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const results = await vfs.findSimilar(path, {
+                limit: options.limit ? parseInt(options.limit) : 10,
+                threshold: options.threshold ? parseFloat(options.threshold) : 0.7
+            });
+            spinner.succeed(`Found ${results.length} similar files`);
+            if (!options.json) {
+                if (results.length === 0) {
+                    console.log(chalk.yellow('No similar files found'));
+                }
+                else {
+                    console.log(chalk.cyan('\n🔗 Similar Files:\n'));
+                    results.forEach((result, i) => {
+                        console.log(chalk.bold(`${i + 1}. ${result.path}`));
+                        if (result.score) {
+                            console.log(chalk.green(`   Similarity: ${(result.score * 100).toFixed(1)}%`));
+                        }
+                        console.log();
+                    });
+                }
+            }
+            else {
+                formatOutput(results, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to find similar files');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    },
+    /**
+     * Get directory tree structure
+     */
+    async tree(path, options) {
+        const spinner = ora('Building tree...').start();
+        try {
+            const brain = getBrainy();
+            const vfs = brain.vfs();
+            await vfs.init();
+            const tree = await vfs.getTreeStructure(path, {
+                maxDepth: options.depth ? parseInt(options.depth) : 3
+            });
+            spinner.succeed('Tree built');
+            if (!options.json) {
+                console.log(chalk.cyan(`\n📁 ${path}\n`));
+                displayTree(tree, '', true);
+            }
+            else {
+                formatOutput(tree, options);
+            }
+        }
+        catch (error) {
+            spinner.fail('Failed to build tree');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    }
+};
+function displayTree(node, prefix, isLast) {
+    const connector = isLast ? '└── ' : '├── ';
+    const name = node.isDirectory ? chalk.blue(node.name + '/') : node.name;
+    console.log(prefix + connector + name);
+    if (node.children && node.children.length > 0) {
+        const childPrefix = prefix + (isLast ? '    ' : '│   ');
+        node.children.forEach((child, i) => {
+            displayTree(child, childPrefix, i === node.children.length - 1);
+        });
+    }
+}
+//# sourceMappingURL=vfs.js.map

package/dist/cli/index.js

@@ -9,7 +9,15 @@ import chalk from 'chalk';
 import { neuralCommands } from './commands/neural.js';
 import { coreCommands } from './commands/core.js';
 import { utilityCommands } from './commands/utility.js';
-import { version } from '../package.json';
+import { vfsCommands } from './commands/vfs.js';
+import { dataCommands } from './commands/data.js';
+import conversationCommand from './commands/conversation.js';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
+const version = packageJson.version;
 // CLI Configuration
 const program = new Command();
 program
@@ -28,12 +36,29 @@ program
     .option('-m, --metadata <json>', 'Add metadata')
     .option('-t, --type <type>', 'Specify noun type')
     .action(coreCommands.add);
+program
+    .command('find <query>')
+    .description('Simple NLP search (just like code: brain.find("query"))')
+    .option('-k, --limit <number>', 'Number of results', '10')
+    .action(coreCommands.search);
 program
     .command('search <query>')
-    .description('Search the neural database')
+    .description('Advanced search with Triple Intelligence™ (vector + graph + field)')
     .option('-k, --limit <number>', 'Number of results', '10')
-    .option('-t, --threshold <number>', 'Similarity threshold')
-    .option('--metadata <json>', 'Filter by metadata')
+    .option('--offset <number>', 'Skip N results (pagination)')
+    .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.7')
+    .option('--type <types>', 'Filter by type(s) - comma separated')
+    .option('--where <json>', 'Metadata filters (JSON)')
+    .option('--near <id>', 'Find items near this ID')
+    .option('--connected-to <id>', 'Connected to this entity')
+    .option('--connected-from <id>', 'Connected from this entity')
+    .option('--via <verbs>', 'Via these relationships - comma separated')
+    .option('--explain', 'Show scoring breakdown')
+    .option('--include-relations', 'Include entity relationships')
+    .option('--fusion <strategy>', 'Fusion strategy (adaptive|weighted|progressive)')
+    .option('--vector-weight <n>', 'Vector search weight (0-1)')
+    .option('--graph-weight <n>', 'Graph search weight (0-1)')
+    .option('--field-weight <n>', 'Field search weight (0-1)')
     .action(coreCommands.search);
 program
     .command('get <id>')
@@ -95,10 +120,14 @@ program
     .action(neuralCommands.hierarchy);
 program
     .command('path <from> <to>')
-    .description('Find semantic path between items')
+    .description('Find semantic path between items (v3.21.0)')
     .option('--steps', 'Show step-by-step path')
     .option('--max-hops <number>', 'Maximum path length', '5')
-    .action(neuralCommands.path);
+    .action(() => {
+    console.log(chalk.yellow('\n⚠️  Semantic path finding coming in v3.21.0'));
+    console.log(chalk.dim('This feature requires implementing graph traversal algorithms'));
+    console.log(chalk.dim('Use "brainy neighbors" and "brainy hierarchy" to explore connections'));
+});
 program
     .command('outliers')
     .alias('anomalies')
@@ -115,11 +144,219 @@ program
     .option('--dimensions <number>', '2D or 3D', '2')
     .option('-o, --output <file>', 'Output file')
     .action(neuralCommands.visualize);
+// ===== Conversation Commands (Infinite Memory) =====
+program
+    .command('conversation')
+    .alias('conv')
+    .description('💬 Infinite agent memory and context management')
+    .addCommand(new Command('setup')
+    .description('Set up MCP server for Claude Code integration')
+    .action(async () => {
+    await conversationCommand.handler({ action: 'setup', _: [] });
+}))
+    .addCommand(new Command('search')
+    .description('Search messages across conversations')
+    .requiredOption('-q, --query <query>', 'Search query')
+    .option('-c, --conversation-id <id>', 'Filter by conversation')
+    .option('-r, --role <role>', 'Filter by role')
+    .option('-l, --limit <number>', 'Maximum results', '10')
+    .action(async (options) => {
+    await conversationCommand.handler({ action: 'search', ...options, _: [] });
+}))
+    .addCommand(new Command('context')
+    .description('Get relevant context for a query')
+    .requiredOption('-q, --query <query>', 'Context query')
+    .option('-l, --limit <number>', 'Maximum messages', '10')
+    .action(async (options) => {
+    await conversationCommand.handler({ action: 'context', ...options, _: [] });
+}))
+    .addCommand(new Command('thread')
+    .description('Get full conversation thread')
+    .requiredOption('-c, --conversation-id <id>', 'Conversation ID')
+    .action(async (options) => {
+    await conversationCommand.handler({ action: 'thread', ...options, _: [] });
+}))
+    .addCommand(new Command('stats')
+    .description('Show conversation statistics')
+    .action(async () => {
+    await conversationCommand.handler({ action: 'stats', _: [] });
+}));
+// ===== VFS Commands (Subcommand Group) =====
+program
+    .command('vfs')
+    .description('📁 Virtual File System operations')
+    .addCommand(new Command('read')
+    .argument('<path>', 'File path')
+    .description('Read file from VFS')
+    .option('-o, --output <file>', 'Save to local file')
+    .option('--encoding <encoding>', 'File encoding', 'utf-8')
+    .action((path, options) => {
+    vfsCommands.read(path, options);
+}))
+    .addCommand(new Command('write')
+    .argument('<path>', 'File path')
+    .description('Write file to VFS')
+    .option('-c, --content <content>', 'File content')
+    .option('-f, --file <file>', 'Read from local file')
+    .option('--encoding <encoding>', 'File encoding', 'utf-8')
+    .action((path, options) => {
+    vfsCommands.write(path, options);
+}))
+    .addCommand(new Command('ls')
+    .alias('list')
+    .argument('<path>', 'Directory path')
+    .description('List directory contents')
+    .option('-l, --long', 'Long format with details')
+    .option('-a, --all', 'Show hidden files')
+    .action((path, options) => {
+    vfsCommands.ls(path, options);
+}))
+    .addCommand(new Command('stat')
+    .argument('<path>', 'File/directory path')
+    .description('Get file/directory statistics')
+    .action((path, options) => {
+    vfsCommands.stat(path, options);
+}))
+    .addCommand(new Command('mkdir')
+    .argument('<path>', 'Directory path')
+    .description('Create directory')
+    .option('-p, --parents', 'Create parent directories')
+    .action((path, options) => {
+    vfsCommands.mkdir(path, options);
+}))
+    .addCommand(new Command('rm')
+    .argument('<path>', 'File/directory path')
+    .description('Remove file or directory')
+    .option('-r, --recursive', 'Remove recursively')
+    .option('-f, --force', 'Force removal')
+    .action((path, options) => {
+    vfsCommands.rm(path, options);
+}))
+    .addCommand(new Command('search')
+    .argument('<query>', 'Search query')
+    .description('Search files by content')
+    .option('--path <path>', 'Search within path')
+    .option('-l, --limit <number>', 'Max results', '10')
+    .option('--type <type>', 'File type filter')
+    .action((query, options) => {
+    vfsCommands.search(query, options);
+}))
+    .addCommand(new Command('similar')
+    .argument('<path>', 'File path')
+    .description('Find similar files')
+    .option('-l, --limit <number>', 'Max results', '10')
+    .option('-t, --threshold <number>', 'Similarity threshold', '0.7')
+    .action((path, options) => {
+    vfsCommands.similar(path, options);
+}))
+    .addCommand(new Command('tree')
+    .argument('<path>', 'Directory path')
+    .description('Show directory tree')
+    .option('-d, --depth <number>', 'Max depth', '3')
+    .action((path, options) => {
+    vfsCommands.tree(path, options);
+}));
+// ===== VFS Commands (Backward Compatibility - Deprecated) =====
+program
+    .command('vfs-read <path>')
+    .description('[DEPRECATED] Use: brainy vfs read <path>')
+    .option('-o, --output <file>', 'Save to local file')
+    .option('--encoding <encoding>', 'File encoding', 'utf-8')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-read" is deprecated. Use: brainy vfs read'));
+    vfsCommands.read(path, options);
+});
+program
+    .command('vfs-write <path>')
+    .description('[DEPRECATED] Use: brainy vfs write <path>')
+    .option('-c, --content <content>', 'File content')
+    .option('-f, --file <file>', 'Read from local file')
+    .option('--encoding <encoding>', 'File encoding', 'utf-8')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-write" is deprecated. Use: brainy vfs write'));
+    vfsCommands.write(path, options);
+});
+program
+    .command('vfs-ls <path>')
+    .alias('vfs-list')
+    .description('[DEPRECATED] Use: brainy vfs ls <path>')
+    .option('-l, --long', 'Long format with details')
+    .option('-a, --all', 'Show hidden files')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-ls" is deprecated. Use: brainy vfs ls'));
+    vfsCommands.ls(path, options);
+});
+program
+    .command('vfs-stat <path>')
+    .description('[DEPRECATED] Use: brainy vfs stat <path>')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-stat" is deprecated. Use: brainy vfs stat'));
+    vfsCommands.stat(path, options);
+});
+program
+    .command('vfs-mkdir <path>')
+    .description('[DEPRECATED] Use: brainy vfs mkdir <path>')
+    .option('-p, --parents', 'Create parent directories')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-mkdir" is deprecated. Use: brainy vfs mkdir'));
+    vfsCommands.mkdir(path, options);
+});
+program
+    .command('vfs-rm <path>')
+    .description('[DEPRECATED] Use: brainy vfs rm <path>')
+    .option('-r, --recursive', 'Remove recursively')
+    .option('-f, --force', 'Force removal')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-rm" is deprecated. Use: brainy vfs rm'));
+    vfsCommands.rm(path, options);
+});
+program
+    .command('vfs-search <query>')
+    .description('[DEPRECATED] Use: brainy vfs search <query>')
+    .option('--path <path>', 'Search within path')
+    .option('-l, --limit <number>', 'Max results', '10')
+    .option('--type <type>', 'File type filter')
+    .action((query, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-search" is deprecated. Use: brainy vfs search'));
+    vfsCommands.search(query, options);
+});
+program
+    .command('vfs-similar <path>')
+    .description('[DEPRECATED] Use: brainy vfs similar <path>')
+    .option('-l, --limit <number>', 'Max results', '10')
+    .option('-t, --threshold <number>', 'Similarity threshold', '0.7')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-similar" is deprecated. Use: brainy vfs similar'));
+    vfsCommands.similar(path, options);
+});
+program
+    .command('vfs-tree <path>')
+    .description('[DEPRECATED] Use: brainy vfs tree <path>')
+    .option('-d, --depth <number>', 'Max depth', '3')
+    .action((path, options) => {
+    console.log(chalk.yellow('⚠️  Command "vfs-tree" is deprecated. Use: brainy vfs tree'));
+    vfsCommands.tree(path, options);
+});
+// ===== Data Management Commands =====
+program
+    .command('backup <file>')
+    .description('Create database backup')
+    .option('--compress', 'Compress backup')
+    .action(dataCommands.backup);
+program
+    .command('restore <file>')
+    .description('Restore from backup')
+    .option('--merge', 'Merge with existing data (default: replace)')
+    .action(dataCommands.restore);
+program
+    .command('data-stats')
+    .description('Show detailed database statistics')
+    .action(dataCommands.stats);
 // ===== Utility Commands =====
 program
     .command('stats')
     .alias('statistics')
-    .description('Show database statistics')
+    .description('Show quick database statistics')
     .option('--by-service', 'Group by service')
     .option('--detailed', 'Show detailed stats')
     .action(utilityCommands.stats);