@simonfestl/husky-cli 1.27.1 → 1.29.0

package/dist/lib/biz/pattern-detection.js

@@ -0,0 +1,205 @@
+import { QdrantClient } from './qdrant.js';
+import { EmbeddingService } from './embeddings.js';
+import { ResolvedTicketsService } from './resolved-tickets.js';
+import { SOPService } from './sop.js';
+// ============================================================================
+// Pattern Detection Service
+// ============================================================================
+export class PatternDetectionService {
+    qdrant;
+    embeddings;
+    resolvedTickets;
+    sopService;
+    constructor() {
+        this.qdrant = QdrantClient.fromConfig();
+        this.embeddings = EmbeddingService.fromConfig();
+        this.resolvedTickets = new ResolvedTicketsService();
+        this.sopService = new SOPService();
+    }
+    async detectPatterns(options = {}) {
+        const minClusterSize = options.minClusterSize || 3;
+        const similarityThreshold = options.similarityThreshold || 0.75;
+        const limit = options.limit || 500;
+        const tickets = await this.resolvedTickets.list({
+            category: options.category,
+            outcome: 'positive',
+            limit,
+        });
+        if (tickets.length < minClusterSize) {
+            return {
+                total_tickets: tickets.length,
+                clusters: [],
+                unmatched_tickets: tickets,
+                suggestions: [],
+            };
+        }
+        const clusters = await this.clusterTickets(tickets, similarityThreshold, minClusterSize);
+        const matchedTicketIds = new Set();
+        for (const cluster of clusters) {
+            matchedTicketIds.add(cluster.representative.id);
+            for (const member of cluster.members) {
+                matchedTicketIds.add(member.id);
+            }
+        }
+        const unmatched = tickets.filter(t => !matchedTicketIds.has(t.id));
+        const suggestions = [];
+        for (const cluster of clusters) {
+            const suggestion = this.generateSOPSuggestion(cluster);
+            cluster.suggested_sop = suggestion;
+            suggestions.push(suggestion);
+        }
+        return {
+            total_tickets: tickets.length,
+            clusters,
+            unmatched_tickets: unmatched,
+            suggestions,
+        };
+    }
+    async createSOPFromCluster(clusterId, analysis) {
+        const cluster = analysis.clusters.find(c => c.id === clusterId);
+        if (!cluster || !cluster.suggested_sop) {
+            return null;
+        }
+        const sop = await this.sopService.create({
+            title: cluster.suggested_sop.title,
+            description: cluster.suggested_sop.description,
+            trigger: cluster.suggested_sop.trigger,
+            category: cluster.suggested_sop.category,
+            steps: cluster.suggested_sop.steps,
+            source_tickets: cluster.suggested_sop.source_tickets,
+            tags: ['auto-generated', 'pattern-detected'],
+            confidence_score: cluster.suggested_sop.confidence_score,
+        });
+        return sop.id;
+    }
+    async findSimilarTickets(ticketId, limit = 5) {
+        const ticket = await this.resolvedTickets.get(ticketId);
+        if (!ticket)
+            return [];
+        const results = await this.resolvedTickets.findSimilarProblems(ticket.problem, {
+            limit: limit + 1,
+            minScore: 0.5,
+        });
+        return results
+            .filter(r => r.ticket.id !== ticketId)
+            .slice(0, limit)
+            .map(r => ({
+            ticket: r.ticket,
+            similarity: r.score,
+        }));
+    }
+    async clusterTickets(tickets, threshold, minSize) {
+        const clusters = [];
+        const assigned = new Set();
+        const sortedTickets = [...tickets].sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+        for (const ticket of sortedTickets) {
+            if (assigned.has(ticket.id))
+                continue;
+            const similar = await this.resolvedTickets.findSimilarProblems(ticket.problem, {
+                limit: 20,
+                minScore: threshold,
+                onlyPositive: true,
+            });
+            const clusterMembers = similar
+                .filter(r => !assigned.has(r.ticket.id) && r.ticket.id !== ticket.id)
+                .map(r => r.ticket);
+            if (clusterMembers.length + 1 >= minSize) {
+                assigned.add(ticket.id);
+                for (const member of clusterMembers) {
+                    assigned.add(member.id);
+                }
+                const allMembers = [ticket, ...clusterMembers];
+                const avgSimilarity = similar.length > 0
+                    ? similar.reduce((sum, r) => sum + r.score, 0) / similar.length
+                    : 1;
+                clusters.push({
+                    id: `cluster_${ticket.ticket_id}_${clusters.length}`,
+                    representative: ticket,
+                    members: clusterMembers,
+                    similarity: avgSimilarity,
+                    problem_category: ticket.problem_category,
+                    common_steps: this.findCommonSteps(allMembers),
+                });
+            }
+        }
+        return clusters.sort((a, b) => (b.members.length + 1) - (a.members.length + 1));
+    }
+    findCommonSteps(tickets) {
+        if (tickets.length === 0)
+            return [];
+        const stepCounts = new Map();
+        for (const ticket of tickets) {
+            for (const step of ticket.resolution.steps) {
+                const key = step.action.toLowerCase().trim();
+                const existing = stepCounts.get(key);
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    stepCounts.set(key, { step, count: 1 });
+                }
+            }
+        }
+        const threshold = Math.ceil(tickets.length * 0.5);
+        const commonSteps = Array.from(stepCounts.values())
+            .filter(({ count }) => count >= threshold)
+            .sort((a, b) => {
+            const orderDiff = (a.step.order || 0) - (b.step.order || 0);
+            if (orderDiff !== 0)
+                return orderDiff;
+            return b.count - a.count;
+        })
+            .map(({ step }, index) => ({
+            ...step,
+            order: index + 1,
+        }));
+        return commonSteps;
+    }
+    generateSOPSuggestion(cluster) {
+        const allTickets = [cluster.representative, ...cluster.members];
+        const ticketCount = allTickets.length;
+        const title = `Handle: ${cluster.representative.problem.slice(0, 50)}`;
+        const description = [
+            `Auto-generated from ${ticketCount} similar resolved tickets.`,
+            `Common problem pattern in category: ${cluster.problem_category}.`,
+            `Average resolution similarity: ${(cluster.similarity * 100).toFixed(0)}%.`,
+        ].join(' ');
+        const trigger = cluster.representative.problem;
+        const steps = cluster.common_steps.map((step, index) => ({
+            order: index + 1,
+            action: step.action,
+            description: step.description,
+            tool: step.tool_used,
+            required: true,
+        }));
+        if (steps.length === 0) {
+            const repSteps = cluster.representative.resolution.steps;
+            for (const step of repSteps) {
+                steps.push({
+                    order: step.order,
+                    action: step.action,
+                    description: step.description,
+                    tool: step.tool_used,
+                    required: true,
+                });
+            }
+        }
+        const confidenceFactors = [
+            ticketCount >= 5 ? 0.3 : ticketCount >= 3 ? 0.2 : 0.1,
+            cluster.similarity * 0.3,
+            steps.length >= 3 ? 0.2 : 0.1,
+            cluster.common_steps.length > 0 ? 0.2 : 0,
+        ];
+        const confidence_score = Math.min(1, confidenceFactors.reduce((a, b) => a + b, 0));
+        return {
+            title,
+            description,
+            trigger,
+            category: cluster.problem_category,
+            steps,
+            confidence_score,
+            source_tickets: allTickets.map(t => t.ticket_id),
+        };
+    }
+}
+export default PatternDetectionService;

package/dist/lib/biz/resolved-tickets.d.ts

@@ -0,0 +1,86 @@
+export declare const RESOLUTION_OUTCOMES: readonly ["positive", "negative", "neutral", "escalated"];
+export type ResolutionOutcome = typeof RESOLUTION_OUTCOMES[number];
+export interface ResolutionStep {
+    order: number;
+    action: string;
+    description: string;
+    tool_used?: string;
+    duration_seconds?: number;
+    success?: boolean;
+}
+export interface ResolvedTicket {
+    id: string;
+    ticket_id: number;
+    problem: string;
+    problem_category: string;
+    resolution: {
+        outcome: ResolutionOutcome;
+        summary: string;
+        steps: ResolutionStep[];
+        sop_reference?: string;
+    };
+    agent_id: string;
+    files?: string[];
+    tags: string[];
+    created_at: string;
+    customer_satisfaction?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateResolvedTicketInput {
+    ticket_id: number;
+    problem: string;
+    problem_category: string;
+    outcome: ResolutionOutcome;
+    summary: string;
+    steps: ResolutionStep[];
+    sop_reference?: string;
+    agent_id: string;
+    files?: string[];
+    tags?: string[];
+    customer_satisfaction?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ResolvedTicketSearchResult {
+    ticket: ResolvedTicket;
+    score: number;
+}
+export declare class ResolvedTicketsService {
+    private qdrant;
+    private embeddings;
+    constructor();
+    log(input: CreateResolvedTicketInput): Promise<ResolvedTicket>;
+    get(id: string): Promise<ResolvedTicket | null>;
+    getByTicketId(ticketId: number): Promise<ResolvedTicket | null>;
+    search(query: string, options?: {
+        limit?: number;
+        category?: string;
+        outcome?: ResolutionOutcome;
+        minScore?: number;
+    }): Promise<ResolvedTicketSearchResult[]>;
+    list(options?: {
+        category?: string;
+        outcome?: ResolutionOutcome;
+        agent_id?: string;
+        limit?: number;
+    }): Promise<ResolvedTicket[]>;
+    findSimilarProblems(problem: string, options?: {
+        limit?: number;
+        minScore?: number;
+        onlyPositive?: boolean;
+    }): Promise<ResolvedTicketSearchResult[]>;
+    getCategories(): Promise<{
+        category: string;
+        count: number;
+    }[]>;
+    stats(): Promise<{
+        total: number;
+        byOutcome: Record<ResolutionOutcome, number>;
+        byCategory: Record<string, number>;
+        avgSteps: number;
+    }>;
+    delete(id: string): Promise<void>;
+    private buildEmbeddingText;
+    private ticketToPayload;
+    private payloadToTicket;
+}
+export default ResolvedTicketsService;

package/dist/lib/biz/resolved-tickets.js

@@ -0,0 +1,250 @@
+import { QdrantClient } from './qdrant.js';
+import { EmbeddingService } from './embeddings.js';
+import { v4 as uuidv4 } from 'uuid';
+// ============================================================================
+// Types
+// ============================================================================
+export const RESOLUTION_OUTCOMES = ['positive', 'negative', 'neutral', 'escalated'];
+// ============================================================================
+// Constants
+// ============================================================================
+const RESOLVED_COLLECTION = 'tickets_resolved';
+// ============================================================================
+// Resolved Tickets Service
+// ============================================================================
+export class ResolvedTicketsService {
+    qdrant;
+    embeddings;
+    constructor() {
+        this.qdrant = QdrantClient.fromConfig();
+        this.embeddings = EmbeddingService.fromConfig();
+    }
+    async log(input) {
+        const id = `rt_${input.ticket_id}_${uuidv4().slice(0, 6)}`;
+        const now = new Date().toISOString();
+        const ticket = {
+            id,
+            ticket_id: input.ticket_id,
+            problem: input.problem,
+            problem_category: input.problem_category,
+            resolution: {
+                outcome: input.outcome,
+                summary: input.summary,
+                steps: input.steps.map((s, i) => ({
+                    ...s,
+                    order: s.order || i + 1,
+                })),
+                sop_reference: input.sop_reference,
+            },
+            agent_id: input.agent_id,
+            files: input.files || [],
+            tags: input.tags || [],
+            created_at: now,
+            customer_satisfaction: input.customer_satisfaction,
+            metadata: input.metadata,
+        };
+        const embeddingText = this.buildEmbeddingText(ticket);
+        const vector = await this.embeddings.embed(embeddingText);
+        await this.qdrant.upsertOne(RESOLVED_COLLECTION, id, vector, {
+            type: 'resolved_ticket',
+            ...this.ticketToPayload(ticket),
+        });
+        return ticket;
+    }
+    async get(id) {
+        const point = await this.qdrant.getPoint(RESOLVED_COLLECTION, id);
+        if (!point || !point.payload)
+            return null;
+        const payload = point.payload;
+        if (payload.type !== 'resolved_ticket')
+            return null;
+        return this.payloadToTicket(payload);
+    }
+    async getByTicketId(ticketId) {
+        const results = await this.qdrant.scroll(RESOLVED_COLLECTION, {
+            filter: {
+                must: [
+                    { key: 'type', match: { value: 'resolved_ticket' } },
+                    { key: 'ticket_id', match: { value: ticketId } },
+                ],
+            },
+            limit: 1,
+            with_payload: true,
+        });
+        if (results.length === 0)
+            return null;
+        return this.payloadToTicket(results[0].payload);
+    }
+    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: 'resolved_ticket' } }
+        ];
+        if (options.category) {
+            mustConditions.push({ key: 'problem_category', match: { value: options.category } });
+        }
+        if (options.outcome) {
+            mustConditions.push({ key: 'outcome', match: { value: options.outcome } });
+        }
+        const results = await this.qdrant.search(RESOLVED_COLLECTION, vector, limit, {
+            filter: { must: mustConditions },
+            scoreThreshold: minScore,
+        });
+        return results
+            .map(r => {
+            const ticket = this.payloadToTicket(r.payload);
+            if (!ticket)
+                return null;
+            return { ticket, score: r.score };
+        })
+            .filter((r) => r !== null);
+    }
+    async list(options = {}) {
+        const limit = options.limit || 50;
+        const mustConditions = [
+            { key: 'type', match: { value: 'resolved_ticket' } }
+        ];
+        if (options.category) {
+            mustConditions.push({ key: 'problem_category', match: { value: options.category } });
+        }
+        if (options.outcome) {
+            mustConditions.push({ key: 'outcome', match: { value: options.outcome } });
+        }
+        if (options.agent_id) {
+            mustConditions.push({ key: 'agent_id', match: { value: options.agent_id } });
+        }
+        const results = await this.qdrant.scroll(RESOLVED_COLLECTION, {
+            filter: { must: mustConditions },
+            limit,
+            with_payload: true,
+        });
+        return results
+            .map(r => this.payloadToTicket(r.payload))
+            .filter((t) => t !== null);
+    }
+    async findSimilarProblems(problem, options = {}) {
+        const searchOptions = {
+            limit: options.limit || 5,
+            minScore: options.minScore || 0.6,
+        };
+        if (options.onlyPositive) {
+            searchOptions.outcome = 'positive';
+        }
+        return this.search(problem, searchOptions);
+    }
+    async getCategories() {
+        const tickets = await this.list({ limit: 1000 });
+        const categoryMap = new Map();
+        for (const t of tickets) {
+            const count = categoryMap.get(t.problem_category) || 0;
+            categoryMap.set(t.problem_category, count + 1);
+        }
+        return Array.from(categoryMap.entries())
+            .map(([category, count]) => ({ category, count }))
+            .sort((a, b) => b.count - a.count);
+    }
+    async stats() {
+        const tickets = await this.list({ limit: 1000 });
+        const byOutcome = {
+            positive: 0,
+            negative: 0,
+            neutral: 0,
+            escalated: 0,
+        };
+        const byCategory = {};
+        let totalSteps = 0;
+        for (const t of tickets) {
+            byOutcome[t.resolution.outcome]++;
+            byCategory[t.problem_category] = (byCategory[t.problem_category] || 0) + 1;
+            totalSteps += t.resolution.steps.length;
+        }
+        return {
+            total: tickets.length,
+            byOutcome,
+            byCategory,
+            avgSteps: tickets.length > 0 ? totalSteps / tickets.length : 0,
+        };
+    }
+    async delete(id) {
+        await this.qdrant.deletePoints(RESOLVED_COLLECTION, [id]);
+    }
+    buildEmbeddingText(ticket) {
+        const stepsText = ticket.resolution.steps
+            .map(s => `${s.order}. ${s.action}: ${s.description}`)
+            .join('\n');
+        return [
+            `Problem: ${ticket.problem}`,
+            `Category: ${ticket.problem_category}`,
+            `Resolution: ${ticket.resolution.summary}`,
+            `Outcome: ${ticket.resolution.outcome}`,
+            `Steps:\n${stepsText}`,
+        ].join('\n');
+    }
+    ticketToPayload(ticket) {
+        return {
+            id: ticket.id,
+            ticket_id: ticket.ticket_id,
+            problem: ticket.problem,
+            problem_category: ticket.problem_category,
+            outcome: ticket.resolution.outcome,
+            summary: ticket.resolution.summary,
+            steps: JSON.stringify(ticket.resolution.steps),
+            sop_reference: ticket.resolution.sop_reference || null,
+            agent_id: ticket.agent_id,
+            files: ticket.files || [],
+            tags: ticket.tags,
+            created_at: ticket.created_at,
+            customer_satisfaction: ticket.customer_satisfaction ?? null,
+            metadata: ticket.metadata ? JSON.stringify(ticket.metadata) : null,
+        };
+    }
+    payloadToTicket(payload) {
+        if (!payload || payload.type !== 'resolved_ticket')
+            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 = [];
+        }
+        let metadata;
+        try {
+            if (typeof payload.metadata === 'string') {
+                metadata = JSON.parse(payload.metadata);
+            }
+            else if (payload.metadata && typeof payload.metadata === 'object') {
+                metadata = payload.metadata;
+            }
+        }
+        catch {
+            metadata = undefined;
+        }
+        return {
+            id: String(payload.id),
+            ticket_id: Number(payload.ticket_id),
+            problem: String(payload.problem || ''),
+            problem_category: String(payload.problem_category || 'general'),
+            resolution: {
+                outcome: payload.outcome || 'neutral',
+                summary: String(payload.summary || ''),
+                steps,
+                sop_reference: payload.sop_reference ? String(payload.sop_reference) : undefined,
+            },
+            agent_id: String(payload.agent_id || ''),
+            files: payload.files || [],
+            tags: payload.tags || [],
+            created_at: String(payload.created_at || new Date().toISOString()),
+            customer_satisfaction: payload.customer_satisfaction ? Number(payload.customer_satisfaction) : undefined,
+            metadata,
+        };
+    }
+}
+export default ResolvedTicketsService;