@soulcraft/brainy 3.19.0 → 3.19.1

package/dist/cli/commands/neural.js

@@ -6,9 +6,9 @@
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
-import fs from 'fs';
-import path from 'path';
-import { BrainyData } from '../../brainyData.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Brainy } from '../../brainyData.js';
 import { NeuralAPI } from '../../neural/neuralAPI.js';
 export const neuralCommand = {
     command: 'neural [action]',
@@ -79,7 +79,7 @@ export const neuralCommand = {
         console.log(chalk.cyan('\n🧠 NEURAL SIMILARITY API'));
         console.log(chalk.gray('━'.repeat(50)));
         // Initialize Brainy and Neural API
-        const brain = new BrainyData();
+        const brain = new Brainy();
         const neural = new NeuralAPI(brain);
         try {
             const action = argv.action || await promptForAction();
@@ -505,4 +505,3 @@ function showHelp() {
     console.log('');
 }
 export default neuralCommand;
-//# sourceMappingURL=neural.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * CLI Commands for Type Management
+ * Consistent with BrainyTypes public API
+ */
+/**
+ * List types - matches BrainyTypes.nouns and BrainyTypes.verbs
+ * Usage: brainy types
+ */
+export declare function types(options: {
+    json?: boolean;
+    noun?: boolean;
+    verb?: boolean;
+}): Promise<void>;
+/**
+ * Suggest type - matches BrainyTypes.suggestNoun() and suggestVerb()
+ * Usage: brainy suggest <data>
+ * Interactive if data not provided
+ */
+export declare function suggest(data?: string, options?: {
+    verb?: boolean;
+    json?: boolean;
+}): Promise<void>;
+/**
+ * Validate type - matches BrainyTypes.isValidNoun() and isValidVerb()
+ * Usage: brainy validate <type>
+ */
+export declare function validate(type?: string, options?: {
+    verb?: boolean;
+    json?: boolean;
+}): Promise<void>;

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,11 +6,11 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import Table from 'cli-table3';
-import { BrainyData } from '../../brainyData.js';
+import { Brainy } from '../../brainyData.js';
 let brainyInstance = null;
 const getBrainy = async () => {
     if (!brainyInstance) {
-        brainyInstance = new BrainyData();
+        brainyInstance = new Brainy();
         await brainyInstance.init();
     }
     return brainyInstance;
@@ -273,4 +273,3 @@ export const utilityCommands = {
         }
     }
 };
-//# sourceMappingURL=utility.js.map

package/dist/cli/index.js

@@ -9,7 +9,13 @@ 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 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
@@ -115,6 +121,43 @@ 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', _: [] });
+}));
 // ===== Utility Commands =====
 program
     .command('stats')
@@ -164,4 +207,3 @@ catch (error) {
 if (!process.argv.slice(2).length) {
     program.outputHelp();
 }
-//# sourceMappingURL=index.js.map

package/dist/cli/interactive.d.ts

@@ -4,7 +4,7 @@
  * Provides consistent, delightful interactive prompts for all commands
  * with smart defaults, validation, and helpful examples
  */
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 export declare const colors: {
     primary: import("chalk").ChalkInstance;
     success: import("chalk").ChalkInstance;
@@ -50,7 +50,7 @@ export declare function promptSearchQuery(previousSearches?: string[]): Promise<
 /**
  * Interactive prompt for item ID with fuzzy search
  */
-export declare function promptItemId(action: string, brain?: BrainyData, allowMultiple?: boolean): Promise<string | string[]>;
+export declare function promptItemId(action: string, brain?: Brainy, allowMultiple?: boolean): Promise<string | string[]>;
 /**
  * Confirm destructive action with preview
  */
@@ -74,7 +74,7 @@ export declare function promptFileOrUrl(action?: string): Promise<string>;
 /**
  * Interactive relationship builder
  */
-export declare function promptRelationship(brain?: BrainyData): Promise<{
+export declare function promptRelationship(brain?: Brainy): Promise<{
     source: string;
     verb: string;
     target: string;

package/dist/cli/interactive.js

@@ -8,6 +8,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import fuzzy from 'fuzzy';
 import ora from 'ora';
+import { getBrainyVersion } from '../utils/version.js';
 // Professional color scheme
 export const colors = {
     primary: chalk.hex('#3A5F4A'), // Teal (from logo)
@@ -107,7 +108,7 @@ export async function promptItemId(action, brain, allowMultiple = false) {
     let choices = [];
     if (brain) {
         try {
-            const recent = await brain.search('*', 10, {
+            const recent = await brain.search('*', { limit: 10,
                 sortBy: 'timestamp',
                 descending: true
             });
@@ -312,7 +313,7 @@ export async function promptFileOrUrl(action = 'import') {
             const data = await promptDataInput('import');
             // Save to temp file and return path
             const tmpFile = `/tmp/brainy-import-${Date.now()}.json`;
-            const { writeFileSync } = await import('fs');
+            const { writeFileSync } = await import('node:fs');
             writeFileSync(tmpFile, data);
             return tmpFile;
         default:
@@ -331,7 +332,7 @@ async function promptFilePath(action) {
             if (!input.trim()) {
                 return 'Please enter a file path';
             }
-            const { existsSync } = await import('fs');
+            const { existsSync } = await import('node:fs');
             if (action === 'import' && !existsSync(input)) {
                 return `File not found: ${input}`;
             }
@@ -489,7 +490,7 @@ export function showWelcome() {
 ║                                              ║
 ╚══════════════════════════════════════════════╝
 `));
-    console.log(colors.dim('Version 1.5.0 • Type "help" for commands'));
+    console.log(colors.dim(`Version ${getBrainyVersion()} • Type "help" for commands`));
     console.log();
 }
 /**
@@ -539,4 +540,3 @@ export default {
     showWelcome,
     promptCommand
 };
-//# sourceMappingURL=interactive.js.map

package/dist/hnsw/hnswIndexOptimized.d.ts

@@ -96,7 +96,7 @@ export declare class HNSWIndexOptimized extends HNSWIndex {
     private vectorCount;
     private memoryUpdateLock;
     private unifiedCache;
-    constructor(config: Partial<HNSWOptimizedConfig> | undefined, distanceFunction: DistanceFunction, storage?: StorageAdapter | null);
+    constructor(config: Partial<HNSWOptimizedConfig>, distanceFunction: DistanceFunction, storage?: StorageAdapter | null);
     /**
      * Thread-safe method to update memory usage
      * @param memoryDelta Change in memory usage (can be negative)

package/dist/mcp/brainyMCPBroadcast.d.ts

@@ -11,7 +11,7 @@
  * - Works both locally and with cloud deployment
  */
 import { BrainyMCPService } from './brainyMCPService.js';
-import { BrainyDataInterface } from '../types/brainyDataInterface.js';
+import { BrainyInterface } from '../types/brainyDataInterface.js';
 import { MCPServiceOptions } from '../types/mcpTypes.js';
 interface BroadcastMessage {
     id: string;
@@ -28,7 +28,7 @@ export declare class BrainyMCPBroadcast extends BrainyMCPService {
     private agents;
     private messageHistory;
     private maxHistorySize;
-    constructor(brainyData: BrainyDataInterface, options?: MCPServiceOptions & {
+    constructor(brainyData: BrainyInterface, options?: MCPServiceOptions & {
         broadcastPort?: number;
         cloudUrl?: string;
     });

package/dist/mcp/brainyMCPBroadcast.js

@@ -11,7 +11,7 @@
  * - Works both locally and with cloud deployment
  */
 import { WebSocketServer, WebSocket } from 'ws';
-import { createServer } from 'http';
+import { createServer } from 'node:http';
 import { BrainyMCPService } from './brainyMCPService.js';
 import { v4 as uuidv4 } from '../universal/uuid.js';
 export class BrainyMCPBroadcast extends BrainyMCPService {

package/dist/mcp/brainyMCPClient.js

@@ -5,7 +5,7 @@
  * Utilizes Brainy for persistent memory and vector search capabilities
  */
 import WebSocket from 'ws';
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 import { v4 as uuidv4 } from '../universal/uuid.js';
 export class BrainyMCPClient {
     constructor(options) {
@@ -23,7 +23,7 @@ export class BrainyMCPClient {
      */
     async initBrainy() {
         if (this.options.useBrainyMemory && !this.brainy) {
-            this.brainy = new BrainyData({
+            this.brainy = new Brainy({
                 storage: {
                     requestPersistentStorage: true
                 }
@@ -95,7 +95,8 @@ export class BrainyMCPClient {
                         to: message.to,
                         timestamp: message.timestamp,
                         type: message.type,
-                        event: message.event
+                        event: message.event,
+                        category: 'Message'
                     }
                 });
             }
@@ -111,7 +112,10 @@ export class BrainyMCPClient {
                 for (const histMsg of message.data.history) {
                     await this.brainy.add({
                         text: `${histMsg.from}: ${JSON.stringify(histMsg.data)}`,
-                        metadata: histMsg
+                        metadata: {
+                            ...histMsg,
+                            category: 'Message'
+                        }
                     });
                 }
             }

package/dist/neural/types.d.ts

@@ -267,8 +267,8 @@ export interface StreamingBatch<T = SemanticCluster> {
 }
 export declare class NeuralAPIError extends Error {
     code: string;
-    context?: Record<string, any> | undefined;
-    constructor(message: string, code: string, context?: Record<string, any> | undefined);
+    context?: Record<string, any>;
+    constructor(message: string, code: string, context?: Record<string, any>);
 }
 export declare class ClusteringError extends NeuralAPIError {
     constructor(message: string, context?: Record<string, any>);

package/dist/streaming/pipeline.d.ts

@@ -43,7 +43,7 @@ export declare class Pipeline<T = any> {
     private running;
     private abortController?;
     private metrics;
-    constructor(brainyInstance?: (Brainy | Brainy<any>) | undefined);
+    constructor(brainyInstance?: Brainy | Brainy<any>);
     /**
      * Add a data source
      */

package/dist/universal/fs.d.ts

@@ -28,74 +28,32 @@ export interface UniversalFS {
     }>;
     access(path: string, mode?: number): Promise<void>;
 }
-export declare const readFile: (path: string, encoding?: string) => Promise<string>;
-export declare const writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
-export declare const mkdir: (path: string, options?: {
-    recursive?: boolean;
-}) => Promise<void>;
-export declare const exists: (path: string) => Promise<boolean>;
-export declare const readdir: {
-    (path: string): Promise<string[]>;
-    (path: string, options: {
-        withFileTypes: true;
-    }): Promise<{
-        name: string;
-        isDirectory(): boolean;
-        isFile(): boolean;
-    }[]>;
-};
-export declare const unlink: (path: string) => Promise<void>;
-export declare const stat: (path: string) => Promise<{
-    isFile(): boolean;
-    isDirectory(): boolean;
-}>;
-export declare const access: (path: string, mode?: number) => Promise<void>;
+export declare const readFile: any;
+export declare const writeFile: any;
+export declare const mkdir: any;
+export declare const exists: any;
+export declare const readdir: any;
+export declare const unlink: any;
+export declare const stat: any;
+export declare const access: any;
 declare const _default: {
-    readFile: (path: string, encoding?: string) => Promise<string>;
-    writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
-    mkdir: (path: string, options?: {
-        recursive?: boolean;
-    }) => Promise<void>;
-    exists: (path: string) => Promise<boolean>;
-    readdir: {
-        (path: string): Promise<string[]>;
-        (path: string, options: {
-            withFileTypes: true;
-        }): Promise<{
-            name: string;
-            isDirectory(): boolean;
-            isFile(): boolean;
-        }[]>;
-    };
-    unlink: (path: string) => Promise<void>;
-    stat: (path: string) => Promise<{
-        isFile(): boolean;
-        isDirectory(): boolean;
-    }>;
-    access: (path: string, mode?: number) => Promise<void>;
+    readFile: any;
+    writeFile: any;
+    mkdir: any;
+    exists: any;
+    readdir: any;
+    unlink: any;
+    stat: any;
+    access: any;
 };
 export default _default;
 export declare const promises: {
-    readFile: (path: string, encoding?: string) => Promise<string>;
-    writeFile: (path: string, data: string, encoding?: string) => Promise<void>;
-    mkdir: (path: string, options?: {
-        recursive?: boolean;
-    }) => Promise<void>;
-    exists: (path: string) => Promise<boolean>;
-    readdir: {
-        (path: string): Promise<string[]>;
-        (path: string, options: {
-            withFileTypes: true;
-        }): Promise<{
-            name: string;
-            isDirectory(): boolean;
-            isFile(): boolean;
-        }[]>;
-    };
-    unlink: (path: string) => Promise<void>;
-    stat: (path: string) => Promise<{
-        isFile(): boolean;
-        isDirectory(): boolean;
-    }>;
-    access: (path: string, mode?: number) => Promise<void>;
+    readFile: any;
+    writeFile: any;
+    mkdir: any;
+    exists: any;
+    readdir: any;
+    unlink: any;
+    stat: any;
+    access: any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.19.0",
+  "version": "3.19.1",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -55,7 +55,7 @@
     "node": "22.x"
   },
   "scripts": {
-    "build": "npm run build:patterns:if-needed && tsc",
+    "build": "npm run build:patterns:if-needed && tsc && tsc -p tsconfig.cli.json",
     "build:patterns": "tsx scripts/buildEmbeddedPatterns.ts",
     "build:patterns:if-needed": "node scripts/check-patterns.cjs || npm run build:patterns",
     "build:patterns:force": "npm run build:patterns",