@simonfestl/husky-cli 1.6.2 → 1.6.4

package/dist/commands/chat.js

@@ -842,6 +842,55 @@ chatCommand
     }
 });
 // ============================================
+// GOOGLE CHAT SPACES
+// ============================================
+chatCommand
+    .command("spaces")
+    .description("List available Google Chat spaces")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/spaces`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        if (!data.spaces || data.spaces.length === 0) {
+            console.log("No Google Chat spaces found.");
+            console.log("Make sure the Husky bot is added to at least one space.");
+            return;
+        }
+        console.log("\n  Google Chat Spaces");
+        console.log("  " + "─".repeat(60));
+        for (const space of data.spaces) {
+            const isDefault = space.name === data.defaultSpace ? " (default)" : "";
+            const typeIcon = space.type === "SPACE" ? "🏠" : space.type === "GROUP_CHAT" ? "👥" : "💬";
+            console.log(`  ${typeIcon} ${space.displayName || "(unnamed)"}${isDefault}`);
+            console.log(`     ID: ${space.name}`);
+            console.log("");
+        }
+        console.log("  Use --space <ID> with chat commands, e.g.:");
+        console.log(`  husky chat ask --space "${data.spaces[0]?.name}" "Your question"`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error fetching spaces:", error);
+        process.exit(1);
+    }
+});
+// ============================================
 // REVIEW COMMANDS (kept for backwards compatibility)
 // ============================================
 chatCommand

package/dist/commands/workflow.js

@@ -11,11 +11,11 @@ function ensureConfig() {
     }
     return config;
 }
-// husky workflow list
 workflowCommand
     .command("list")
     .description("List all workflows")
     .option("--value-stream <valueStream>", "Filter by value stream")
+    .option("-l, --limit <num>", "Max results")
     .option("--json", "Output as JSON")
     .action(async (options) => {
     const config = ensureConfig();
@@ -30,7 +30,10 @@ workflowCommand
         if (!res.ok) {
             throw new Error(`API error: ${res.status}`);
         }
-        const workflows = await res.json();
+        let workflows = await res.json();
+        if (options.limit) {
+            workflows = workflows.slice(0, parseInt(options.limit, 10));
+        }
         if (options.json) {
             console.log(JSON.stringify(workflows, null, 2));
         }

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/dist/lib/biz/qdrant.d.ts

@@ -49,5 +49,13 @@ export declare class QdrantClient {
     getPoint(collectionName: string, id: string | number): Promise<Point | null>;
     deletePoints(collectionName: string, ids: (string | number)[]): Promise<void>;
     count(collectionName: string): Promise<number>;
+    scroll(collectionName: string, options?: {
+        filter?: Record<string, unknown>;
+        limit?: number;
+        with_payload?: boolean;
+    }): Promise<Array<{
+        id: string | number;
+        payload: Record<string, unknown>;
+    }>>;
 }
 export default QdrantClient;

package/dist/lib/biz/qdrant.js

@@ -157,5 +157,19 @@ export class QdrantClient {
         const info = await this.getCollection(collectionName);
         return info.pointsCount;
     }
+    async scroll(collectionName, options = {}) {
+        const response = await this.request(`/collections/${collectionName}/points/scroll`, {
+            method: 'POST',
+            body: JSON.stringify({
+                filter: options.filter,
+                limit: options.limit || 50,
+                with_payload: options.with_payload ?? true,
+            }),
+        });
+        return response.result.points.map(p => ({
+            id: p.id,
+            payload: p.payload || {},
+        }));
+    }
 }
 export default QdrantClient;

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

@@ -0,0 +1,98 @@
+/**
+ * SOP (Standard Operating Procedure) Service
+ *
+ * Manages SOPs in Qdrant with semantic search capabilities.
+ * SOPs are auto-generated from resolved ticket patterns and can be
+ * approved/deprecated by humans.
+ */
+export declare const SOP_STATUSES: readonly ["draft", "approved", "deprecated"];
+export type SOPStatus = typeof SOP_STATUSES[number];
+export interface SOPStep {
+    order: number;
+    action: string;
+    description: string;
+    tool?: string;
+    required?: boolean;
+    conditions?: string;
+}
+export interface SOP {
+    id: string;
+    title: string;
+    description: string;
+    trigger: string;
+    category: string;
+    steps: SOPStep[];
+    source_tickets: number[];
+    status: SOPStatus;
+    tags: string[];
+    created_at: string;
+    updated_at: string;
+    approved_by?: string;
+    approved_at?: string;
+    deprecated_by?: string;
+    deprecated_at?: string;
+    version: number;
+    confidence_score?: number;
+}
+export interface CreateSOPInput {
+    title: string;
+    description: string;
+    trigger: string;
+    category: string;
+    steps: SOPStep[];
+    source_tickets?: number[];
+    tags?: string[];
+    confidence_score?: number;
+}
+export interface UpdateSOPInput {
+    title?: string;
+    description?: string;
+    trigger?: string;
+    category?: string;
+    steps?: SOPStep[];
+    tags?: string[];
+}
+export interface SOPSearchResult {
+    sop: SOP;
+    score: number;
+}
+export declare class SOPService {
+    private qdrant;
+    private embeddings;
+    constructor();
+    create(input: CreateSOPInput): Promise<SOP>;
+    get(id: string): Promise<SOP | null>;
+    update(id: string, input: UpdateSOPInput): Promise<SOP | null>;
+    approve(id: string, approver: string): Promise<SOP | null>;
+    deprecate(id: string, deprecator: string): Promise<SOP | null>;
+    delete(id: string): Promise<void>;
+    list(options?: {
+        status?: SOPStatus;
+        category?: string;
+        limit?: number;
+    }): Promise<SOP[]>;
+    search(query: string, options?: {
+        limit?: number;
+        status?: SOPStatus;
+        minScore?: number;
+    }): Promise<SOPSearchResult[]>;
+    findByTrigger(trigger: string, options?: {
+        status?: SOPStatus;
+        minScore?: number;
+    }): Promise<SOPSearchResult | null>;
+    getByCategory(category: string, status?: SOPStatus): Promise<SOP[]>;
+    getCategories(): Promise<{
+        category: string;
+        count: number;
+    }[]>;
+    stats(): Promise<{
+        total: number;
+        byStatus: Record<SOPStatus, number>;
+        byCategory: Record<string, number>;
+    }>;
+    private buildEmbeddingText;
+    private sopToPayload;
+    private payloadToSOP;
+    private scrollPoints;
+}
+export default SOPService;

package/dist/lib/biz/sop.js

@@ -0,0 +1,307 @@
+/**
+ * SOP (Standard Operating Procedure) Service
+ *
+ * Manages SOPs in Qdrant with semantic search capabilities.
+ * SOPs are auto-generated from resolved ticket patterns and can be
+ * approved/deprecated by humans.
+ */
+import { QdrantClient } from './qdrant.js';
+import { EmbeddingService } from './embeddings.js';
+import { v4 as uuidv4 } from 'uuid';
+// ============================================================================
+// Types
+// ============================================================================
+export const SOP_STATUSES = ['draft', 'approved', 'deprecated'];
+// ============================================================================
+// Constants
+// ============================================================================
+const SOP_COLLECTION = 'knowledge';
+const VECTOR_DIM = 768;
+// ============================================================================
+// SOP Service
+// ============================================================================
+export class SOPService {
+    qdrant;
+    embeddings;
+    constructor() {
+        this.qdrant = QdrantClient.fromConfig();
+        this.embeddings = EmbeddingService.fromConfig();
+    }
+    async create(input) {
+        const id = `sop_${uuidv4().slice(0, 8)}`;
+        const now = new Date().toISOString();
+        const sop = {
+            id,
+            title: input.title,
+            description: input.description,
+            trigger: input.trigger,
+            category: input.category,
+            steps: input.steps.map((s, i) => ({
+                ...s,
+                order: s.order || i + 1,
+                required: s.required ?? true,
+            })),
+            source_tickets: input.source_tickets || [],
+            status: 'draft',
+            tags: input.tags || [],
+            created_at: now,
+            updated_at: now,
+            version: 1,
+            confidence_score: input.confidence_score,
+        };
+        const embeddingText = this.buildEmbeddingText(sop);
+        const vector = await this.embeddings.embed(embeddingText);
+        await this.qdrant.upsertOne(SOP_COLLECTION, id, vector, {
+            type: 'sop',
+            ...this.sopToPayload(sop),
+        });
+        return sop;
+    }
+    async get(id) {
+        const point = await this.qdrant.getPoint(SOP_COLLECTION, id);
+        if (!point || !point.payload)
+            return null;
+        const payload = point.payload;
+        if (payload.type !== 'sop')
+            return null;
+        return this.payloadToSOP(payload);
+    }
+    async update(id, input) {
+        const existing = await this.get(id);
+        if (!existing)
+            return null;
+        const now = new Date().toISOString();
+        const updated = {
+            ...existing,
+            title: input.title ?? existing.title,
+            description: input.description ?? existing.description,
+            trigger: input.trigger ?? existing.trigger,
+            category: input.category ?? existing.category,
+            steps: input.steps ?? existing.steps,
+            tags: input.tags ?? existing.tags,
+            updated_at: now,
+            version: existing.version + 1,
+        };
+        const embeddingText = this.buildEmbeddingText(updated);
+        const vector = await this.embeddings.embed(embeddingText);
+        await this.qdrant.upsertOne(SOP_COLLECTION, id, vector, {
+            type: 'sop',
+            ...this.sopToPayload(updated),
+        });
+        return updated;
+    }
+    async approve(id, approver) {
+        const existing = await this.get(id);
+        if (!existing)
+            return null;
+        if (existing.status !== 'draft') {
+            throw new Error(`Cannot approve SOP with status '${existing.status}'. Only draft SOPs can be approved.`);
+        }
+        const now = new Date().toISOString();
+        const updated = {
+            ...existing,
+            status: 'approved',
+            approved_by: approver,
+            approved_at: now,
+            updated_at: now,
+        };
+        const embeddingText = this.buildEmbeddingText(updated);
+        const vector = await this.embeddings.embed(embeddingText);
+        await this.qdrant.upsertOne(SOP_COLLECTION, id, vector, {
+            type: 'sop',
+            ...this.sopToPayload(updated),
+        });
+        return updated;
+    }
+    async deprecate(id, deprecator) {
+        const existing = await this.get(id);
+        if (!existing)
+            return null;
+        const now = new Date().toISOString();
+        const updated = {
+            ...existing,
+            status: 'deprecated',
+            deprecated_by: deprecator,
+            deprecated_at: now,
+            updated_at: now,
+        };
+        const embeddingText = this.buildEmbeddingText(updated);
+        const vector = await this.embeddings.embed(embeddingText);
+        await this.qdrant.upsertOne(SOP_COLLECTION, id, vector, {
+            type: 'sop',
+            ...this.sopToPayload(updated),
+        });
+        return updated;
+    }
+    async delete(id) {
+        await this.qdrant.deletePoints(SOP_COLLECTION, [id]);
+    }
+    async list(options = {}) {
+        const limit = options.limit || 50;
+        const mustConditions = [
+            { key: 'type', match: { value: 'sop' } }
+        ];
+        if (options.status) {
+            mustConditions.push({ key: 'status', match: { value: options.status } });
+        }
+        if (options.category) {
+            mustConditions.push({ key: 'category', match: { value: options.category } });
+        }
+        const response = await this.scrollPoints(SOP_COLLECTION, {
+            filter: { must: mustConditions },
+            limit,
+            with_payload: true,
+        });
+        return response
+            .map(p => this.payloadToSOP(p.payload))
+            .filter((sop) => sop !== null);
+    }
+    async search(query, options = {}) {
+        const limit = options.limit || 5;
+        const minScore = options.minScore || 0.5;
+        const vector = await this.embeddings.embed(query);
+        const mustConditions = [
+            { key: 'type', match: { value: 'sop' } }
+        ];
+        if (options.status) {
+            mustConditions.push({ key: 'status', match: { value: options.status } });
+        }
+        const results = await this.qdrant.search(SOP_COLLECTION, vector, limit, {
+            filter: { must: mustConditions },
+            scoreThreshold: minScore,
+        });
+        return results
+            .map(r => {
+            const sop = this.payloadToSOP(r.payload);
+            if (!sop)
+                return null;
+            return { sop, score: r.score };
+        })
+            .filter((r) => r !== null);
+    }
+    async findByTrigger(trigger, options = {}) {
+        const results = await this.search(trigger, {
+            limit: 1,
+            status: options.status || 'approved',
+            minScore: options.minScore || 0.7,
+        });
+        return results[0] || null;
+    }
+    async getByCategory(category, status) {
+        return this.list({ category, status });
+    }
+    async getCategories() {
+        const sops = await this.list();
+        const categoryMap = new Map();
+        for (const sop of sops) {
+            const count = categoryMap.get(sop.category) || 0;
+            categoryMap.set(sop.category, count + 1);
+        }
+        return Array.from(categoryMap.entries())
+            .map(([category, count]) => ({ category, count }))
+            .sort((a, b) => b.count - a.count);
+    }
+    async stats() {
+        const sops = await this.list({ limit: 1000 });
+        const byStatus = {
+            draft: 0,
+            approved: 0,
+            deprecated: 0,
+        };
+        const byCategory = {};
+        for (const sop of sops) {
+            byStatus[sop.status]++;
+            byCategory[sop.category] = (byCategory[sop.category] || 0) + 1;
+        }
+        return {
+            total: sops.length,
+            byStatus,
+            byCategory,
+        };
+    }
+    buildEmbeddingText(sop) {
+        const stepsText = sop.steps
+            .map(s => `Step ${s.order}: ${s.action} - ${s.description}`)
+            .join('\n');
+        return `${sop.title}\n${sop.description}\nTrigger: ${sop.trigger}\nCategory: ${sop.category}\n${stepsText}`;
+    }
+    sopToPayload(sop) {
+        return {
+            id: sop.id,
+            title: sop.title,
+            description: sop.description,
+            trigger: sop.trigger,
+            category: sop.category,
+            steps: JSON.stringify(sop.steps),
+            source_tickets: sop.source_tickets,
+            status: sop.status,
+            tags: sop.tags,
+            created_at: sop.created_at,
+            updated_at: sop.updated_at,
+            approved_by: sop.approved_by || null,
+            approved_at: sop.approved_at || null,
+            deprecated_by: sop.deprecated_by || null,
+            deprecated_at: sop.deprecated_at || null,
+            version: sop.version,
+            confidence_score: sop.confidence_score || null,
+        };
+    }
+    payloadToSOP(payload) {
+        if (!payload || payload.type !== 'sop')
+            return null;
+        let steps = [];
+        try {
+            if (typeof payload.steps === 'string') {
+                steps = JSON.parse(payload.steps);
+            }
+            else if (Array.isArray(payload.steps)) {
+                steps = payload.steps;
+            }
+        }
+        catch {
+            steps = [];
+        }
+        return {
+            id: String(payload.id),
+            title: String(payload.title || ''),
+            description: String(payload.description || ''),
+            trigger: String(payload.trigger || ''),
+            category: String(payload.category || 'general'),
+            steps,
+            source_tickets: payload.source_tickets || [],
+            status: payload.status || 'draft',
+            tags: payload.tags || [],
+            created_at: String(payload.created_at || new Date().toISOString()),
+            updated_at: String(payload.updated_at || new Date().toISOString()),
+            approved_by: payload.approved_by ? String(payload.approved_by) : undefined,
+            approved_at: payload.approved_at ? String(payload.approved_at) : undefined,
+            deprecated_by: payload.deprecated_by ? String(payload.deprecated_by) : undefined,
+            deprecated_at: payload.deprecated_at ? String(payload.deprecated_at) : undefined,
+            version: Number(payload.version) || 1,
+            confidence_score: payload.confidence_score ? Number(payload.confidence_score) : undefined,
+        };
+    }
+    async scrollPoints(collection, options) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const qdrantAny = this.qdrant;
+        try {
+            const response = await qdrantAny.request(`/collections/${collection}/points/scroll`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    filter: options.filter,
+                    limit: options.limit || 50,
+                    with_payload: options.with_payload ?? true,
+                }),
+            });
+            return response.result.points.map((p) => ({
+                id: p.id,
+                payload: p.payload || {},
+            }));
+        }
+        catch (error) {
+            console.error('Scroll failed:', error);
+            return [];
+        }
+    }
+}
+export default SOPService;

package/package.json

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