@simonfestl/husky-cli 1.3.0 → 1.4.0

package/dist/commands/biz/tickets.js

@@ -459,21 +459,51 @@ ticketsCommand
         console.log(`  Searching ${options.collection}...`);
         const results = await qdrant.search(options.collection, vector, parseInt(options.limit, 10) + 1 // +1 to exclude self
         );
+        // Extract ticket_id from payload (handle nested metadata.ticket_id)
+        const extractTicketId = (payload) => {
+            if (!payload)
+                return null;
+            if (typeof payload.ticket_id === 'number')
+                return payload.ticket_id;
+            if (typeof payload.id === 'number')
+                return payload.id;
+            const metadata = payload.metadata;
+            if (metadata && typeof metadata.ticket_id === 'number')
+                return metadata.ticket_id;
+            return null;
+        };
         // Filter out the same ticket
         const filteredResults = results.filter(r => {
-            const payload = r.payload;
-            return payload?.ticket_id !== ticket.id && payload?.id !== ticket.id;
+            const ticketId = extractTicketId(r.payload);
+            return ticketId !== ticket.id;
         }).slice(0, parseInt(options.limit, 10));
+        // Fetch ticket details from Zendesk for each result
+        const ticketIds = filteredResults
+            .map(r => extractTicketId(r.payload))
+            .filter((id) => id !== null);
+        const ticketDetailsMap = new Map();
+        if (ticketIds.length > 0) {
+            console.log(`  Fetching ${ticketIds.length} ticket details...`);
+            const ticketDetails = await Promise.all(ticketIds.map(id => zendesk.getTicket(id).catch(() => null)));
+            ticketDetails.forEach((t, i) => {
+                if (t)
+                    ticketDetailsMap.set(ticketIds[i], { subject: t.subject, status: t.status });
+            });
+        }
         if (options.json) {
             console.log(JSON.stringify({
                 success: true,
                 source_ticket: { id: ticket.id, subject: ticket.subject },
-                similar: filteredResults.map(r => ({
-                    id: r.payload?.ticket_id || r.id,
-                    score: r.score,
-                    subject: r.payload?.subject,
-                    status: r.payload?.status,
-                })),
+                similar: filteredResults.map(r => {
+                    const ticketId = extractTicketId(r.payload);
+                    const details = ticketId ? ticketDetailsMap.get(ticketId) : undefined;
+                    return {
+                        id: ticketId,
+                        score: r.score,
+                        subject: details?.subject,
+                        status: details?.status,
+                    };
+                }),
             }, null, 2));
             return;
         }
@@ -483,10 +513,10 @@ ticketsCommand
             return;
         }
         for (const result of filteredResults) {
-            const payload = result.payload;
-            const ticketId = payload?.ticket_id || payload?.id || result.id;
-            const subject = payload?.subject || '(no subject)';
-            const status = payload?.status || '';
+            const ticketId = extractTicketId(result.payload);
+            const details = ticketId ? ticketDetailsMap.get(ticketId) : undefined;
+            const subject = details?.subject || '(no subject)';
+            const status = details?.status || '';
             console.log(`  [${(result.score * 100).toFixed(1)}%] #${ticketId} │ ${status} │ ${String(subject).slice(0, 45)}`);
         }
         console.log("");
@@ -505,24 +535,51 @@ ticketsCommand
     .option("--json", "Output as JSON")
     .action(async (query, options) => {
     try {
+        const zendesk = ZendeskClient.fromConfig();
         const embeddings = EmbeddingService.fromConfig();
         const qdrant = QdrantClient.fromConfig();
-        // 1. Create embedding from query
         console.log(`  Generating embedding for query...`);
         const vector = await embeddings.embed(query);
-        // 2. Search Qdrant
         console.log(`  Searching ${options.collection}...`);
         const results = await qdrant.search(options.collection, vector, parseInt(options.limit, 10));
+        const extractTicketId = (payload) => {
+            if (!payload)
+                return null;
+            if (typeof payload.ticket_id === 'number')
+                return payload.ticket_id;
+            if (typeof payload.id === 'number')
+                return payload.id;
+            const metadata = payload.metadata;
+            if (metadata && typeof metadata.ticket_id === 'number')
+                return metadata.ticket_id;
+            return null;
+        };
+        const ticketIds = results
+            .map(r => extractTicketId(r.payload))
+            .filter((id) => id !== null);
+        const ticketDetailsMap = new Map();
+        if (ticketIds.length > 0) {
+            console.log(`  Fetching ${ticketIds.length} ticket details...`);
+            const ticketDetails = await Promise.all(ticketIds.map(id => zendesk.getTicket(id).catch(() => null)));
+            ticketDetails.forEach((t, i) => {
+                if (t)
+                    ticketDetailsMap.set(ticketIds[i], { subject: t.subject, status: t.status });
+            });
+        }
         if (options.json) {
             console.log(JSON.stringify({
                 success: true,
                 query,
-                results: results.map(r => ({
-                    id: r.payload?.ticket_id || r.id,
-                    score: r.score,
-                    subject: r.payload?.subject,
-                    status: r.payload?.status,
-                })),
+                results: results.map(r => {
+                    const ticketId = extractTicketId(r.payload);
+                    const details = ticketId ? ticketDetailsMap.get(ticketId) : undefined;
+                    return {
+                        id: ticketId,
+                        score: r.score,
+                        subject: details?.subject,
+                        status: details?.status,
+                    };
+                }),
             }, null, 2));
             return;
         }
@@ -532,10 +589,10 @@ ticketsCommand
             return;
         }
         for (const result of results) {
-            const payload = result.payload;
-            const ticketId = payload?.ticket_id || payload?.id || result.id;
-            const subject = payload?.subject || '(no subject)';
-            const status = payload?.status || '';
+            const ticketId = extractTicketId(result.payload);
+            const details = ticketId ? ticketDetailsMap.get(ticketId) : undefined;
+            const subject = details?.subject || '(no subject)';
+            const status = details?.status || '';
             console.log(`  [${(result.score * 100).toFixed(1)}%] #${ticketId} │ ${status} │ ${String(subject).slice(0, 45)}`);
         }
         console.log("");

package/dist/commands/brain.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const brainCommand: Command;
+export default brainCommand;

package/dist/commands/brain.js

@@ -0,0 +1,168 @@
+import { Command } from "commander";
+import { AgentBrain } from "../lib/biz/agent-brain.js";
+const DEFAULT_AGENT = process.env.HUSKY_AGENT_ID || 'default';
+export const brainCommand = new Command("brain")
+    .description("Agent memory and knowledge management");
+brainCommand
+    .command("remember <content>")
+    .description("Store a memory")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("-t, --tags <tags>", "Comma-separated tags")
+    .option("--json", "Output as JSON")
+    .action(async (content, options) => {
+    try {
+        const brain = new AgentBrain(options.agent);
+        const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+        console.log(`  Storing memory for agent: ${options.agent}...`);
+        const id = await brain.remember(content, tags);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, id, agent: options.agent }));
+        }
+        else {
+            console.log(`  ✓ Memory stored: ${id}`);
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("recall <query>")
+    .description("Search memories semantically")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("-l, --limit <num>", "Max results", "5")
+    .option("-m, --min-score <score>", "Minimum similarity score (0-1)", "0.5")
+    .option("--json", "Output as JSON")
+    .action(async (query, options) => {
+    try {
+        const brain = new AgentBrain(options.agent);
+        console.log(`  Searching memories for: "${query}"...`);
+        const results = await brain.recall(query, parseInt(options.limit, 10), parseFloat(options.minScore));
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, query, results }));
+            return;
+        }
+        console.log(`\n  🧠 Memories for "${query}" (${results.length} found)\n`);
+        if (results.length === 0) {
+            console.log("  No relevant memories found.");
+            return;
+        }
+        for (const r of results) {
+            const tags = r.memory.tags.length > 0 ? ` [${r.memory.tags.join(", ")}]` : "";
+            console.log(`  [${(r.score * 100).toFixed(1)}%] ${r.memory.content.slice(0, 80)}${tags}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("list")
+    .description("List recent memories")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("-l, --limit <num>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const brain = new AgentBrain(options.agent);
+        const memories = await brain.listMemories(parseInt(options.limit, 10));
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, memories }));
+            return;
+        }
+        console.log(`\n  🧠 Memories for agent: ${options.agent} (${memories.length})\n`);
+        if (memories.length === 0) {
+            console.log("  No memories stored yet.");
+            return;
+        }
+        for (const m of memories) {
+            const date = m.createdAt.toLocaleDateString("de-DE");
+            const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+            console.log(`  ${date} │ ${m.content.slice(0, 60)}...${tags}`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("forget <id>")
+    .description("Delete a memory")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .action(async (memoryId, options) => {
+    try {
+        const brain = new AgentBrain(options.agent);
+        await brain.forget(memoryId);
+        console.log(`  ✓ Memory deleted: ${memoryId}`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("stats")
+    .description("Show memory statistics")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const brain = new AgentBrain(options.agent);
+        const stats = await brain.stats();
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, agent: options.agent, ...stats }));
+            return;
+        }
+        console.log(`\n  🧠 Brain Stats for: ${options.agent}`);
+        console.log(`  ────────────────────────────────`);
+        console.log(`  Total memories: ${stats.count}`);
+        if (Object.keys(stats.tags).length > 0) {
+            console.log(`\n  Tags:`);
+            const sortedTags = Object.entries(stats.tags).sort((a, b) => b[1] - a[1]);
+            for (const [tag, count] of sortedTags.slice(0, 10)) {
+                console.log(`    ${tag}: ${count}`);
+            }
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("tags <tags>")
+    .description("Find memories by tags")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("-l, --limit <num>", "Max results", "10")
+    .option("--json", "Output as JSON")
+    .action(async (tags, options) => {
+    try {
+        const brain = new AgentBrain(options.agent);
+        const tagList = tags.split(",").map((t) => t.trim());
+        const memories = await brain.recallByTags(tagList, parseInt(options.limit, 10));
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, tags: tagList, memories }));
+            return;
+        }
+        console.log(`\n  🏷️  Memories with tags: ${tagList.join(", ")} (${memories.length})\n`);
+        if (memories.length === 0) {
+            console.log("  No memories found with these tags.");
+            return;
+        }
+        for (const m of memories) {
+            console.log(`  ${m.content.slice(0, 70)}...`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+export default brainCommand;

package/dist/index.js

@@ -27,6 +27,7 @@ import { serviceAccountCommand } from "./commands/service-account.js";
 import { chatCommand } from "./commands/chat.js";
 import { previewCommand } from "./commands/preview.js";
 import { initCommand } from "./commands/init.js";
+import { brainCommand } from "./commands/brain.js";
 // Read version from package.json
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
@@ -61,6 +62,7 @@ program.addCommand(previewCommand);
 program.addCommand(llmCommand);
 program.addCommand(initCommand);
 program.addCommand(agentMsgCommand);
+program.addCommand(brainCommand);
 // Handle --llm flag specially
 if (process.argv.includes("--llm")) {
     printLLMContext();

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

@@ -0,0 +1,32 @@
+export interface Memory {
+    id: string;
+    agent: string;
+    content: string;
+    tags: string[];
+    embedding?: number[];
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, unknown>;
+}
+export interface RecallResult {
+    memory: Memory;
+    score: number;
+}
+export declare class AgentBrain {
+    private db;
+    private embeddings;
+    private agentId;
+    private collectionPath;
+    constructor(agentId: string, projectId?: string);
+    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[]>;
+    forget(memoryId: string): Promise<void>;
+    listMemories(limit?: number): Promise<Memory[]>;
+    stats(): Promise<{
+        count: number;
+        tags: Record<string, number>;
+    }>;
+    private cosineSimilarity;
+}
+export default AgentBrain;

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

@@ -0,0 +1,132 @@
+import { initializeApp, getApps } from 'firebase-admin/app';
+import { getFirestore, Timestamp } from 'firebase-admin/firestore';
+import { EmbeddingService } from './embeddings.js';
+import { getConfig } from '../../commands/config.js';
+const BRAIN_COLLECTION = 'agent_brains';
+export class AgentBrain {
+    db;
+    embeddings;
+    agentId;
+    collectionPath;
+    constructor(agentId, projectId) {
+        this.agentId = agentId;
+        const config = getConfig();
+        const gcpProject = projectId || config.gcpProjectId || process.env.GOOGLE_CLOUD_PROJECT || 'tigerv0';
+        if (getApps().length === 0) {
+            initializeApp({ projectId: gcpProject });
+        }
+        this.db = getFirestore();
+        this.embeddings = new EmbeddingService({
+            projectId: gcpProject,
+            location: config.gcpLocation || 'europe-west1'
+        });
+        this.collectionPath = `${BRAIN_COLLECTION}/${agentId}/memories`;
+    }
+    async remember(content, tags = [], metadata) {
+        const embedding = await this.embeddings.embed(content);
+        const memory = {
+            agent: this.agentId,
+            content,
+            tags,
+            embedding,
+            metadata: metadata || {},
+            createdAt: Timestamp.now(),
+            updatedAt: Timestamp.now(),
+        };
+        const ref = await this.db.collection(this.collectionPath).add(memory);
+        return ref.id;
+    }
+    async recall(query, limit = 5, minScore = 0.5) {
+        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,
+                });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    async recallByTags(tags, limit = 10) {
+        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,
+        }));
+    }
+    async forget(memoryId) {
+        await this.db.collection(this.collectionPath).doc(memoryId).delete();
+    }
+    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,
+        }));
+    }
+    async stats() {
+        const snapshot = await this.db.collection(this.collectionPath).get();
+        const tagCounts = {};
+        for (const doc of snapshot.docs) {
+            const tags = doc.data().tags || [];
+            for (const tag of tags) {
+                tagCounts[tag] = (tagCounts[tag] || 0) + 1;
+            }
+        }
+        return {
+            count: snapshot.size,
+            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/dist/lib/biz/embeddings.js

@@ -27,7 +27,7 @@ export class EmbeddingService {
     static fromConfig() {
         const config = getConfig();
         const embeddingConfig = {
-            projectId: config.gcpProjectId || process.env.GOOGLE_PROJECT_ID || process.env.GCP_PROJECT_ID || '',
+            projectId: config.gcpProjectId || process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_PROJECT_ID || process.env.GCP_PROJECT_ID || '',
             location: config.gcpLocation || process.env.GOOGLE_LOCATION || 'europe-west1',
             model: process.env.EMBEDDING_MODEL || EMBEDDING_MODELS.TEXT_EMBEDDING_004,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {
@@ -21,15 +21,16 @@
   "dependencies": {
     "@anthropic-ai/claude-code": "^1.0.0",
     "@inquirer/prompts": "^8.1.0",
-    "commander": "^12.1.0"
+    "commander": "^12.1.0",
+    "firebase-admin": "^13.6.0"
   },
   "devDependencies": {
     "@types/node": "^22",
-    "typescript": "^5",
-    "vitest": "^2.1.8",
     "@vitest/coverage-v8": "^2.1.8",
+    "memfs": "^4.14.0",
     "msw": "^2.6.8",
-    "memfs": "^4.14.0"
+    "typescript": "^5",
+    "vitest": "^2.1.8"
   },
   "files": [
     "dist"
@@ -43,4 +44,4 @@
   "bugs": {
     "url": "https://github.com/simon-sfxecom/huskyv0/issues"
   }
-}
+}