@simonfestl/husky-cli 1.6.3 → 1.6.4

package/dist/lib/biz/agent-brain.d.ts

@@ -3,9 +3,9 @@ export type AgentType = typeof AGENT_TYPES[number];
 export interface Memory {
     id: string;
     agent: string;
+    agentType?: string;
     content: string;
     tags: string[];
-    embedding?: number[];
     createdAt: Date;
     updatedAt: Date;
     metadata?: Record<string, unknown>;
@@ -21,19 +21,17 @@ export interface AgentBrainOptions {
 }
 export declare function isValidAgentType(value: string | undefined): value is AgentType;
 export declare function getAgentType(): AgentType | undefined;
-export declare function getDatabaseName(agentType?: AgentType): string;
 export declare class AgentBrain {
-    private db;
+    private qdrant;
     private embeddings;
     private agentId;
     private agentType?;
-    private collectionPath;
-    private databaseName;
     constructor(agentIdOrOptions: string | AgentBrainOptions, projectId?: string);
     getDatabaseInfo(): {
         agentType?: AgentType;
         databaseName: string;
     };
+    private ensureCollection;
     remember(content: string, tags?: string[], metadata?: Record<string, unknown>): Promise<string>;
     recall(query: string, limit?: number, minScore?: number): Promise<RecallResult[]>;
     recallByTags(tags: string[], limit?: number): Promise<Memory[]>;
@@ -43,6 +41,5 @@ export declare class AgentBrain {
         count: number;
         tags: Record<string, number>;
     }>;
-    private cosineSimilarity;
 }
 export default AgentBrain;

package/dist/lib/biz/agent-brain.js

@@ -1,19 +1,10 @@
-import { initializeApp, getApps } from 'firebase-admin/app';
-import { getFirestore, Timestamp } from 'firebase-admin/firestore';
+import { QdrantClient } from './qdrant.js';
 import { EmbeddingService } from './embeddings.js';
 import { getConfig } from '../../commands/config.js';
-const BRAIN_COLLECTION = 'agent_brains';
-const DEFAULT_DATABASE = '(default)';
+import { randomUUID } from 'crypto';
+const MEMORIES_COLLECTION = 'agent-memories';
+const VECTOR_SIZE = 768;
 export const AGENT_TYPES = ['support', 'claude', 'gotess', 'supervisor', 'worker'];
-const AGENT_DB_MAP = {
-    support: 'support-brain-db',
-    claude: 'claude-brain-db',
-    gotess: 'gotess-brain-db',
-    supervisor: 'supervisor-brain-db',
-    worker: 'worker-brain-db',
-};
-const firestoreCache = new Map();
-let firebaseInitialized = false;
 export function isValidAgentType(value) {
     return value !== undefined && AGENT_TYPES.includes(value);
 }
@@ -29,19 +20,11 @@ export function getAgentType() {
     }
     return undefined;
 }
-export function getDatabaseName(agentType) {
-    if (!agentType) {
-        return DEFAULT_DATABASE;
-    }
-    return AGENT_DB_MAP[agentType];
-}
 export class AgentBrain {
-    db;
+    qdrant;
     embeddings;
     agentId;
     agentType;
-    collectionPath;
-    databaseName;
     constructor(agentIdOrOptions, projectId) {
         let options;
         if (typeof agentIdOrOptions === 'string') {
@@ -53,144 +36,164 @@ export class AgentBrain {
         const config = getConfig();
         this.agentId = options.agentId;
         this.agentType = options.agentType || getAgentType();
-        this.databaseName = getDatabaseName(this.agentType);
+        this.qdrant = QdrantClient.fromConfig();
         const gcpProject = options.projectId || config.gcpProjectId || process.env.GOOGLE_CLOUD_PROJECT || 'tigerv0';
-        if (!firebaseInitialized && getApps().length === 0) {
-            initializeApp({ projectId: gcpProject });
-            firebaseInitialized = true;
-        }
-        const cacheKey = `${gcpProject}:${this.databaseName}`;
-        let db = firestoreCache.get(cacheKey);
-        if (!db) {
-            if (this.databaseName === DEFAULT_DATABASE) {
-                db = getFirestore();
-            }
-            else {
-                db = getFirestore(this.databaseName);
-            }
-            firestoreCache.set(cacheKey, db);
-        }
-        this.db = db;
         this.embeddings = new EmbeddingService({
             projectId: gcpProject,
             location: config.gcpLocation || 'europe-west1'
         });
-        this.collectionPath = `${BRAIN_COLLECTION}/${this.agentId}/memories`;
     }
     getDatabaseInfo() {
         return {
             agentType: this.agentType,
-            databaseName: this.databaseName,
+            databaseName: `qdrant:${MEMORIES_COLLECTION}`,
         };
     }
+    async ensureCollection() {
+        try {
+            await this.qdrant.getCollection(MEMORIES_COLLECTION);
+        }
+        catch {
+            await this.qdrant.createCollection(MEMORIES_COLLECTION, VECTOR_SIZE);
+        }
+    }
     async remember(content, tags = [], metadata) {
+        await this.ensureCollection();
         const embedding = await this.embeddings.embed(content);
-        const memory = {
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        await this.qdrant.upsertOne(MEMORIES_COLLECTION, id, embedding, {
             agent: this.agentId,
+            agentType: this.agentType || 'default',
             content,
             tags,
-            embedding,
             metadata: metadata || {},
-            createdAt: Timestamp.now(),
-            updatedAt: Timestamp.now(),
-        };
-        const ref = await this.db.collection(this.collectionPath).add(memory);
-        return ref.id;
+            createdAt: now,
+            updatedAt: now,
+        });
+        return id;
     }
     async recall(query, limit = 5, minScore = 0.5) {
+        await this.ensureCollection();
         const queryEmbedding = await this.embeddings.embed(query);
-        const snapshot = await this.db.collection(this.collectionPath).get();
-        const results = [];
-        for (const doc of snapshot.docs) {
-            const data = doc.data();
-            if (!data.embedding)
-                continue;
-            const score = this.cosineSimilarity(queryEmbedding, data.embedding);
-            if (score >= minScore) {
-                results.push({
-                    memory: {
-                        id: doc.id,
-                        agent: data.agent,
-                        content: data.content,
-                        tags: data.tags || [],
-                        createdAt: data.createdAt?.toDate() || new Date(),
-                        updatedAt: data.updatedAt?.toDate() || new Date(),
-                        metadata: data.metadata,
-                    },
-                    score,
-                });
-            }
+        const filter = {
+            must: [
+                { key: 'agent', match: { value: this.agentId } }
+            ]
+        };
+        if (this.agentType) {
+            filter.must.push({ key: 'agentType', match: { value: this.agentType } });
         }
-        return results
-            .sort((a, b) => b.score - a.score)
-            .slice(0, limit);
+        const results = await this.qdrant.search(MEMORIES_COLLECTION, queryEmbedding, limit, {
+            filter,
+            scoreThreshold: minScore,
+        });
+        return results.map(r => ({
+            memory: {
+                id: String(r.id),
+                agent: String(r.payload?.agent || ''),
+                agentType: String(r.payload?.agentType || ''),
+                content: String(r.payload?.content || ''),
+                tags: r.payload?.tags || [],
+                createdAt: new Date(String(r.payload?.createdAt || new Date().toISOString())),
+                updatedAt: new Date(String(r.payload?.updatedAt || new Date().toISOString())),
+                metadata: r.payload?.metadata,
+            },
+            score: r.score,
+        }));
     }
     async recallByTags(tags, limit = 10) {
         if (tags.length === 0) {
             return [];
         }
-        const snapshot = await this.db
-            .collection(this.collectionPath)
-            .where('tags', 'array-contains-any', tags)
-            .orderBy('createdAt', 'desc')
-            .limit(limit)
-            .get();
-        return snapshot.docs.map(doc => ({
-            id: doc.id,
-            agent: doc.data().agent,
-            content: doc.data().content,
-            tags: doc.data().tags || [],
-            createdAt: doc.data().createdAt?.toDate() || new Date(),
-            updatedAt: doc.data().updatedAt?.toDate() || new Date(),
-            metadata: doc.data().metadata,
-        }));
+        await this.ensureCollection();
+        const filter = {
+            must: [
+                { key: 'agent', match: { value: this.agentId } },
+                {
+                    should: tags.map(tag => ({
+                        key: 'tags',
+                        match: { any: [tag] }
+                    }))
+                }
+            ]
+        };
+        const results = await this.qdrant.scroll(MEMORIES_COLLECTION, {
+            filter,
+            limit,
+            with_payload: true,
+        });
+        return results
+            .map(r => ({
+            id: String(r.id),
+            agent: String(r.payload?.agent || ''),
+            agentType: String(r.payload?.agentType || ''),
+            content: String(r.payload?.content || ''),
+            tags: r.payload?.tags || [],
+            createdAt: new Date(String(r.payload?.createdAt || new Date().toISOString())),
+            updatedAt: new Date(String(r.payload?.updatedAt || new Date().toISOString())),
+            metadata: r.payload?.metadata,
+        }))
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     }
     async forget(memoryId) {
-        await this.db.collection(this.collectionPath).doc(memoryId).delete();
+        await this.ensureCollection();
+        await this.qdrant.deletePoints(MEMORIES_COLLECTION, [memoryId]);
     }
     async listMemories(limit = 20) {
-        const snapshot = await this.db
-            .collection(this.collectionPath)
-            .orderBy('createdAt', 'desc')
-            .limit(limit)
-            .get();
-        return snapshot.docs.map(doc => ({
-            id: doc.id,
-            agent: doc.data().agent,
-            content: doc.data().content,
-            tags: doc.data().tags || [],
-            createdAt: doc.data().createdAt?.toDate() || new Date(),
-            updatedAt: doc.data().updatedAt?.toDate() || new Date(),
-            metadata: doc.data().metadata,
-        }));
+        await this.ensureCollection();
+        const filter = {
+            must: [
+                { key: 'agent', match: { value: this.agentId } }
+            ]
+        };
+        if (this.agentType) {
+            filter.must.push({ key: 'agentType', match: { value: this.agentType } });
+        }
+        const results = await this.qdrant.scroll(MEMORIES_COLLECTION, {
+            filter,
+            limit,
+            with_payload: true,
+        });
+        return results
+            .map(r => ({
+            id: String(r.id),
+            agent: String(r.payload?.agent || ''),
+            agentType: String(r.payload?.agentType || ''),
+            content: String(r.payload?.content || ''),
+            tags: r.payload?.tags || [],
+            createdAt: new Date(String(r.payload?.createdAt || new Date().toISOString())),
+            updatedAt: new Date(String(r.payload?.updatedAt || new Date().toISOString())),
+            metadata: r.payload?.metadata,
+        }))
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     }
     async stats() {
-        const snapshot = await this.db.collection(this.collectionPath).get();
+        await this.ensureCollection();
+        const filter = {
+            must: [
+                { key: 'agent', match: { value: this.agentId } }
+            ]
+        };
+        if (this.agentType) {
+            filter.must.push({ key: 'agentType', match: { value: this.agentType } });
+        }
+        const results = await this.qdrant.scroll(MEMORIES_COLLECTION, {
+            filter,
+            limit: 1000,
+            with_payload: true,
+        });
         const tagCounts = {};
-        for (const doc of snapshot.docs) {
-            const tags = doc.data().tags || [];
+        for (const r of results) {
+            const tags = r.payload?.tags || [];
             for (const tag of tags) {
                 tagCounts[tag] = (tagCounts[tag] || 0) + 1;
             }
         }
         return {
-            count: snapshot.size,
+            count: results.length,
             tags: tagCounts,
         };
     }
-    cosineSimilarity(a, b) {
-        if (a.length !== b.length)
-            return 0;
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-        return magnitude === 0 ? 0 : dotProduct / magnitude;
-    }
 }
 export default AgentBrain;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "1.6.3",
+  "version": "1.6.4",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {