@soulcraft/brainy 3.19.1 → 3.20.1

package/dist/cli/commands/neural.js

@@ -8,8 +8,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import fs from 'node:fs';
 import path from 'node:path';
-import { Brainy } from '../../brainyData.js';
-import { NeuralAPI } from '../../neural/neuralAPI.js';
+import { Brainy } from '../../brainy.js';
 export const neuralCommand = {
     command: 'neural [action]',
     describe: '🧠 Neural similarity and clustering operations',
@@ -80,7 +79,7 @@ export const neuralCommand = {
         console.log(chalk.gray('━'.repeat(50)));
         // Initialize Brainy and Neural API
         const brain = new Brainy();
-        const neural = new NeuralAPI(brain);
+        const neural = brain.neural();
         try {
             const action = argv.action || await promptForAction();
             switch (action) {
@@ -97,7 +96,9 @@ export const neuralCommand = {
                     await handleNeighborsCommand(neural, argv);
                     break;
                 case 'path':
-                    await handlePathCommand(neural, argv);
+                    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 "neighbors" and "hierarchy" commands to explore connections'));
                     break;
                 case 'outliers':
                     await handleOutliersCommand(neural, argv);
@@ -126,7 +127,7 @@ async function promptForAction() {
                 { name: '🎯 Find semantic clusters', value: 'clusters' },
                 { name: '🌳 Show item hierarchy', value: 'hierarchy' },
                 { name: '🕸️  Find semantic neighbors', value: 'neighbors' },
-                { name: '🛣️  Find semantic path between items', value: 'path' },
+                { name: '🛣️  Find semantic path between items (v3.21.0)', value: 'path', disabled: true },
                 { name: '🚨 Detect outliers', value: 'outliers' },
                 { name: '📊 Generate visualization data', value: 'visualize' }
             ]
@@ -504,4 +505,14 @@ function showHelp() {
     console.log('  --explain, -e     Include explanations');
     console.log('');
 }
+export const neuralCommands = {
+    similar: handleSimilarCommand,
+    cluster: handleClustersCommand,
+    hierarchy: handleHierarchyCommand,
+    related: handleNeighborsCommand,
+    // path: handlePathCommand, // Coming in v3.21.0 - requires graph traversal implementation
+    outliers: handleOutliersCommand,
+    visualize: handleVisualizeCommand
+};
 export default neuralCommand;
+//# sourceMappingURL=neural.js.map

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 {};