@soulcraft/brainy 3.18.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/conversation/conversationManager.d.ts

@@ -0,0 +1,176 @@
+/**
+ * ConversationManager - Infinite Agent Memory
+ *
+ * Production-ready conversation and context management for AI agents.
+ * Built on Brainy's existing infrastructure: Triple Intelligence, Neural API, VFS.
+ *
+ * REAL IMPLEMENTATION - No stubs, no mocks, no TODOs
+ */
+import { Brainy } from '../brainy.js';
+import { MessageRole, ConversationThread, ConversationContext, SaveMessageOptions, ContextRetrievalOptions, ConversationSearchOptions, ConversationSearchResult, ConversationTheme, ArtifactOptions, ConversationStats } from './types.js';
+/**
+ * ConversationManager - High-level API for conversation operations
+ *
+ * Uses existing Brainy infrastructure:
+ * - brain.add() for messages
+ * - brain.relate() for threading
+ * - brain.find() with Triple Intelligence for context
+ * - brain.neural for clustering and similarity
+ * - brain.vfs() for artifacts
+ */
+export declare class ConversationManager {
+    private brain;
+    private initialized;
+    private _vfs;
+    /**
+     * Create a ConversationManager instance
+     * @param brain Brainy instance to use
+     */
+    constructor(brain: Brainy);
+    /**
+     * Initialize the conversation manager
+     * Lazy initialization pattern - only called when first used
+     */
+    init(): Promise<void>;
+    /**
+     * Save a message to the conversation history
+     *
+     * Uses: brain.add() with NounType.Message
+     * Real implementation - stores message with embedding
+     *
+     * @param content Message content
+     * @param role Message role (user, assistant, system, tool)
+     * @param options Save options (conversationId, metadata, etc.)
+     * @returns Message ID
+     */
+    saveMessage(content: string, role: MessageRole, options?: SaveMessageOptions): Promise<string>;
+    /**
+     * Link two messages in temporal sequence
+     *
+     * Uses: brain.relate() with VerbType.Precedes
+     * Real implementation - creates graph relationship
+     *
+     * @param prevMessageId ID of previous message
+     * @param nextMessageId ID of next message
+     * @returns Relationship ID
+     */
+    linkMessages(prevMessageId: string, nextMessageId: string): Promise<string>;
+    /**
+     * Get a full conversation thread
+     *
+     * Uses: brain.getNoun() and brain.getConnections()
+     * Real implementation - traverses graph relationships
+     *
+     * @param conversationId Conversation ID
+     * @param options Options (includeArtifacts, etc.)
+     * @returns Complete conversation thread
+     */
+    getConversationThread(conversationId: string, options?: {
+        includeArtifacts?: boolean;
+    }): Promise<ConversationThread>;
+    /**
+     * Get relevant context for a query
+     *
+     * Uses: brain.find() with Triple Intelligence
+     * Real implementation - semantic + temporal + graph ranking
+     *
+     * @param query Query string or context options
+     * @param options Retrieval options
+     * @returns Ranked context messages with artifacts
+     */
+    getRelevantContext(query: string | ContextRetrievalOptions, options?: ContextRetrievalOptions): Promise<ConversationContext>;
+    /**
+     * Search messages semantically
+     *
+     * Uses: brain.find() with semantic search
+     * Real implementation - vector similarity search
+     *
+     * @param options Search options
+     * @returns Search results with scores
+     */
+    searchMessages(options: ConversationSearchOptions): Promise<ConversationSearchResult[]>;
+    /**
+     * Find similar conversations using Neural API
+     *
+     * Uses: brain.neural.neighbors()
+     * Real implementation - semantic similarity with embeddings
+     *
+     * @param conversationId Conversation ID to find similar to
+     * @param limit Maximum number of similar conversations
+     * @param threshold Minimum similarity threshold
+     * @returns Similar conversations with relevance scores
+     */
+    findSimilarConversations(conversationId: string, limit?: number, threshold?: number): Promise<Array<{
+        id: string;
+        relevance: number;
+        metadata?: any;
+    }>>;
+    /**
+     * Get conversation themes via clustering
+     *
+     * Uses: brain.neural.clusters()
+     * Real implementation - semantic clustering
+     *
+     * @param conversationId Conversation ID
+     * @returns Discovered themes
+     */
+    getConversationThemes(conversationId: string): Promise<ConversationTheme[]>;
+    /**
+     * Save an artifact (code, file, etc.) to VFS
+     *
+     * Uses: brain.vfs()
+     * Real implementation - stores in virtual filesystem
+     *
+     * @param path VFS path
+     * @param content File content
+     * @param options Artifact options
+     * @returns Artifact entity ID
+     */
+    saveArtifact(path: string, content: string | Buffer, options: ArtifactOptions): Promise<string>;
+    /**
+     * Get conversation statistics
+     *
+     * Uses: brain.find() with aggregations
+     * Real implementation - queries and aggregates data
+     *
+     * @param conversationId Optional conversation ID to filter
+     * @returns Conversation statistics
+     */
+    getConversationStats(conversationId?: string): Promise<ConversationStats>;
+    /**
+     * Delete a message
+     *
+     * Uses: brain.deleteNoun()
+     * Real implementation - removes from graph
+     *
+     * @param messageId Message ID to delete
+     */
+    deleteMessage(messageId: string): Promise<void>;
+    /**
+     * Export conversation to JSON
+     *
+     * Uses: getConversationThread()
+     * Real implementation - serializes conversation
+     *
+     * @param conversationId Conversation ID
+     * @returns JSON-serializable conversation object
+     */
+    exportConversation(conversationId: string): Promise<any>;
+    /**
+     * Import conversation from JSON
+     *
+     * Uses: saveMessage() and linkMessages()
+     * Real implementation - recreates conversation
+     *
+     * @param data Exported conversation data
+     * @returns New conversation ID
+     */
+    importConversation(data: any): Promise<string>;
+}
+/**
+ * Create a ConversationManager instance
+ *
+ * @param brain Brainy instance
+ * @returns ConversationManager instance
+ */
+export declare function createConversationManager(brain: Brainy): ConversationManager;