@simonfestl/husky-cli 1.3.1 → 1.4.1

package/dist/commands/biz/tickets.js

@@ -126,6 +126,8 @@ ticketsCommand
     .description("Update ticket properties")
     .option("--status <status>", "New status (open, pending, solved)")
     .option("--priority <priority>", "New priority (low, normal, high, urgent)")
+    .option("-f, --field <field...>", "Set custom field (format: field_id=value or name=value)")
+    .option("--json", "Output as JSON")
     .action(async (id, options) => {
     try {
         const client = ZendeskClient.fromConfig();
@@ -134,13 +136,41 @@ ticketsCommand
             updates.status = options.status;
         if (options.priority)
             updates.priority = options.priority;
+        if (options.field && options.field.length > 0) {
+            updates.custom_fields = options.field.map((f) => {
+                const [key, ...valueParts] = f.split("=");
+                const value = valueParts.join("=");
+                const fieldId = parseInt(key, 10);
+                if (isNaN(fieldId)) {
+                    throw new Error(`Invalid field ID: ${key}. Use numeric field ID (e.g., 28080124674706=value)`);
+                }
+                if (value === "true")
+                    return { id: fieldId, value: true };
+                if (value === "false")
+                    return { id: fieldId, value: false };
+                if (value === "null" || value === "")
+                    return { id: fieldId, value: null };
+                const numValue = parseInt(value, 10);
+                if (!isNaN(numValue) && String(numValue) === value) {
+                    return { id: fieldId, value: numValue };
+                }
+                return { id: fieldId, value };
+            });
+        }
         if (Object.keys(updates).length === 0) {
-            console.error("Error: Provide --status or --priority");
+            console.error("Error: Provide --status, --priority, or --field");
             process.exit(1);
         }
         const ticket = await client.updateTicket(parseInt(id, 10), updates);
+        if (options.json) {
+            console.log(JSON.stringify(ticket, null, 2));
+            return;
+        }
         console.log(`✓ Updated ticket #${ticket.id}`);
         console.log(`  Status: ${ticket.status}, Priority: ${ticket.priority || "normal"}`);
+        if (updates.custom_fields) {
+            console.log(`  Custom fields updated: ${updates.custom_fields.length}`);
+        }
     }
     catch (error) {
         console.error("Error:", error.message);

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.1",
+  "version": "1.4.1",
   "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"
   }
-}
+}