@bluehawks/cli 1.0.3 → 1.0.4

package/dist/core/tools/definitions/memory.js

@@ -0,0 +1,155 @@
+import { toolRegistry } from '../registry.js';
+import { memoryManager } from '../../memory/index.js';
+// Remember Tool
+const rememberTool = {
+    name: 'remember',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'remember',
+            description: 'Store a piece of information, preference, or concept in long-term memory. Use this to remember user choices, project guidelines, or important facts.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    content: {
+                        type: 'string',
+                        description: 'The information to remember.',
+                    },
+                    type: {
+                        type: 'string',
+                        enum: ['preference', 'mistake', 'knowledge', 'task_context'],
+                        description: 'The type of memory. Default is knowledge.',
+                    },
+                    tags: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Tags to categorize this memory.',
+                    },
+                },
+                required: ['content'],
+            },
+        },
+    },
+    async execute(args) {
+        const content = args.content;
+        const type = args.type || 'knowledge';
+        const tags = args.tags || [];
+        const memory = await memoryManager.remember(content, type, { tags });
+        return `Remembered: "${content}" (ID: ${memory.id})`;
+    },
+};
+// Recall Tool
+const recallTool = {
+    name: 'recall',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'recall',
+            description: 'Search long-term memory for relevant information. Use this to find past decisions, user preferences, or project guidelines.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'The search query to find relevant memories.',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of results to return. Default is 5.',
+                    },
+                },
+                required: ['query'],
+            },
+        },
+    },
+    async execute(args) {
+        const query = args.query;
+        const limit = args.limit || 5;
+        const results = await memoryManager.search(query, limit);
+        if (results.length === 0) {
+            return 'No relevant memories found.';
+        }
+        return results
+            .map((m) => `[${m.type.toUpperCase()}] ${m.content} (Similarity: ${(m.similarity * 100).toFixed(1)}%)`)
+            .join('\n');
+    },
+};
+// Forget Tool
+const forgetTool = {
+    name: 'forget',
+    safeToAutoRun: false, // Deletion is unsafe
+    definition: {
+        type: 'function',
+        function: {
+            name: 'forget',
+            description: 'Delete a memory by its ID.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'The ID of the memory to delete.',
+                    },
+                },
+                required: ['id'],
+            },
+        },
+    },
+    async execute(args) {
+        const id = args.id;
+        await memoryManager.forget(id);
+        return `Forgot memory with ID: ${id}`;
+    },
+};
+// Learn Mistake Tool
+const learnMistakeTool = {
+    name: 'learn_mistake',
+    safeToAutoRun: true, // Learning is safe
+    definition: {
+        type: 'function',
+        function: {
+            name: 'learn_mistake',
+            description: 'Record a mistake and its solution to avoid repeating it in the future.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    error: {
+                        type: 'string',
+                        description: 'The error or mistake that occurred.',
+                    },
+                    fix: {
+                        type: 'string',
+                        description: 'The solution or lesson learned.',
+                    },
+                    context: {
+                        type: 'string',
+                        description: 'Optional context (e.g., file path, command).',
+                    },
+                },
+                required: ['error', 'fix'],
+            },
+        },
+    },
+    async execute(args) {
+        const error = args.error;
+        const fix = args.fix;
+        const context = args.context;
+        const content = `Mistake: ${error}\nSolution: ${fix}${context ? `\nContext: ${context}` : ''}`;
+        const memory = await memoryManager.remember(content, 'mistake', {
+            originalError: error,
+            fix,
+            context,
+        });
+        return `Recorded mistake and solution (ID: ${memory.id}). I will remember this to avoid it in the future.`;
+    },
+};
+// Register all memory tools
+export function registerMemoryTools() {
+    toolRegistry.register(rememberTool);
+    toolRegistry.register(recallTool);
+    toolRegistry.register(forgetTool);
+    toolRegistry.register(learnMistakeTool);
+}
+//# sourceMappingURL=memory.js.map

package/dist/core/tools/definitions/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../../src/core/tools/definitions/memory.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluehawks/cli",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "A production-ready multi-agent AI CLI assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -35,6 +35,7 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
+    "better-sqlite3": "^12.6.2",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "eventsource-parser": "^3.0.0",
@@ -50,6 +51,7 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.10.5",
     "@types/react": "^18.3.18",
     "@typescript-eslint/eslint-plugin": "^8.19.1",

package/src/config/constants.ts

@@ -8,7 +8,7 @@ export const DEFAULT_MODEL = 'Qwen/Qwen3-0.6B';
 
 // CLI Metadata
 export const CLI_NAME = 'bluehawks';
-export const CLI_VERSION = '1.0.3';
+export const CLI_VERSION = '1.0.4';
 export const CLI_DESCRIPTION = 'A production-ready multi-agent AI CLI assistant';
 
 // Configuration Paths

package/src/core/agents/orchestrator.ts

@@ -9,6 +9,7 @@ import { Agent, type AgentResponse } from './agent.js';
 import { CONTEXT_FILE } from '../../config/constants.js';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import { memoryManager } from '../memory/index.js'; // Corrected path
 
 export interface SubAgentConfig {
     name: string;
@@ -178,17 +179,27 @@ Before making any changes, first:
             onToolEnd?: (name: string, result: string) => void;
         }
     ): Promise<AgentResponse> {
+        // Retrieve relevant memories
+        const memories = await memoryManager.search(userMessage, 5);
+        let systemPrompt = this.buildSystemPrompt();
+
+        if (memories.length > 0) {
+            const memoryContext = memories
+                .map(m => `- [${m.type.toUpperCase()}] ${m.content}`)
+                .join('\n');
+            systemPrompt += `\n\n## Long-Term Memory (Relevant Context)\n${memoryContext}\n\nUse this information to guide your decisions and avoid past mistakes.`;
+        }
+
         const mainAgent = new Agent(
             {
                 name: 'main',
-                systemPrompt: this.buildSystemPrompt(),
+                systemPrompt,
                 maxIterations: this.maxTurns,
             },
             this.apiClient,
             this.toolExecutor
         );
 
-
         return mainAgent.run(
             userMessage,
             callbacks?.onChunk,

package/src/core/api/client.ts

@@ -22,6 +22,8 @@ import {
     type ToolDefinition,
     type ToolResult,
     type StreamDelta,
+    type EmbeddingRequest,
+    type EmbeddingResponse,
     APIError,
 } from './types.js';
 
@@ -42,6 +44,21 @@ export class APIClient {
         this.timeout = options.timeout || DEFAULT_TIMEOUT_MS;
     }
 
+    /**
+     * Create embeddings for the given input
+     */
+    async createEmbeddings(
+        input: string | string[],
+        model?: string
+    ): Promise<EmbeddingResponse> {
+        const body: EmbeddingRequest = {
+            model: model || 'text-embedding-3-small',
+            input,
+        };
+
+        return this.makeRequest<EmbeddingResponse>('/embeddings', body);
+    }
+
     /**
      * Create a chat completion (non-streaming)
      */

package/src/core/api/types.ts

@@ -136,6 +136,29 @@ export interface APIClientOptions {
 export type StreamCallback = (chunk: string) => void;
 export type ToolCallCallback = (toolCalls: ToolCall[]) => void;
 
+// Embedding Types
+export interface EmbeddingRequest {
+    model: string;
+    input: string | string[];
+    user?: string;
+}
+
+export interface EmbeddingResponse {
+    object: 'list';
+    data: EmbeddingObject[];
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}
+
+export interface EmbeddingObject {
+    object: 'embedding';
+    index: number;
+    embedding: number[];
+}
+
 // API Error
 export class APIError extends Error {
     constructor(

package/src/core/memory/index.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './storage.js';
+export * from './manager.js';

package/src/core/memory/manager.ts

@@ -0,0 +1,120 @@
+import { apiClient } from '../api/client.js';
+import { memoryStorage } from './storage.js';
+import type { Memory, MemoryType, SearchResult } from './types.js';
+import * as crypto from 'crypto';
+
+export class MemoryManager {
+    private static instance: MemoryManager;
+
+    private constructor() { }
+
+    static getInstance(): MemoryManager {
+        if (!MemoryManager.instance) {
+            MemoryManager.instance = new MemoryManager();
+        }
+        return MemoryManager.instance;
+    }
+
+    /**
+     * Store a new memory
+     */
+    async remember(content: string, type: MemoryType = 'knowledge', metadata: Record<string, any> = {}): Promise<Memory> {
+        // Generate embedding
+        let embedding: number[] = [];
+        try {
+            const response = await apiClient.createEmbeddings(content);
+            if (response.data && response.data.length > 0) {
+                embedding = response.data[0].embedding;
+            }
+        } catch (error) {
+            console.error('Failed to generate embedding for memory:', error);
+            // We still save the memory without embedding, it just won't be searchable by vector
+        }
+
+        const memory: Memory = {
+            id: crypto.randomUUID(),
+            content,
+            type,
+            metadata,
+            embedding,
+            created_at: Date.now(),
+            updated_at: Date.now(),
+        };
+
+        await memoryStorage.save(memory);
+        return memory;
+    }
+
+    /**
+     * Search memories by semantic similarity
+     */
+    async search(query: string, limit: number = 5, minSimilarity: number = 0.7): Promise<SearchResult[]> {
+        // Generate query embedding
+        let queryEmbedding: number[] = [];
+        try {
+            const response = await apiClient.createEmbeddings(query);
+            if (response.data && response.data.length > 0) {
+                queryEmbedding = response.data[0].embedding;
+            }
+        } catch (error) {
+            console.error('Failed to generate embedding for search query:', error);
+            // Fallback to keyword search? For now just return empty if vector search fails
+            return [];
+        }
+
+        const allMemories = await memoryStorage.getAll();
+
+        // Calculate similarity for each memory
+        const results: SearchResult[] = allMemories
+            .filter(m => m.embedding && m.embedding.length > 0)
+            .map(memory => {
+                const similarity = this.cosineSimilarity(queryEmbedding, memory.embedding!);
+                return { ...memory, similarity };
+            })
+            .filter(r => r.similarity >= minSimilarity)
+            .sort((a, b) => b.similarity - a.similarity) // Descending
+            .slice(0, limit);
+
+        return results;
+    }
+
+    /**
+     * Retrieve a memory by ID
+     */
+    async get(id: string): Promise<Memory | null> {
+        return memoryStorage.get(id);
+    }
+
+    /**
+     * Delete a memory
+     */
+    async forget(id: string): Promise<void> {
+        await memoryStorage.delete(id);
+    }
+
+    /**
+     * Clear all memories (useful for testing or reset)
+     */
+    async clear(): Promise<void> {
+        await memoryStorage.clear();
+    }
+
+    private cosineSimilarity(vecA: number[], vecB: number[]): number {
+        if (vecA.length !== vecB.length) return 0;
+
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+
+        for (let i = 0; i < vecA.length; i++) {
+            dotProduct += vecA[i] * vecB[i];
+            normA += vecA[i] * vecA[i];
+            normB += vecB[i] * vecB[i];
+        }
+
+        if (normA === 0 || normB === 0) return 0;
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+}
+
+export const memoryManager = MemoryManager.getInstance();

package/src/core/memory/storage.ts

@@ -0,0 +1,90 @@
+import Database from 'better-sqlite3';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+import { CONFIG_DIR_NAME } from '../../config/constants.js';
+import type { Memory, MemoryType } from './types.js';
+
+export class MemoryStorage {
+    private db: Database.Database;
+    private dbPath: string;
+
+    constructor() {
+        const homeDir = os.homedir();
+        const configDir = path.join(homeDir, CONFIG_DIR_NAME);
+
+        // Ensure directory exists
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+
+        this.dbPath = path.join(configDir, 'memory.db');
+        this.db = new Database(this.dbPath);
+        this.initialize();
+    }
+
+    private initialize(): void {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS memories (
+                id TEXT PRIMARY KEY,
+                content TEXT NOT NULL,
+                type TEXT NOT NULL,
+                metadata TEXT,
+                embedding TEXT,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+        `);
+    }
+
+    async save(memory: Memory): Promise<void> {
+        const stmt = this.db.prepare(`
+            INSERT OR REPLACE INTO memories (id, content, type, metadata, embedding, created_at, updated_at)
+            VALUES (@id, @content, @type, @metadata, @embedding, @created_at, @updated_at)
+        `);
+
+        stmt.run({
+            ...memory,
+            metadata: JSON.stringify(memory.metadata || {}),
+            embedding: JSON.stringify(memory.embedding || []),
+        });
+    }
+
+    async get(id: string): Promise<Memory | null> {
+        const stmt = this.db.prepare('SELECT * FROM memories WHERE id = ?');
+        const row = stmt.get(id) as any;
+
+        if (!row) return null;
+        return this.mapRowToMemory(row);
+    }
+
+    async getAll(): Promise<Memory[]> {
+        const stmt = this.db.prepare('SELECT * FROM memories');
+        const rows = stmt.all() as any[];
+        return rows.map(r => this.mapRowToMemory(r));
+    }
+
+    async delete(id: string): Promise<void> {
+        const stmt = this.db.prepare('DELETE FROM memories WHERE id = ?');
+        stmt.run(id);
+    }
+
+    async clear(): Promise<void> {
+        this.db.exec('DELETE FROM memories');
+    }
+
+    private mapRowToMemory(row: any): Memory {
+        return {
+            id: row.id,
+            content: row.content,
+            type: row.type as MemoryType,
+            metadata: JSON.parse(row.metadata),
+            embedding: JSON.parse(row.embedding),
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+        };
+    }
+}
+
+export const memoryStorage = new MemoryStorage();

package/src/core/memory/types.ts

@@ -0,0 +1,22 @@
+export interface Memory {
+    id: string;
+    content: string;
+    type: MemoryType;
+    metadata?: Record<string, any>;
+    embedding?: number[];
+    created_at: number;
+    updated_at: number;
+}
+
+export type MemoryType = 'preference' | 'mistake' | 'knowledge' | 'task_context';
+
+export interface MemoryMetadata {
+    source?: string;
+    confidence?: number;
+    tags?: string[];
+    [key: string]: any;
+}
+
+export interface SearchResult extends Memory {
+    similarity: number;
+}

package/src/core/tools/definitions/index.ts

@@ -8,6 +8,7 @@ import { registerShellTools } from './shell.js';
 import { registerSearchTools } from './search.js';
 import { registerGitTools } from './git.js';
 import { registerWebTools } from './web.js';
+import { registerMemoryTools } from './memory.js';
 
 export function registerAllTools(): void {
     registerFileTools();
@@ -15,6 +16,7 @@ export function registerAllTools(): void {
     registerSearchTools();
     registerGitTools();
     registerWebTools();
+    registerMemoryTools();
 }
 
 export * from './file.js';
@@ -22,3 +24,4 @@ export * from './shell.js';
 export * from './search.js';
 export * from './git.js';
 export * from './web.js';
+export * from './memory.js';