@operor/copilot 0.1.0

package/dist/index.js

@@ -0,0 +1,708 @@
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import crypto from "node:crypto";
+
+//#region src/types.ts
+/** Default copilot configuration values */
+const DEFAULT_COPILOT_CONFIG = {
+	enabled: false,
+	trackingThreshold: .7,
+	clusterThreshold: .87,
+	digestIntervalMs: 864e5,
+	digestMaxItems: 10,
+	autoSuggest: true
+};
+
+//#endregion
+//#region src/SQLiteCopilotStore.ts
+/**
+* SQLite-backed copilot store with sqlite-vec for vector search on cluster centroids.
+*/
+var SQLiteCopilotStore = class {
+	db;
+	constructor(dbPath, dimensions) {
+		this.dbPath = dbPath;
+		this.dimensions = dimensions;
+		this.db = new Database(dbPath);
+		this.db.pragma("journal_mode = WAL");
+		this.db.pragma("foreign_keys = ON");
+		sqliteVec.load(this.db);
+	}
+	async initialize() {
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS copilot_queries (
+        id TEXT PRIMARY KEY,
+        query TEXT NOT NULL,
+        normalized_query TEXT NOT NULL,
+        channel TEXT NOT NULL,
+        customer_phone TEXT NOT NULL,
+        kb_top_score REAL NOT NULL DEFAULT 0,
+        kb_is_faq_match INTEGER NOT NULL DEFAULT 0,
+        kb_top_chunk_content TEXT,
+        kb_result_count INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'pending',
+        cluster_id TEXT,
+        times_asked INTEGER NOT NULL DEFAULT 1,
+        unique_customers TEXT NOT NULL DEFAULT '[]',
+        embedding BLOB,
+        suggested_answer TEXT,
+        taught_answer TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_copilot_queries_status ON copilot_queries(status);
+      CREATE INDEX IF NOT EXISTS idx_copilot_queries_normalized ON copilot_queries(normalized_query);
+      CREATE INDEX IF NOT EXISTS idx_copilot_queries_cluster ON copilot_queries(cluster_id);
+
+      CREATE TABLE IF NOT EXISTS copilot_clusters (
+        id TEXT PRIMARY KEY,
+        label TEXT,
+        representative_query TEXT NOT NULL,
+        centroid BLOB,
+        query_count INTEGER NOT NULL DEFAULT 1,
+        unique_customers TEXT NOT NULL DEFAULT '[]',
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_copilot_clusters_status ON copilot_clusters(status);
+
+      CREATE TABLE IF NOT EXISTS copilot_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+		this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS vec_copilot_clusters USING vec0(
+        cluster_id TEXT PRIMARY KEY,
+        centroid float[${this.dimensions}]
+      );
+    `);
+	}
+	async close() {
+		this.db.close();
+	}
+	async addQuery(query) {
+		this.db.prepare(`
+      INSERT OR REPLACE INTO copilot_queries
+        (id, query, normalized_query, channel, customer_phone, kb_top_score, kb_is_faq_match,
+         kb_top_chunk_content, kb_result_count, status, cluster_id, times_asked,
+         unique_customers, embedding, suggested_answer, taught_answer, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(query.id, query.query, query.normalizedQuery, query.channel, query.customerPhone, query.kbTopScore, query.kbIsFaqMatch ? 1 : 0, query.kbTopChunkContent ?? null, query.kbResultCount, query.status, query.clusterId ?? null, query.timesAsked, JSON.stringify(query.uniqueCustomers), query.embedding ? Buffer.from(new Float32Array(query.embedding).buffer) : null, query.suggestedAnswer ?? null, query.taughtAnswer ?? null, query.createdAt, query.updatedAt);
+	}
+	async getQuery(id) {
+		const row = this.db.prepare("SELECT * FROM copilot_queries WHERE id = ?").get(id);
+		return row ? this.rowToQuery(row) : null;
+	}
+	async updateQuery(id, updates) {
+		const existing = await this.getQuery(id);
+		if (!existing) return;
+		const merged = {
+			...existing,
+			...updates,
+			updatedAt: Date.now()
+		};
+		await this.addQuery(merged);
+	}
+	async getPendingQueries(limit) {
+		const sql = limit ? "SELECT * FROM copilot_queries WHERE status = ? ORDER BY times_asked DESC LIMIT ?" : "SELECT * FROM copilot_queries WHERE status = ? ORDER BY times_asked DESC";
+		return (limit ? this.db.prepare(sql).all("pending", limit) : this.db.prepare(sql).all("pending")).map((r) => this.rowToQuery(r));
+	}
+	async findSimilarQuery(normalizedQuery) {
+		const row = this.db.prepare("SELECT * FROM copilot_queries WHERE normalized_query = ? AND status = ? LIMIT 1").get(normalizedQuery, "pending");
+		return row ? this.rowToQuery(row) : null;
+	}
+	async getQueriesByCluster(clusterId) {
+		return this.db.prepare("SELECT * FROM copilot_queries WHERE cluster_id = ? ORDER BY times_asked DESC").all(clusterId).map((r) => this.rowToQuery(r));
+	}
+	async addCluster(cluster) {
+		this.db.prepare(`
+      INSERT OR REPLACE INTO copilot_clusters
+        (id, label, representative_query, centroid, query_count, unique_customers, status, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(cluster.id, cluster.label ?? null, cluster.representativeQuery, cluster.centroid ? Buffer.from(new Float32Array(cluster.centroid).buffer) : null, cluster.queryCount, JSON.stringify(cluster.uniqueCustomers), cluster.status, cluster.createdAt, cluster.updatedAt);
+		if (cluster.centroid) {
+			this.db.prepare("DELETE FROM vec_copilot_clusters WHERE cluster_id = ?").run(cluster.id);
+			this.db.prepare("INSERT INTO vec_copilot_clusters (cluster_id, centroid) VALUES (?, ?)").run(cluster.id, new Float32Array(cluster.centroid));
+		}
+	}
+	async getCluster(id) {
+		const row = this.db.prepare("SELECT * FROM copilot_clusters WHERE id = ?").get(id);
+		return row ? this.rowToCluster(row) : null;
+	}
+	async updateCluster(id, updates) {
+		const existing = await this.getCluster(id);
+		if (!existing) return;
+		const merged = {
+			...existing,
+			...updates,
+			updatedAt: Date.now()
+		};
+		await this.addCluster(merged);
+	}
+	async getOpenClusters() {
+		return this.db.prepare("SELECT * FROM copilot_clusters WHERE status = ? ORDER BY query_count DESC").all("pending").map((r) => this.rowToCluster(r));
+	}
+	/** Vector search cluster centroids — returns closest clusters by cosine distance */
+	async searchClusters(embedding, limit) {
+		return this.db.prepare(`
+      SELECT cluster_id, distance
+      FROM vec_copilot_clusters
+      WHERE centroid MATCH ?
+      ORDER BY distance
+      LIMIT ?
+    `).all(new Float32Array(embedding), limit).map((r) => ({
+			clusterId: r.cluster_id,
+			distance: r.distance
+		}));
+	}
+	async getImpactMetrics(topN = 10) {
+		const counts = this.db.prepare(`
+      SELECT
+        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending_count,
+        SUM(CASE WHEN status = 'taught' THEN 1 ELSE 0 END) as taught_count,
+        SUM(CASE WHEN status = 'dismissed' THEN 1 ELSE 0 END) as dismissed_count,
+        SUM(times_asked) as total_times_asked
+      FROM copilot_queries
+    `).get();
+		const allCustomerRows = this.db.prepare("SELECT unique_customers FROM copilot_queries").all();
+		const allCustomers = /* @__PURE__ */ new Set();
+		for (const row of allCustomerRows) JSON.parse(row.unique_customers).forEach((c) => allCustomers.add(c));
+		const topPending = await this.getPendingQueries(topN);
+		return {
+			pendingCount: counts.pending_count ?? 0,
+			taughtCount: counts.taught_count ?? 0,
+			dismissedCount: counts.dismissed_count ?? 0,
+			totalCustomersAffected: allCustomers.size,
+			totalTimesAsked: counts.total_times_asked ?? 0,
+			topPendingQueries: topPending
+		};
+	}
+	async getLastDigestTime() {
+		const row = this.db.prepare("SELECT value FROM copilot_meta WHERE key = 'last_digest_time'").get();
+		return row ? parseInt(row.value, 10) : 0;
+	}
+	async setLastDigestTime(time) {
+		this.db.prepare("INSERT OR REPLACE INTO copilot_meta (key, value) VALUES ('last_digest_time', ?)").run(String(time));
+	}
+	rowToQuery(row) {
+		return {
+			id: row.id,
+			query: row.query,
+			normalizedQuery: row.normalized_query,
+			channel: row.channel,
+			customerPhone: row.customer_phone,
+			kbTopScore: row.kb_top_score,
+			kbIsFaqMatch: !!row.kb_is_faq_match,
+			kbTopChunkContent: row.kb_top_chunk_content ?? void 0,
+			kbResultCount: row.kb_result_count,
+			status: row.status,
+			clusterId: row.cluster_id ?? void 0,
+			timesAsked: row.times_asked,
+			uniqueCustomers: JSON.parse(row.unique_customers),
+			embedding: row.embedding ? Array.from(new Float32Array(row.embedding.buffer ?? row.embedding)) : void 0,
+			suggestedAnswer: row.suggested_answer ?? void 0,
+			taughtAnswer: row.taught_answer ?? void 0,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at
+		};
+	}
+	rowToCluster(row) {
+		return {
+			id: row.id,
+			label: row.label ?? void 0,
+			representativeQuery: row.representative_query,
+			centroid: row.centroid ? Array.from(new Float32Array(row.centroid.buffer ?? row.centroid)) : void 0,
+			queryCount: row.query_count,
+			uniqueCustomers: JSON.parse(row.unique_customers),
+			status: row.status,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at
+		};
+	}
+};
+
+//#endregion
+//#region src/InMemoryCopilotStore.ts
+/**
+* In-memory copilot store for testing and development.
+*/
+var InMemoryCopilotStore = class {
+	queries = /* @__PURE__ */ new Map();
+	clusters = /* @__PURE__ */ new Map();
+	lastDigestTime = 0;
+	async initialize() {}
+	async close() {}
+	async addQuery(query) {
+		this.queries.set(query.id, { ...query });
+	}
+	async getQuery(id) {
+		return this.queries.get(id) ?? null;
+	}
+	async updateQuery(id, updates) {
+		const q = this.queries.get(id);
+		if (q) this.queries.set(id, {
+			...q,
+			...updates,
+			updatedAt: Date.now()
+		});
+	}
+	async getPendingQueries(limit) {
+		const pending = [...this.queries.values()].filter((q) => q.status === "pending").sort((a, b) => b.timesAsked - a.timesAsked);
+		return limit ? pending.slice(0, limit) : pending;
+	}
+	async findSimilarQuery(normalizedQuery) {
+		for (const q of this.queries.values()) if (q.normalizedQuery === normalizedQuery) return q;
+		return null;
+	}
+	async getQueriesByCluster(clusterId) {
+		return [...this.queries.values()].filter((q) => q.clusterId === clusterId);
+	}
+	async addCluster(cluster) {
+		this.clusters.set(cluster.id, { ...cluster });
+	}
+	async getCluster(id) {
+		return this.clusters.get(id) ?? null;
+	}
+	async updateCluster(id, updates) {
+		const c = this.clusters.get(id);
+		if (c) this.clusters.set(id, {
+			...c,
+			...updates,
+			updatedAt: Date.now()
+		});
+	}
+	async getOpenClusters() {
+		return [...this.clusters.values()].filter((c) => c.status === "pending");
+	}
+	async getImpactMetrics(topN = 10) {
+		const all = [...this.queries.values()];
+		const pending = all.filter((q) => q.status === "pending");
+		const allCustomers = /* @__PURE__ */ new Set();
+		let totalAsked = 0;
+		for (const q of all) {
+			q.uniqueCustomers.forEach((c) => allCustomers.add(c));
+			totalAsked += q.timesAsked;
+		}
+		return {
+			pendingCount: pending.length,
+			taughtCount: all.filter((q) => q.status === "taught").length,
+			dismissedCount: all.filter((q) => q.status === "dismissed").length,
+			totalCustomersAffected: allCustomers.size,
+			totalTimesAsked: totalAsked,
+			topPendingQueries: pending.sort((a, b) => b.timesAsked - a.timesAsked).slice(0, topN)
+		};
+	}
+	async getLastDigestTime() {
+		return this.lastDigestTime;
+	}
+	async setLastDigestTime(time) {
+		this.lastDigestTime = time;
+	}
+};
+
+//#endregion
+//#region src/UnansweredQueryTracker.ts
+/**
+* Tracks unanswered queries by listening to message:processed events.
+* Runs non-blocking — errors are caught and logged, never thrown.
+*/
+var UnansweredQueryTracker = class {
+	constructor(store, config, embedder, clusterer) {
+		this.store = store;
+		this.config = config;
+		this.embedder = embedder;
+		this.clusterer = clusterer;
+	}
+	/**
+	* Called after each message is processed. Decides whether to track the query.
+	* Non-blocking: catches all errors internally.
+	*/
+	async maybeTrack(event) {
+		try {
+			if (!this.config.enabled) return;
+			const kbTopScore = event.response.metadata?.kbTopScore ?? 0;
+			const kbResultCount = event.response.metadata?.kbResultCount ?? 0;
+			if (kbResultCount > 0 && kbTopScore >= this.config.trackingThreshold) return;
+			const normalizedQuery = this.normalizeQuery(event.query);
+			const existing = await this.store.findSimilarQuery(normalizedQuery);
+			if (existing) {
+				const uniqueCustomers = existing.uniqueCustomers.includes(event.customerPhone) ? existing.uniqueCustomers : [...existing.uniqueCustomers, event.customerPhone];
+				await this.store.updateQuery(existing.id, {
+					timesAsked: existing.timesAsked + 1,
+					uniqueCustomers,
+					updatedAt: Date.now()
+				});
+			} else {
+				const embedding = await this.embedder.embed(normalizedQuery);
+				const now = Date.now();
+				const id = crypto.randomUUID();
+				const newQuery = {
+					id,
+					query: event.query,
+					normalizedQuery,
+					channel: event.channel,
+					customerPhone: event.customerPhone,
+					kbTopScore,
+					kbIsFaqMatch: event.response.metadata?.kbIsFaqMatch ?? false,
+					kbTopChunkContent: event.response.metadata?.kbTopChunkContent,
+					kbResultCount,
+					status: "pending",
+					timesAsked: 1,
+					uniqueCustomers: [event.customerPhone],
+					embedding,
+					createdAt: now,
+					updatedAt: now
+				};
+				await this.store.addQuery(newQuery);
+				if (this.clusterer) await this.clusterer.assignCluster(id, normalizedQuery, embedding);
+			}
+		} catch (_err) {}
+	}
+	/** Normalize query text for deduplication */
+	normalizeQuery(text) {
+		return text.toLowerCase().trim().replace(/\s+/g, " ");
+	}
+};
+
+//#endregion
+//#region src/QueryClusterer.ts
+/**
+* Groups semantically similar unanswered queries into clusters.
+*/
+var QueryClusterer = class {
+	constructor(store, embedder, config = { clusterThreshold: .87 }) {
+		this.store = store;
+		this.embedder = embedder;
+		this.config = config;
+	}
+	/**
+	* Assign a query to an existing cluster or create a new one.
+	* Returns the cluster ID.
+	*/
+	async assignCluster(queryId, queryText, embedding) {
+		const clusters = await this.store.getOpenClusters();
+		let bestCluster = null;
+		let bestScore = -1;
+		for (const cluster of clusters) {
+			if (!cluster.centroid) continue;
+			const score = this.cosineSimilarity(embedding, cluster.centroid);
+			if (score > bestScore) {
+				bestScore = score;
+				bestCluster = cluster;
+			}
+		}
+		if (bestCluster && bestScore >= this.config.clusterThreshold) {
+			const newCount = bestCluster.queryCount + 1;
+			const newCentroid = this.updateCentroid(bestCluster.centroid, embedding, newCount);
+			await this.store.updateCluster(bestCluster.id, {
+				centroid: newCentroid,
+				queryCount: newCount,
+				updatedAt: Date.now()
+			});
+			await this.store.updateQuery(queryId, { clusterId: bestCluster.id });
+			return bestCluster.id;
+		}
+		const clusterId = crypto.randomUUID();
+		const now = Date.now();
+		const newCluster = {
+			id: clusterId,
+			representativeQuery: queryText,
+			centroid: embedding,
+			queryCount: 1,
+			uniqueCustomers: [],
+			status: "pending",
+			createdAt: now,
+			updatedAt: now
+		};
+		await this.store.addCluster(newCluster);
+		await this.store.updateQuery(queryId, { clusterId });
+		return clusterId;
+	}
+	/** Cosine similarity between two vectors */
+	cosineSimilarity(a, b) {
+		let dot = 0, magA = 0, magB = 0;
+		for (let i = 0; i < a.length; i++) {
+			dot += a[i] * b[i];
+			magA += a[i] * a[i];
+			magB += b[i] * b[i];
+		}
+		return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+	}
+	/** Compute running average centroid */
+	updateCentroid(current, newVec, count) {
+		return current.map((v, i) => (v * (count - 1) + newVec[i]) / count);
+	}
+};
+
+//#endregion
+//#region src/SuggestionEngine.ts
+const SYSTEM_PROMPT = `You are a helpful assistant that drafts FAQ answers for a knowledge base. Write concise, accurate answers based on the available context. If the context doesn't contain enough information, say so.`;
+/**
+* Generates suggested answers for unanswered queries using the LLM + KB context.
+*/
+var SuggestionEngine = class {
+	constructor(aiProvider, kb) {
+		this.aiProvider = aiProvider;
+		this.kb = kb;
+	}
+	/**
+	* Generate a suggested answer for a query, optionally including related queries from a cluster.
+	*/
+	async suggest(query, relatedQueries) {
+		const kbResult = await this.kb.retrieve(query);
+		let prompt = `Customer query: "${query}"\n`;
+		if (relatedQueries && relatedQueries.length > 0) {
+			prompt += `\nRelated queries from other customers:\n`;
+			for (const rq of relatedQueries) prompt += `- "${rq}"\n`;
+		}
+		if (kbResult.context) prompt += `\nKnowledge base context:\n${kbResult.context}\n`;
+		prompt += `\nPlease draft a concise, helpful FAQ answer for this query.`;
+		return (await this.aiProvider.generateText({
+			system: SYSTEM_PROMPT,
+			prompt,
+			temperature: .3
+		})).text;
+	}
+};
+
+//#endregion
+//#region src/CopilotCommandHandler.ts
+/**
+* Handles /review commands from admin users in training mode.
+*/
+var CopilotCommandHandler = class {
+	/** Per-admin session state: tracks which query they're currently reviewing */
+	sessions = /* @__PURE__ */ new Map();
+	constructor(store, suggestionEngine, kb, clusterer) {
+		this.store = store;
+		this.suggestionEngine = suggestionEngine;
+		this.kb = kb;
+		this.clusterer = clusterer;
+	}
+	/**
+	* Handle a /review subcommand.
+	* @param command The full command (always '/review')
+	* @param args Subcommand + arguments (e.g. 'accept This is the answer')
+	* @param adminPhone The admin's phone number
+	* @param reply Function to send a reply back to the admin
+	*/
+	async handleCommand(command, args, adminPhone, reply) {
+		const trimmed = args.trim();
+		const spaceIndex = trimmed.indexOf(" ");
+		const subcommand = spaceIndex === -1 ? trimmed.toLowerCase() : trimmed.slice(0, spaceIndex).toLowerCase();
+		const subArgs = spaceIndex === -1 ? "" : trimmed.slice(spaceIndex + 1).trim();
+		switch (subcommand) {
+			case "":
+			case "next": return this.handleNext(adminPhone, reply);
+			case "accept": return this.handleAccept(adminPhone, subArgs, reply);
+			case "edit": return this.handleEdit(adminPhone, subArgs, reply);
+			case "skip": return this.handleSkip(adminPhone, reply);
+			case "stats": return this.handleStats(reply);
+			case "cluster": return this.handleCluster(adminPhone, reply);
+			case "help": return this.handleHelp(reply);
+			default: await reply(`Unknown subcommand: *${subcommand}*\n\nType */review help* to see available commands.`);
+		}
+	}
+	getSession(adminPhone) {
+		let session = this.sessions.get(adminPhone);
+		if (!session) {
+			session = { currentQuery: null };
+			this.sessions.set(adminPhone, session);
+		}
+		return session;
+	}
+	async handleNext(adminPhone, reply) {
+		const session = this.getSession(adminPhone);
+		const pending = await this.store.getPendingQueries(1);
+		if (pending.length === 0) {
+			session.currentQuery = null;
+			await reply("No pending queries to review. Great job! 🎉");
+			return;
+		}
+		const query = pending[0];
+		session.currentQuery = query;
+		let text = `*📋 Query for Review*\n\n`;
+		text += `*Question:* ${query.query}\n`;
+		text += `*Times asked:* ${query.timesAsked}\n`;
+		text += `*Unique customers:* ${query.uniqueCustomers.length}\n`;
+		if (query.suggestedAnswer) text += `\n*💡 Suggested answer:*\n${query.suggestedAnswer}\n`;
+		else if (this.suggestionEngine) try {
+			const suggested = await this.suggestionEngine.suggest(query.query);
+			if (suggested) {
+				query.suggestedAnswer = suggested;
+				await this.store.updateQuery(query.id, { suggestedAnswer: suggested });
+				text += `\n*💡 Suggested answer:*\n${suggested}\n`;
+			}
+		} catch {}
+		text += `\n*Actions:*`;
+		text += `\n/review accept [answer] — Teach this answer`;
+		text += `\n/review edit <answer> — Provide your own answer`;
+		text += `\n/review skip — Skip this query`;
+		await reply(text);
+	}
+	async handleAccept(adminPhone, answerText, reply) {
+		const session = this.getSession(adminPhone);
+		const query = session.currentQuery;
+		if (!query) {
+			await reply("No query selected. Use */review next* to load one.");
+			return;
+		}
+		const answer = answerText || query.suggestedAnswer;
+		if (!answer) {
+			await reply("No answer provided and no suggestion available. Use */review edit <answer>* to provide one.");
+			return;
+		}
+		await this.kb.ingestFaq(query.query, answer);
+		await this.store.updateQuery(query.id, {
+			status: "taught",
+			taughtAnswer: answer,
+			updatedAt: Date.now()
+		});
+		session.currentQuery = null;
+		await reply(`*✅ Taught!*\n\n*Q:* ${query.query}\n*A:* ${answer}`);
+	}
+	async handleEdit(adminPhone, answerText, reply) {
+		const session = this.getSession(adminPhone);
+		const query = session.currentQuery;
+		if (!query) {
+			await reply("No query selected. Use */review next* to load one.");
+			return;
+		}
+		if (!answerText) {
+			await reply("Please provide an answer: */review edit <your answer>*");
+			return;
+		}
+		await this.kb.ingestFaq(query.query, answerText);
+		await this.store.updateQuery(query.id, {
+			status: "taught",
+			taughtAnswer: answerText,
+			updatedAt: Date.now()
+		});
+		session.currentQuery = null;
+		await reply(`*✅ Taught!*\n\n*Q:* ${query.query}\n*A:* ${answerText}`);
+	}
+	async handleSkip(adminPhone, reply) {
+		const session = this.getSession(adminPhone);
+		const query = session.currentQuery;
+		if (!query) {
+			await reply("No query selected. Use */review next* to load one.");
+			return;
+		}
+		await this.store.updateQuery(query.id, {
+			status: "dismissed",
+			updatedAt: Date.now()
+		});
+		session.currentQuery = null;
+		await reply(`*⏭️ Skipped:* ${query.query}`);
+	}
+	async handleStats(reply) {
+		const metrics = await this.store.getImpactMetrics();
+		let text = `*📊 Copilot Stats*\n\n`;
+		text += `*Pending:* ${metrics.pendingCount}\n`;
+		text += `*Taught:* ${metrics.taughtCount}\n`;
+		text += `*Dismissed:* ${metrics.dismissedCount}\n`;
+		text += `*Customers affected:* ${metrics.totalCustomersAffected}\n`;
+		text += `*Total times asked:* ${metrics.totalTimesAsked}`;
+		if (metrics.topPendingQueries.length > 0) {
+			text += `\n\n*Top pending queries:*`;
+			for (const q of metrics.topPendingQueries) text += `\n• ${q.query} (×${q.timesAsked})`;
+		}
+		await reply(text);
+	}
+	async handleCluster(adminPhone, reply) {
+		const query = this.getSession(adminPhone).currentQuery;
+		if (!query) {
+			await reply("No query selected. Use */review next* to load one.");
+			return;
+		}
+		if (!query.clusterId) {
+			await reply("This query is not part of any cluster.");
+			return;
+		}
+		const cluster = await this.store.getCluster(query.clusterId);
+		if (!cluster) {
+			await reply("Cluster not found.");
+			return;
+		}
+		const queries = await this.store.getQueriesByCluster(query.clusterId);
+		let text = `*🔗 Cluster: ${cluster.label || cluster.representativeQuery}*\n\n`;
+		text += `*Queries in cluster:* ${queries.length}\n`;
+		text += `*Unique customers:* ${cluster.uniqueCustomers.length}\n\n`;
+		for (const q of queries) {
+			const marker = q.id === query.id ? "👉 " : "• ";
+			text += `${marker}${q.query} (×${q.timesAsked})\n`;
+		}
+		await reply(text);
+	}
+	async handleHelp(reply) {
+		await reply([
+			"*📖 Review Commands*",
+			"",
+			"*/review* — Show next pending query",
+			"*/review next* — Same as above",
+			"*/review accept [answer]* — Teach with answer (or suggested)",
+			"*/review edit <answer>* — Teach with your own answer",
+			"*/review skip* — Dismiss current query",
+			"*/review stats* — Show impact metrics",
+			"*/review cluster* — Show related queries in cluster",
+			"*/review help* — This help message"
+		].join("\n"));
+	}
+};
+
+//#endregion
+//#region src/DigestScheduler.ts
+/**
+* Periodically sends digest summaries of unanswered queries to admin phones.
+*/
+var DigestScheduler = class {
+	timer = null;
+	constructor(store, config, sendMessage) {
+		this.store = store;
+		this.config = config;
+		this.sendMessage = sendMessage;
+	}
+	/** Start the digest scheduler for the given admin phones */
+	start(adminPhones) {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = setInterval(async () => {
+			try {
+				const lastDigest = await this.store.getLastDigestTime();
+				const now = Date.now();
+				if (now - lastDigest < this.config.digestIntervalMs) return;
+				const digest = await this.buildDigest();
+				if (!digest) return;
+				for (const phone of adminPhones) await this.sendMessage(phone, digest);
+				await this.store.setLastDigestTime(now);
+			} catch {}
+		}, this.config.digestIntervalMs);
+	}
+	/** Stop the digest scheduler */
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+	/** Build the digest message text */
+	async buildDigest() {
+		const metrics = await this.store.getImpactMetrics(this.config.digestMaxItems);
+		if (metrics.pendingCount === 0) return null;
+		let text = `*📬 Training Copilot Digest*\n\n`;
+		text += `*${metrics.pendingCount}* pending queries from *${metrics.totalCustomersAffected}* customers\n`;
+		if (metrics.topPendingQueries.length > 0) {
+			text += `\n*Top unanswered queries:*\n`;
+			for (const q of metrics.topPendingQueries) text += `• ${q.query} (×${q.timesAsked})\n`;
+		}
+		text += `\nReply */review* to start reviewing`;
+		return text;
+	}
+};
+
+//#endregion
+export { CopilotCommandHandler, DEFAULT_COPILOT_CONFIG, DigestScheduler, InMemoryCopilotStore, QueryClusterer, SQLiteCopilotStore, SuggestionEngine, UnansweredQueryTracker };
+//# sourceMappingURL=index.js.map