@simonfestl/husky-cli 1.6.2 → 1.6.3

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/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.3",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {