@soulcraft/brainy 3.19.1 → 3.20.0

package/dist/cli/commands/utility.js

@@ -6,12 +6,12 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import Table from 'cli-table3';
-import { Brainy } from '../../brainyData.js';
+import { Brainy } from '../../brainy.js';
+import { NounType } from '../../types/graphTypes.js';
 let brainyInstance = null;
-const getBrainy = async () => {
+const getBrainy = () => {
     if (!brainyInstance) {
         brainyInstance = new Brainy();
-        await brainyInstance.init();
     }
     return brainyInstance;
 };
@@ -35,10 +35,16 @@ export const utilityCommands = {
     async stats(options) {
         const spinner = ora('Gathering statistics...').start();
         try {
-            const brain = await getBrainy();
-            const stats = await brain.getStatistics();
+            const brain = getBrainy();
+            const nounCount = await brain.getNounCount();
+            const verbCount = await brain.getVerbCount();
             const memUsage = process.memoryUsage();
             spinner.succeed('Statistics gathered');
+            const stats = {
+                nounCount,
+                verbCount,
+                totalItems: nounCount + verbCount
+            };
             if (options.json) {
                 formatOutput(stats, options);
                 return;
@@ -49,53 +55,8 @@ export const utilityCommands = {
                 head: [chalk.cyan('Metric'), chalk.cyan('Value')],
                 style: { head: [], border: [] }
             });
-            coreTable.push(['Total Items', chalk.green(stats.nounCount + stats.verbCount + stats.metadataCount || 0)], ['Nouns', chalk.green(stats.nounCount || 0)], ['Verbs (Relationships)', chalk.green(stats.verbCount || 0)], ['Metadata Records', chalk.green(stats.metadataCount || 0)]);
+            coreTable.push(['Total Items', chalk.green(stats.totalItems)], ['Nouns', chalk.green(stats.nounCount)], ['Verbs (Relationships)', chalk.green(stats.verbCount)]);
             console.log(coreTable.toString());
-            // Service breakdown if available
-            if (options.byService && stats.serviceBreakdown) {
-                console.log(chalk.cyan('\n🔧 Service Breakdown\n'));
-                const serviceTable = new Table({
-                    head: [chalk.cyan('Service'), chalk.cyan('Nouns'), chalk.cyan('Verbs'), chalk.cyan('Metadata')],
-                    style: { head: [], border: [] }
-                });
-                Object.entries(stats.serviceBreakdown).forEach(([service, serviceStats]) => {
-                    serviceTable.push([
-                        service,
-                        serviceStats.nounCount || 0,
-                        serviceStats.verbCount || 0,
-                        serviceStats.metadataCount || 0
-                    ]);
-                });
-                console.log(serviceTable.toString());
-            }
-            // Storage info
-            if (stats.storage) {
-                console.log(chalk.cyan('\n💾 Storage\n'));
-                const storageTable = new Table({
-                    head: [chalk.cyan('Property'), chalk.cyan('Value')],
-                    style: { head: [], border: [] }
-                });
-                storageTable.push(['Type', stats.storage.type || 'Unknown'], ['Size', stats.storage.size ? formatBytes(stats.storage.size) : 'N/A'], ['Location', stats.storage.location || 'N/A']);
-                console.log(storageTable.toString());
-            }
-            // Performance metrics
-            if (stats.performance && options.detailed) {
-                console.log(chalk.cyan('\n⚡ Performance\n'));
-                const perfTable = new Table({
-                    head: [chalk.cyan('Metric'), chalk.cyan('Value')],
-                    style: { head: [], border: [] }
-                });
-                if (stats.performance.avgQueryTime) {
-                    perfTable.push(['Avg Query Time', `${stats.performance.avgQueryTime.toFixed(2)} ms`]);
-                }
-                if (stats.performance.totalQueries) {
-                    perfTable.push(['Total Queries', stats.performance.totalQueries]);
-                }
-                if (stats.performance.cacheHitRate) {
-                    perfTable.push(['Cache Hit Rate', `${(stats.performance.cacheHitRate * 100).toFixed(1)}%`]);
-                }
-                console.log(perfTable.toString());
-            }
             // Memory usage
             console.log(chalk.cyan('\n🧠 Memory Usage\n'));
             const memTable = new Table({
@@ -104,16 +65,6 @@ export const utilityCommands = {
             });
             memTable.push(['Heap Used', formatBytes(memUsage.heapUsed)], ['Heap Total', formatBytes(memUsage.heapTotal)], ['RSS', formatBytes(memUsage.rss)], ['External', formatBytes(memUsage.external)]);
             console.log(memTable.toString());
-            // Index info
-            if (stats.index && options.detailed) {
-                console.log(chalk.cyan('\n🎯 Vector Index\n'));
-                const indexTable = new Table({
-                    head: [chalk.cyan('Property'), chalk.cyan('Value')],
-                    style: { head: [], border: [] }
-                });
-                indexTable.push(['Dimensions', stats.index.dimensions || 'N/A'], ['Indexed Vectors', stats.index.vectorCount || 0], ['Index Size', stats.index.indexSize ? formatBytes(stats.index.indexSize) : 'N/A']);
-                console.log(indexTable.toString());
-            }
         }
         catch (error) {
             spinner.fail('Failed to gather statistics');
@@ -127,40 +78,30 @@ export const utilityCommands = {
     async clean(options) {
         const spinner = ora('Cleaning database...').start();
         try {
-            const brain = await getBrainy();
-            const tasks = [];
-            if (options.removeOrphans) {
-                spinner.text = 'Removing orphaned items...';
-                tasks.push('Removed orphaned items');
-                // Implementation would go here
-                await new Promise(resolve => setTimeout(resolve, 500)); // Simulate work
-            }
-            if (options.rebuildIndex) {
-                spinner.text = 'Rebuilding search index...';
-                tasks.push('Rebuilt search index');
-                // Implementation would go here
-                await new Promise(resolve => setTimeout(resolve, 1000)); // Simulate work
-            }
-            if (tasks.length === 0) {
-                spinner.text = 'Running general cleanup...';
-                tasks.push('General cleanup completed');
-                // Run general cleanup tasks
-                await new Promise(resolve => setTimeout(resolve, 500)); // Simulate work
+            const brain = getBrainy();
+            // For now, only support full clear
+            // removeOrphans and rebuildIndex would require new Brainy APIs
+            if (options.removeOrphans || options.rebuildIndex) {
+                spinner.warn('Advanced cleanup options not yet implemented');
+                console.log(chalk.yellow('\n⚠️  Advanced cleanup features coming in v3.21.0:'));
+                console.log(chalk.dim('  • --remove-orphans: Remove disconnected items'));
+                console.log(chalk.dim('  • --rebuild-index: Rebuild vector index'));
+                console.log(chalk.dim('\nUse "brainy clean" without options to clear the database'));
+                return;
             }
-            spinner.succeed('Database cleaned');
+            // Show warning before clearing
+            console.log(chalk.yellow('\n⚠️  WARNING: This will permanently delete ALL data!'));
+            const dataApi = await brain.data();
+            // Clear all data
+            spinner.text = 'Clearing all data...';
+            await dataApi.clear({ entities: true, relations: true });
+            spinner.succeed('Database cleared');
             if (!options.json) {
-                console.log(chalk.green('\n✓ Cleanup completed:'));
-                tasks.forEach(task => {
-                    console.log(chalk.dim(`  • ${task}`));
-                });
-                // Get new stats
-                const stats = await brain.getStatistics();
-                console.log(chalk.cyan('\nDatabase Status:'));
-                console.log(`  Total items: ${stats.nounCount + stats.verbCount}`);
-                console.log(`  Index status: ${chalk.green('Healthy')}`);
+                console.log(chalk.green('\n✓ Database cleared successfully'));
+                console.log(chalk.dim('  All nouns, verbs, and metadata have been removed'));
             }
             else {
-                formatOutput({ tasks, success: true }, options);
+                formatOutput({ cleared: true, success: true }, options);
             }
         }
         catch (error) {
@@ -181,7 +122,7 @@ export const utilityCommands = {
             summary: {}
         };
         try {
-            const brain = await getBrainy();
+            const brain = getBrainy();
             // Benchmark different operations
             const benchmarks = [
                 { name: 'add', enabled: operations === 'all' || operations.includes('add') },
@@ -198,17 +139,17 @@ export const utilityCommands = {
                     const start = Date.now();
                     switch (bench.name) {
                         case 'add':
-                            await brain.add(`Test item ${i}`, { benchmark: true });
+                            await brain.add({ data: `Test item ${i}`, type: NounType.Thing, metadata: { benchmark: true } });
                             break;
                         case 'search':
-                            await brain.search('test', 10);
+                            await brain.find({ query: 'test', limit: 10 });
                             break;
                         case 'similarity':
-                            const neural = brain.neural;
+                            const neural = brain.neural();
                             await neural.similar('test1', 'test2');
                             break;
                         case 'cluster':
-                            const neuralApi = brain.neural;
+                            const neuralApi = brain.neural();
                             await neuralApi.clusters();
                             break;
                     }
@@ -232,7 +173,7 @@ export const utilityCommands = {
             const totalOps = Object.values(results.operations).reduce((sum, op) => sum + parseFloat(op.ops), 0);
             results.summary = {
                 totalOperations: Object.keys(results.operations).length,
-                averageOpsPerSec: (totalOps / Object.keys(results.operations).length).toFixed(2)
+                averageOpsPerSec: totalOps > 0 ? (totalOps / Object.keys(results.operations).length).toFixed(2) : '0'
             };
             if (!options.json) {
                 // Display results table
@@ -273,3 +214,4 @@ export const utilityCommands = {
         }
     }
 };
+//# sourceMappingURL=utility.js.map

package/dist/cli/commands/vfs.d.ts

@@ -0,0 +1,73 @@
+/**
+ * VFS CLI Commands - Virtual File System Operations
+ *
+ * Complete filesystem-like interface for Brainy's VFS
+ */
+interface VFSOptions {
+    verbose?: boolean;
+    json?: boolean;
+    pretty?: boolean;
+}
+export declare const vfsCommands: {
+    /**
+     * Read file from VFS
+     */
+    read(path: string, options: VFSOptions & {
+        output?: string;
+        encoding?: string;
+    }): Promise<void>;
+    /**
+     * Write file to VFS
+     */
+    write(path: string, options: VFSOptions & {
+        content?: string;
+        file?: string;
+        encoding?: string;
+    }): Promise<void>;
+    /**
+     * List directory contents
+     */
+    ls(path: string, options: VFSOptions & {
+        long?: boolean;
+        all?: boolean;
+    }): Promise<void>;
+    /**
+     * Get file/directory stats
+     */
+    stat(path: string, options: VFSOptions): Promise<void>;
+    /**
+     * Create directory
+     */
+    mkdir(path: string, options: VFSOptions & {
+        parents?: boolean;
+    }): Promise<void>;
+    /**
+     * Remove file or directory
+     */
+    rm(path: string, options: VFSOptions & {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Search files by content
+     */
+    search(query: string, options: VFSOptions & {
+        path?: string;
+        limit?: string;
+        type?: string;
+    }): Promise<void>;
+    /**
+     * Find similar files
+     */
+    similar(path: string, options: VFSOptions & {
+        limit?: string;
+        threshold?: string;
+    }): Promise<void>;
+    /**
+     * Get directory tree structure
+     */
+    tree(path: string, options: VFSOptions & {
+        depth?: string;
+    }): Promise<void>;
+};
+export {};

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