@soulcraft/brainy 3.19.0 → 3.20.0

package/dist/cli/commands/types.js

@@ -0,0 +1,194 @@
+/**
+ * CLI Commands for Type Management
+ * Consistent with BrainyTypes public API
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { BrainyTypes } from '../../index.js';
+/**
+ * List types - matches BrainyTypes.nouns and BrainyTypes.verbs
+ * Usage: brainy types
+ */
+export async function types(options) {
+    try {
+        // Default to showing both if neither flag specified
+        const showNouns = options.noun || (!options.noun && !options.verb);
+        const showVerbs = options.verb || (!options.noun && !options.verb);
+        const result = {};
+        if (showNouns)
+            result.nouns = BrainyTypes.nouns;
+        if (showVerbs)
+            result.verbs = BrainyTypes.verbs;
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        // Display nouns
+        if (showNouns) {
+            console.log(chalk.bold.cyan('\n📚 Noun Types (31):\n'));
+            const nounChunks = [];
+            for (let i = 0; i < BrainyTypes.nouns.length; i += 3) {
+                nounChunks.push(BrainyTypes.nouns.slice(i, i + 3));
+            }
+            for (const chunk of nounChunks) {
+                console.log('  ' + chunk.map(n => chalk.green(n.padEnd(20))).join(''));
+            }
+        }
+        // Display verbs
+        if (showVerbs) {
+            console.log(chalk.bold.cyan('\n🔗 Verb Types (40):\n'));
+            const verbChunks = [];
+            for (let i = 0; i < BrainyTypes.verbs.length; i += 3) {
+                verbChunks.push(BrainyTypes.verbs.slice(i, i + 3));
+            }
+            for (const chunk of verbChunks) {
+                console.log('  ' + chunk.map(v => chalk.blue(v.padEnd(20))).join(''));
+            }
+        }
+        console.log(chalk.dim('\n💡 Use "brainy suggest <data>" to get AI-powered type suggestions'));
+    }
+    catch (error) {
+        console.error(chalk.red('Error:', error.message));
+        process.exit(1);
+    }
+}
+/**
+ * Suggest type - matches BrainyTypes.suggestNoun() and suggestVerb()
+ * Usage: brainy suggest <data>
+ * Interactive if data not provided
+ */
+export async function suggest(data, options = {}) {
+    try {
+        // Interactive mode if no data provided
+        if (!data) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'kind',
+                    message: 'What type do you want to suggest?',
+                    choices: ['Noun', 'Verb'],
+                    default: 'Noun'
+                },
+                {
+                    type: 'input',
+                    name: 'data',
+                    message: 'Enter data (JSON or text):',
+                    validate: (input) => input.length > 0 || 'Data is required'
+                },
+                {
+                    type: 'input',
+                    name: 'hint',
+                    message: 'Relationship hint (optional):',
+                    when: (answers) => answers.kind === 'Verb'
+                }
+            ]);
+            data = answers.data;
+            options.verb = answers.kind === 'Verb';
+            // For verbs, parse source/target if provided as JSON
+            if (options.verb && answers.hint) {
+                data = JSON.stringify({ hint: answers.hint });
+            }
+        }
+        const spinner = ora('Analyzing with AI...').start();
+        let parsedData;
+        try {
+            parsedData = JSON.parse(data);
+        }
+        catch {
+            parsedData = { content: data };
+        }
+        let suggestion;
+        if (options.verb) {
+            // For verb suggestions, need source and target
+            const source = parsedData.source || { type: 'unknown' };
+            const target = parsedData.target || { type: 'unknown' };
+            const hint = parsedData.hint || parsedData.relationship || parsedData.verb;
+            suggestion = await BrainyTypes.suggestVerb(source, target, hint);
+            spinner.succeed('Verb type analyzed');
+        }
+        else {
+            suggestion = await BrainyTypes.suggestNoun(parsedData);
+            spinner.succeed('Noun type analyzed');
+        }
+        if (options.json) {
+            console.log(JSON.stringify(suggestion, null, 2));
+            return;
+        }
+        // Display results
+        console.log(chalk.bold.green(`\n✨ Suggested: ${suggestion.type}`));
+        console.log(chalk.cyan(`Confidence: ${(suggestion.confidence * 100).toFixed(1)}%`));
+        if (suggestion.alternatives && suggestion.alternatives.length > 0) {
+            console.log(chalk.yellow('\nAlternatives:'));
+            for (const alt of suggestion.alternatives.slice(0, 3)) {
+                console.log(`  ${alt.type} (${(alt.confidence * 100).toFixed(1)}%)`);
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:', error.message));
+        process.exit(1);
+    }
+}
+/**
+ * Validate type - matches BrainyTypes.isValidNoun() and isValidVerb()
+ * Usage: brainy validate <type>
+ */
+export async function validate(type, options = {}) {
+    try {
+        // Interactive mode if no type provided
+        if (!type) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'kind',
+                    message: 'Validate as:',
+                    choices: ['Noun Type', 'Verb Type'],
+                    default: 'Noun Type'
+                },
+                {
+                    type: 'input',
+                    name: 'type',
+                    message: 'Enter type to validate:',
+                    validate: (input) => input.length > 0 || 'Type is required'
+                }
+            ]);
+            type = answers.type;
+            options.verb = answers.kind === 'Verb Type';
+        }
+        const isValid = options.verb
+            ? BrainyTypes.isValidVerb(type)
+            : BrainyTypes.isValidNoun(type);
+        if (options.json) {
+            console.log(JSON.stringify({
+                type,
+                kind: options.verb ? 'verb' : 'noun',
+                valid: isValid
+            }, null, 2));
+            return;
+        }
+        if (isValid) {
+            console.log(chalk.green(`✅ "${type}" is valid`));
+        }
+        else {
+            console.log(chalk.red(`❌ "${type}" is invalid`));
+            // Show valid options
+            const validTypes = options.verb ? BrainyTypes.verbs : BrainyTypes.nouns;
+            const similar = validTypes.filter(t => t.toLowerCase().includes(type.toLowerCase()) ||
+                type.toLowerCase().includes(t.toLowerCase())).slice(0, 5);
+            if (similar.length > 0) {
+                console.log(chalk.yellow('\nDid you mean:'));
+                similar.forEach(s => console.log(`  ${s}`));
+            }
+            else {
+                console.log(chalk.dim(`\nRun "brainy types" to see all valid types`));
+            }
+        }
+        process.exit(isValid ? 0 : 1);
+    }
+    catch (error) {
+        console.error(chalk.red('Error:', error.message));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=types.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 { BrainyData } 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 BrainyData();
-        await brainyInstance.init();
+        brainyInstance = new Brainy();
     }
     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

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