@bluehawks/cli 1.0.3 → 1.0.6

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.6';
 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,10 @@ import {
     type ToolDefinition,
     type ToolResult,
     type StreamDelta,
+    type EmbeddingRequest,
+    type EmbeddingResponse,
+    type RerankRequest,
+    type RerankResponse,
     APIError,
 } from './types.js';
 
@@ -42,6 +46,30 @@ 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);
+    }
+
+    /**
+     * Rerank documents based on query relevance
+     */
+    async rerank(request: RerankRequest): Promise<RerankResponse> {
+        return this.makeRequest<RerankResponse>('/rerank', request);
+    }
+
+
+
     /**
      * Create a chat completion (non-streaming)
      */

package/src/core/api/types.ts

@@ -136,6 +136,52 @@ 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[];
+}
+
+// Rerank Types
+export interface RerankRequest {
+    model?: string;
+    query: string;
+    documents: string[];
+    top_n?: number;
+}
+
+export interface RerankResult {
+    index: number;
+    score: number;
+    document: string;
+}
+
+export interface RerankResponse {
+    model: string;
+    results: RerankResult[];
+    usage?: {
+        total_tokens: number;
+        prompt_tokens?: 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,146 @@
+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();
+
+        // Stage 1: Vector Search (Fetch 50 candidates)
+        const candidates = 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)
+            .slice(0, 50); // increased limit for reranking
+
+        if (candidates.length === 0) return [];
+
+        // Stage 2: Reranking
+        try {
+            // Rerank candidates
+            const rerankResponse = await apiClient.rerank({
+                query,
+                documents: candidates.map(c => c.content),
+                top_n: limit
+            });
+
+            // Map reranked results back to memory objects
+            const rerankedResults = rerankResponse.results.map(result => {
+                const candidate = candidates[result.index];
+                return {
+                    ...candidate,
+                    similarity: result.score // Update similarity with reranker score
+                };
+            });
+
+            return rerankedResults;
+
+        } catch (error) {
+            console.warn('Reranking failed, falling back to vector similarity:', error);
+            // Fallback: return top K from vector search
+            return candidates.slice(0, limit);
+        }
+    }
+
+    /**
+     * 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';

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

@@ -0,0 +1,171 @@
+import { toolRegistry, type ToolHandler } from '../registry.js';
+import { memoryManager } from '../../memory/index.js';
+
+// Remember Tool
+const rememberTool: ToolHandler = {
+    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 as string;
+        const type = (args.type as any) || 'knowledge';
+        const tags = (args.tags as string[]) || [];
+
+        const memory = await memoryManager.remember(content, type, { tags });
+        return `Remembered: "${content}" (ID: ${memory.id})`;
+    },
+};
+
+// Recall Tool
+const recallTool: ToolHandler = {
+    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 as string;
+        const limit = (args.limit as number) || 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: ToolHandler = {
+    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 as string;
+        await memoryManager.forget(id);
+        return `Forgot memory with ID: ${id}`;
+    },
+};
+
+// Learn Mistake Tool
+const learnMistakeTool: ToolHandler = {
+    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 as string;
+        const fix = args.fix as string;
+        const context = args.context as string | undefined;
+
+        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(): void {
+    toolRegistry.register(rememberTool);
+    toolRegistry.register(recallTool);
+    toolRegistry.register(forgetTool);
+    toolRegistry.register(learnMistakeTool);
+}

package/src/index.ts

@@ -192,9 +192,6 @@ program
 
 
         // Interactive mode
-        console.log(`\n🦅 ${CLI_NAME} v${CLI_VERSION}`);
-        console.log(`   API: ${API_BASE_URL}`);
-        console.log(`   Model: ${DEFAULT_MODEL}\n`);
 
         const { waitUntilExit } = render(
             React.createElement(App, {