@simonfestl/husky-cli 1.23.0 → 1.25.1

package/dist/commands/biz/gotess.js

@@ -317,4 +317,43 @@ gotessCommand
         process.exit(1);
     }
 });
+gotessCommand
+    .command("upload <file>")
+    .description("Upload invoice PDF to Gotess")
+    .option("-s, --sender <name>", "Sender/vendor name (required)")
+    .option("-a, --amount <amount>", "Invoice amount", parseFloat)
+    .option("-d, --date <date>", "Invoice date (YYYY-MM-DD)")
+    .option("--link <transactionId>", "Auto-link to transaction after upload")
+    .action(async (file, options) => {
+    try {
+        if (!options.sender) {
+            console.error("✗ Sender name is required (-s, --sender)");
+            process.exit(1);
+        }
+        const client = GotessClient.fromConfig();
+        console.log(`\n  📤 Uploading ${file}...`);
+        const invoice = await client.uploadInvoicePdf(file, {
+            senderName: options.sender,
+            amount: options.amount,
+            invoiceDate: options.date,
+        });
+        console.log(`  ✓ Invoice created: ${invoice.id}`);
+        console.log(`    Filename: ${invoice.filename}`);
+        console.log(`    Sender:   ${invoice.sender_name}`);
+        if (invoice.amount) {
+            console.log(`    Amount:   ${invoice.amount.toFixed(2)} EUR`);
+        }
+        // Auto-link if transaction ID provided
+        if (options.link) {
+            console.log(`\n  🔗 Linking to transaction ${options.link}...`);
+            await client.linkInvoice(options.link, invoice.id);
+            console.log(`  ✓ Linked successfully`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
 export default gotessCommand;

package/dist/commands/brain.js

@@ -698,6 +698,112 @@ brainCommand
         process.exit(1);
     }
 });
+// ============================================================================
+// Auto-Brain: Hook Integration Commands
+// ============================================================================
+brainCommand
+    .command("auto-recall <prompt>")
+    .description("Automatically search brain for relevant memories based on user prompt (for hook integration)")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("-l, --limit <num>", "Max results", "3")
+    .option("-m, --min-score <score>", "Minimum similarity score (0-1)", "0.6")
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--format <format>", "Output format (hint, json, markdown)", "hint")
+    .option("--quiet", "Suppress output if no results found")
+    .action(async (prompt, options) => {
+    try {
+        // Skip very short prompts (likely not meaningful queries)
+        if (prompt.length < 10) {
+            if (!options.quiet) {
+                console.log("");
+            }
+            return;
+        }
+        const brain = createBrain(options.agent, options.agentType);
+        const results = await brain.recall(prompt, parseInt(options.limit, 10), parseFloat(options.minScore));
+        if (results.length === 0) {
+            if (!options.quiet) {
+                console.log("");
+            }
+            return;
+        }
+        if (options.format === "json") {
+            console.log(JSON.stringify({ success: true, results }));
+            return;
+        }
+        if (options.format === "markdown") {
+            console.log("\n## 🧠 Brain Recall - Relevante Erinnerungen\n");
+            for (const r of results) {
+                const tags = r.memory.tags.length > 0 ? ` (Tags: ${r.memory.tags.join(", ")})` : "";
+                console.log(`- **[${(r.score * 100).toFixed(0)}%]** ${r.memory.content.slice(0, 150)}...${tags}`);
+            }
+            console.log("");
+            return;
+        }
+        // Default: hint format (compact, for hooks)
+        console.log("\n🧠 BRAIN RECALL - Relevante Erinnerungen:");
+        console.log("─".repeat(50));
+        for (const r of results) {
+            const tags = r.memory.tags.length > 0 ? ` [${r.memory.tags.join(", ")}]` : "";
+            console.log(`  [${(r.score * 100).toFixed(0)}%] ${r.memory.content.slice(0, 120)}...${tags}`);
+        }
+        console.log("─".repeat(50));
+        console.log("");
+    }
+    catch (error) {
+        // Fail silently for hook integration - don't block agent workflow
+        if (options.format === "json") {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+    }
+});
+brainCommand
+    .command("auto-remember <content>")
+    .description("Automatically store a learning/insight (for hook integration after task completion)")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--task-id <id>", "Associated task ID")
+    .option("-t, --tags <tags>", "Comma-separated tags", "auto-learning")
+    .option("--source <source>", "Source of learning (task, conversation, tool)", "task")
+    .option("--json", "Output as JSON")
+    .action(async (content, options) => {
+    try {
+        // Skip very short content
+        if (content.length < 20) {
+            if (options.json) {
+                console.log(JSON.stringify({ success: false, error: "Content too short" }));
+            }
+            return;
+        }
+        const brain = createBrain(options.agent, options.agentType);
+        const tags = options.tags.split(",").map((t) => t.trim());
+        // Add source and task info to tags
+        if (options.source && !tags.includes(options.source)) {
+            tags.push(options.source);
+        }
+        if (options.taskId) {
+            tags.push(`task:${options.taskId}`);
+        }
+        const id = await brain.remember(content, tags, {
+            source: options.source,
+            taskId: options.taskId,
+            autoGenerated: true,
+            timestamp: new Date().toISOString(),
+        });
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, id, tags }));
+        }
+        else {
+            console.log(`  ✓ Auto-Remember: ${id.slice(0, 8)}... [${tags.join(", ")}]`);
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: error.message }));
+        }
+        // Fail silently for hook integration
+    }
+});
 brainCommand
     .command("kb-stats <kb>")
     .description("Show statistics for a knowledge base")

package/dist/commands/chat.js

@@ -98,30 +98,54 @@ chatCommand
 });
 chatCommand
     .command("send <message>")
-    .description("Send a message as supervisor")
+    .description("Send a message (to Google Chat if --space provided, otherwise to dashboard chat)")
     .option("--task-id <id>", "Link to a specific task")
+    .option("--space <id>", "Google Chat space ID (e.g., spaces/ABC123 or DM space)")
+    .option("--thread <name>", "Reply in Google Chat thread")
     .action(async (message, options) => {
     const config = getConfig();
-    if (!config.apiUrl) {
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
         console.error("Error: API URL not configured.");
         process.exit(1);
     }
     try {
-        const res = await fetch(`${config.apiUrl}/api/chat/supervisor`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
-            },
-            body: JSON.stringify({
-                content: message,
-                taskId: options.taskId,
-            }),
-        });
-        if (!res.ok) {
-            throw new Error(`API error: ${res.status}`);
+        if (options.space) {
+            const res = await fetch(`${huskyApiUrl}/api/google-chat/send`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                },
+                body: JSON.stringify({
+                    text: message,
+                    spaceName: options.space,
+                    threadName: options.thread,
+                }),
+            });
+            if (!res.ok) {
+                const error = await res.text();
+                throw new Error(`API error: ${res.status} - ${error}`);
+            }
+            console.log("✅ Message sent to Google Chat.");
+        }
+        else {
+            const res = await fetch(`${huskyApiUrl}/api/chat/supervisor`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                },
+                body: JSON.stringify({
+                    content: message,
+                    taskId: options.taskId,
+                }),
+            });
+            if (!res.ok) {
+                throw new Error(`API error: ${res.status}`);
+            }
+            console.log("Message sent to dashboard chat.");
         }
-        console.log("Message sent.");
     }
     catch (error) {
         console.error("Error sending message:", error);

package/dist/commands/config.d.ts

@@ -43,6 +43,7 @@ interface Config {
     wattizPassword?: string;
     wattizBaseUrl?: string;
     wattizLanguage?: string;
+    gcsBucket?: string;
 }
 export declare function getConfig(): Config;
 export declare function saveConfig(config: Config): void;

package/dist/lib/biz/gotess.d.ts

@@ -81,6 +81,19 @@ export declare class GotessClient {
     }): Promise<GotessInvoice[]>;
     linkInvoice(transactionId: string, invoiceId: string): Promise<void>;
     markProofless(transactionId: string): Promise<void>;
+    /**
+     * Create an invoice record in Gotess
+     * Used for auto-upload from invoice extraction
+     */
+    createInvoice(invoice: {
+        invoiceDate?: string;
+        amount?: number;
+        senderName: string;
+        filename: string;
+        gcsUri?: string;
+        s3Uri?: string;
+        bookId?: string;
+    }): Promise<GotessInvoice>;
     autoMatch(bookId?: string): Promise<{
         matched: Array<{
             transaction: GotessTransaction;
@@ -93,5 +106,19 @@ export declare class GotessClient {
     setBookId(id: string): void;
     getAccessToken(): string | undefined;
     getBookId(): string | undefined;
+    /**
+     * Upload a PDF file to Supabase Storage and create invoice record
+     * This uploads directly to Gotess's storage system
+     */
+    uploadInvoicePdf(filePath: string, options: {
+        invoiceDate?: string;
+        amount?: number;
+        senderName: string;
+        bookId?: string;
+    }): Promise<GotessInvoice>;
+    /**
+     * Get signed URL for private file access
+     */
+    getSignedUrl(storagePath: string, expiresIn?: number): Promise<string>;
 }
 export default GotessClient;

package/dist/lib/biz/gotess.js

@@ -137,6 +137,34 @@ export class GotessClient {
         if (!res.ok)
             throw new Error('Failed to mark proofless');
     }
+    /**
+     * Create an invoice record in Gotess
+     * Used for auto-upload from invoice extraction
+     */
+    async createInvoice(invoice) {
+        const bid = invoice.bookId || this.bookId;
+        if (!bid)
+            throw new Error('Book ID required');
+        const body = {
+            invoice_date: invoice.invoiceDate,
+            amount: invoice.amount,
+            sender_name: invoice.senderName,
+            filename: invoice.filename,
+            s3_uri: invoice.s3Uri || invoice.gcsUri, // Use GCS URI as s3_uri field
+            book_id: bid,
+        };
+        const res = await fetch(`${SUPABASE_URL}/rest/v1/Invoices`, {
+            method: 'POST',
+            headers: { ...this.headers, 'Prefer': 'return=representation' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.message || 'Failed to create invoice');
+        }
+        const data = await res.json();
+        return Array.isArray(data) ? data[0] : data;
+    }
     async autoMatch(bookId) {
         const bid = bookId || this.bookId;
         if (!bid)
@@ -198,5 +226,65 @@ export class GotessClient {
     getBookId() {
         return this.bookId;
     }
+    /**
+     * Upload a PDF file to Supabase Storage and create invoice record
+     * This uploads directly to Gotess's storage system
+     */
+    async uploadInvoicePdf(filePath, options) {
+        const bid = options.bookId || this.bookId;
+        if (!bid)
+            throw new Error('Book ID required');
+        // Read file
+        const fs = await import('fs');
+        const path = await import('path');
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const fileBuffer = fs.readFileSync(filePath);
+        const filename = path.basename(filePath);
+        // Generate unique storage path
+        const timestamp = Date.now();
+        const storagePath = `invoices/${bid}/${timestamp}-${filename}`;
+        // Upload to Supabase Storage
+        const uploadRes = await fetch(`${SUPABASE_URL}/storage/v1/object/invoices/${storagePath}`, {
+            method: 'POST',
+            headers: {
+                ...this.headers,
+                'Content-Type': 'application/pdf',
+            },
+            body: fileBuffer,
+        });
+        if (!uploadRes.ok) {
+            const err = await uploadRes.json().catch(() => ({}));
+            throw new Error(err.message || `Upload failed: ${uploadRes.status}`);
+        }
+        // Get the public URL
+        const s3Uri = `${SUPABASE_URL}/storage/v1/object/public/invoices/${storagePath}`;
+        // Create invoice record
+        const invoice = await this.createInvoice({
+            invoiceDate: options.invoiceDate,
+            amount: options.amount,
+            senderName: options.senderName,
+            filename,
+            s3Uri,
+            bookId: bid,
+        });
+        return invoice;
+    }
+    /**
+     * Get signed URL for private file access
+     */
+    async getSignedUrl(storagePath, expiresIn = 3600) {
+        const res = await fetch(`${SUPABASE_URL}/storage/v1/object/sign/invoices/${storagePath}`, {
+            method: 'POST',
+            headers: this.headers,
+            body: JSON.stringify({ expiresIn }),
+        });
+        if (!res.ok) {
+            throw new Error('Failed to generate signed URL');
+        }
+        const data = await res.json();
+        return `${SUPABASE_URL}/storage/v1${data.signedURL}`;
+    }
 }
 export default GotessClient;

package/dist/lib/biz/index.d.ts

@@ -11,3 +11,4 @@ export type { EmbeddingConfig, EmbeddingResult } from './embeddings.js';
 export * from './billbee-types.js';
 export * from './zendesk-types.js';
 export * from './seatable-types.js';
+export { GotessClient } from './gotess.js';

package/dist/lib/biz/index.js

@@ -9,3 +9,4 @@ export { EmbeddingService, EMBEDDING_MODELS } from './embeddings.js';
 export * from './billbee-types.js';
 export * from './zendesk-types.js';
 export * from './seatable-types.js';
+export { GotessClient } from './gotess.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "1.23.0",
+  "version": "1.25.1",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {
@@ -20,13 +20,16 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-code": "^1.0.0",
+    "@google-cloud/storage": "^7.14.0",
     "@google-cloud/vertexai": "^1.10.0",
     "@google/generative-ai": "^0.24.1",
     "@inquirer/prompts": "^8.1.0",
+    "@types/uuid": "^10.0.0",
     "commander": "^12.1.0",
     "firebase-admin": "^13.6.0",
     "playwright": "^1.57.0",
     "sharp": "^0.34.5",
+    "uuid": "^13.0.0",
     "youtube-transcript": "^1.2.1",
     "zod": "^4.3.5"
   },