@lssm/example.ai-support-bot 0.0.0-canary-20251217060834 → 0.0.0-canary-20251217072406

package/dist/libs/logger/dist/logger.node.js

@@ -0,0 +1,189 @@
+import { LogContext } from "./context.node.js";
+import { LogLevel } from "./types.js";
+import { TimerManager } from "./timer.js";
+import { Tracer } from "./tracer.node.js";
+import { DevFormatter, ProductionFormatter } from "./formatters.js";
+
+//#region ../../libs/logger/dist/logger.node.mjs
+var Logger = class Logger$1 {
+	config;
+	formatter;
+	context;
+	tracer;
+	timerManager;
+	constructor(config) {
+		this.config = {
+			level: LogLevel.INFO,
+			environment: process.env.NODE_ENV || "development",
+			enableTracing: true,
+			enableTiming: true,
+			enableContext: true,
+			enableColors: true,
+			maxContextDepth: 10,
+			timestampFormat: "iso",
+			...config
+		};
+		this.context = LogContext.getInstance();
+		this.tracer = new Tracer();
+		this.timerManager = new TimerManager();
+		this.formatter = this.config.environment === "production" ? new ProductionFormatter() : new DevFormatter(this.config.enableColors);
+	}
+	traceLog(message, metadata) {
+		this.log(LogLevel.TRACE, message, metadata);
+	}
+	debug(message, metadata) {
+		this.log(LogLevel.DEBUG, message, metadata);
+	}
+	info(message, metadata) {
+		this.log(LogLevel.INFO, message, metadata);
+	}
+	warn(message, metadata) {
+		this.log(LogLevel.WARN, message, metadata);
+	}
+	error(message, metadata, error) {
+		this.log(LogLevel.ERROR, message, metadata, error);
+	}
+	fatal(message, metadata, error) {
+		this.log(LogLevel.FATAL, message, metadata, error);
+	}
+	withContext(context, fn) {
+		return this.context.run(context, fn);
+	}
+	extendContext(additionalContext, fn) {
+		return this.context.extend(additionalContext, fn);
+	}
+	setContext(key, value) {
+		this.context.set(key, value);
+	}
+	getContext() {
+		return this.context.getContext();
+	}
+	trace = async (options, fn) => {
+		if (!this.config.enableTracing) return await fn();
+		return this.tracer.trace(options, fn);
+	};
+	getTraceId() {
+		return this.tracer.getCurrentTrace()?.traceId;
+	}
+	startSpan(options) {
+		if (!this.config.enableTracing) return null;
+		return this.tracer.startSpan(options);
+	}
+	finishSpan(spanId) {
+		if (!this.config.enableTracing) return;
+		return this.tracer.finishSpan(spanId);
+	}
+	addTraceMetadata(key, value) {
+		if (this.config.enableTracing) this.tracer.addMetadata(key, value);
+	}
+	addTraceTags(...tags) {
+		if (this.config.enableTracing) this.tracer.addTags(...tags);
+	}
+	startTimer(id) {
+		if (!this.config.enableTiming) return null;
+		return this.timerManager.start(id);
+	}
+	stopTimer(id) {
+		if (!this.config.enableTiming) return;
+		return this.timerManager.stop(id);
+	}
+	getTimer(id) {
+		return this.timerManager.get(id);
+	}
+	child(context) {
+		const childLogger = new Logger$1(this.config);
+		Object.entries(context).forEach(([key, value]) => {
+			childLogger.setContext(key, value);
+		});
+		return childLogger;
+	}
+	setLevel(level) {
+		this.config.level = level;
+	}
+	setFormatter(formatter) {
+		this.formatter = formatter;
+	}
+	async profile(operationName, fn, options) {
+		const timer = this.startTimer(`profile-${operationName}`);
+		const startTime = performance.now();
+		try {
+			const result = await this.tracer.trace({
+				operationType: "custom",
+				operationName: `profile:${operationName}`,
+				autoTiming: true
+			}, fn);
+			const duration = performance.now() - startTime;
+			timer?.stop();
+			const logLevel = options?.logLevel || LogLevel.DEBUG;
+			this.log(logLevel, `Profile: ${operationName} completed`, {
+				operation: operationName,
+				duration: `${duration.toFixed(2)}ms`,
+				result: options?.logResult ? result : "[result hidden]"
+			});
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+			timer?.stop();
+			this.error(`Profile: ${operationName} failed`, {
+				operation: operationName,
+				duration: `${duration.toFixed(2)}ms`,
+				error: error.message
+			}, error);
+			throw error;
+		}
+	}
+	logRequest(method, url, statusCode, duration) {
+		const level = this.getHttpLogLevel(statusCode);
+		const message = `${method.toUpperCase()} ${url}${statusCode ? ` ${statusCode}` : ""}`;
+		this.log(level, message, {
+			method,
+			url,
+			statusCode,
+			duration: duration ? `${duration.toFixed(2)}ms` : void 0,
+			type: "http_request"
+		});
+	}
+	async flush() {
+		this.timerManager.clear();
+	}
+	getStats() {
+		return {
+			activeTimers: this.timerManager.getActive().length,
+			activeSpans: this.tracer.getActiveSpans().length,
+			config: { ...this.config }
+		};
+	}
+	output(message, level) {
+		if (level >= LogLevel.ERROR) console.error(message);
+		else console.log(message);
+	}
+	log(level, message, metadata, error) {
+		if (level < this.config.level) return;
+		const currentTrace = this.config.enableTracing ? this.tracer.getCurrentTrace() : void 0;
+		const contextData = this.config.enableContext ? this.context.getContext() : void 0;
+		const entry = {
+			level,
+			message,
+			timestamp: /* @__PURE__ */ new Date(),
+			traceId: currentTrace?.traceId,
+			parentId: currentTrace?.parentId,
+			spanId: currentTrace?.spanId,
+			context: contextData,
+			metadata,
+			error,
+			tags: currentTrace?.tags
+		};
+		if (currentTrace?.metadata?.duration) entry.duration = currentTrace.metadata.duration;
+		const formatted = this.formatter.format(entry);
+		this.output(formatted, level);
+	}
+	getHttpLogLevel(statusCode) {
+		if (!statusCode) return LogLevel.INFO;
+		if (statusCode >= 500) return LogLevel.ERROR;
+		if (statusCode >= 400) return LogLevel.WARN;
+		return LogLevel.INFO;
+	}
+};
+
+//#endregion
+export { Logger };

package/dist/libs/logger/dist/timer.js

@@ -0,0 +1,126 @@
+//#region ../../libs/logger/dist/timer.mjs
+var Timer = class {
+	id;
+	startTime;
+	laps = [];
+	stopped = false;
+	stopTime;
+	constructor(id) {
+		this.id = id || crypto.randomUUID();
+		this.startTime = performance.now();
+	}
+	/**
+	* Stop the timer and return elapsed time in milliseconds
+	*/
+	stop() {
+		if (this.stopped) return this.getElapsed();
+		this.stopTime = performance.now();
+		this.stopped = true;
+		const elapsed = this.stopTime - this.startTime;
+		this.laps.push({
+			label: "stop",
+			time: this.stopTime,
+			elapsed
+		});
+		return elapsed;
+	}
+	/**
+	* Record a lap time and return elapsed time since start
+	*/
+	lap(label) {
+		if (this.stopped) return this.getElapsed();
+		const now = performance.now();
+		const elapsed = now - this.startTime;
+		this.laps.push({
+			label: label || `lap-${this.laps.length + 1}`,
+			time: now,
+			elapsed
+		});
+		return elapsed;
+	}
+	/**
+	* Get elapsed time without stopping the timer
+	*/
+	getElapsed() {
+		if (this.stopped && this.stopTime) return this.stopTime - this.startTime;
+		return performance.now() - this.startTime;
+	}
+	/**
+	* Get all recorded laps
+	*/
+	getLaps() {
+		return [...this.laps];
+	}
+	/**
+	* Get timer summary with total time and laps
+	*/
+	getSummary() {
+		return {
+			id: this.id,
+			totalTime: this.getElapsed(),
+			isRunning: !this.stopped,
+			laps: this.getLaps()
+		};
+	}
+	/**
+	* Reset the timer (starts a new timing session)
+	*/
+	reset() {
+		this.startTime = performance.now();
+		this.laps = [];
+		this.stopped = false;
+		this.stopTime = void 0;
+	}
+};
+/**
+* Utility class for managing multiple timers
+*/
+var TimerManager = class {
+	timers = /* @__PURE__ */ new Map();
+	/**
+	* Start a new timer
+	*/
+	start(id) {
+		const timer = new Timer(id);
+		this.timers.set(timer.id, timer);
+		return timer;
+	}
+	/**
+	* Get an existing timer
+	*/
+	get(id) {
+		return this.timers.get(id);
+	}
+	/**
+	* Stop and remove a timer
+	*/
+	stop(id) {
+		const timer = this.timers.get(id);
+		if (timer) {
+			const elapsed = timer.stop();
+			this.timers.delete(id);
+			return elapsed;
+		}
+	}
+	/**
+	* Get all active timers
+	*/
+	getActive() {
+		return Array.from(this.timers.values()).filter((timer) => !timer.getSummary().isRunning === false);
+	}
+	/**
+	* Clear all timers
+	*/
+	clear() {
+		this.timers.clear();
+	}
+	/**
+	* Get summary of all timers
+	*/
+	getSummary() {
+		return Array.from(this.timers.values()).map((timer) => timer.getSummary());
+	}
+};
+
+//#endregion
+export { Timer, TimerManager };

package/dist/libs/logger/dist/tracer.node.js

@@ -0,0 +1,115 @@
+import { LogContext } from "./context.node.js";
+import { Timer } from "./timer.js";
+
+//#region ../../libs/logger/dist/tracer.node.mjs
+var Tracer = class {
+	context;
+	activeSpans = /* @__PURE__ */ new Map();
+	constructor() {
+		this.context = LogContext.getInstance();
+	}
+	/**
+	* Start a new trace span
+	*/
+	startSpan(options) {
+		const parentTrace = this.context.getCurrentTrace();
+		const span = {
+			traceId: parentTrace?.traceId || this.generateTraceId(),
+			parentId: parentTrace?.spanId,
+			spanId: this.generateSpanId(),
+			operationType: options.operationType,
+			operationName: options.operationName,
+			startTime: performance.now(),
+			metadata: { ...options.metadata },
+			tags: [...options.tags || []]
+		};
+		this.activeSpans.set(span.spanId, span);
+		this.context.setTrace(span);
+		return span;
+	}
+	/**
+	* Finish a trace span
+	*/
+	finishSpan(spanId) {
+		const span = this.activeSpans.get(spanId);
+		if (!span) return;
+		const duration = performance.now() - span.startTime;
+		this.activeSpans.delete(spanId);
+		if (this.context.getCurrentTrace()?.spanId === spanId && span.parentId) {
+			const parentSpan = this.findSpanById(span.parentId);
+			if (parentSpan) this.context.setTrace(parentSpan);
+		}
+		return duration;
+	}
+	/**
+	* Execute a function within a trace span
+	*/
+	async trace(options, fn) {
+		const span = this.startSpan(options);
+		const timer = options.autoTiming !== false ? new Timer(`trace-${span.spanId}`) : void 0;
+		try {
+			const result = await fn();
+			const duration = this.finishSpan(span.spanId);
+			if (timer) timer.stop();
+			if (duration !== void 0) span.metadata.duration = duration;
+			return result;
+		} catch (error) {
+			span.metadata.error = {
+				name: error.name || "Unknown",
+				message: error.message || "Unknown error",
+				stack: error.stack
+			};
+			const duration = this.finishSpan(span.spanId);
+			span.metadata.duration = duration;
+			if (timer) timer.stop();
+			throw error;
+		}
+	}
+	/**
+	* Add metadata to current span
+	*/
+	addMetadata(key, value) {
+		const currentTrace = this.context.getCurrentTrace();
+		if (currentTrace) currentTrace.metadata[key] = value;
+	}
+	/**
+	* Add tags to current span
+	*/
+	addTags(...tags) {
+		const currentTrace = this.context.getCurrentTrace();
+		if (currentTrace) currentTrace.tags.push(...tags);
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return this.context.getCurrentTrace();
+	}
+	/**
+	* Get all active spans
+	*/
+	getActiveSpans() {
+		return Array.from(this.activeSpans.values());
+	}
+	/**
+	* Find a span by ID
+	*/
+	findSpanById(spanId) {
+		return this.activeSpans.get(spanId);
+	}
+	/**
+	* Generate a unique trace ID
+	*/
+	generateTraceId() {
+		return crypto.randomUUID().replace(/-/g, "");
+	}
+	/**
+	* Generate a unique span ID
+	*/
+	generateSpanId() {
+		return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+	}
+};
+
+//#endregion
+export { Tracer };

package/dist/libs/logger/dist/types.js

@@ -0,0 +1,13 @@
+//#region ../../libs/logger/dist/types.mjs
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["TRACE"] = 0] = "TRACE";
+	LogLevel$1[LogLevel$1["DEBUG"] = 1] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 3] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 4] = "ERROR";
+	LogLevel$1[LogLevel$1["FATAL"] = 5] = "FATAL";
+	return LogLevel$1;
+}({});
+
+//#endregion
+export { LogLevel };

package/dist/libs/support-bot/dist/bot/auto-responder.js

@@ -0,0 +1,83 @@
+//#region ../../libs/support-bot/dist/bot/auto-responder.js
+var AutoResponder = class {
+	llm;
+	model;
+	tone;
+	closing;
+	constructor(options) {
+		this.llm = options?.llm;
+		this.model = options?.model;
+		this.tone = options?.tone ?? "friendly";
+		this.closing = options?.closing ?? (this.tone === "friendly" ? "We remain available if you need anything else." : "Please let us know if you require additional assistance.");
+	}
+	async draft(ticket, resolution, classification) {
+		if (this.llm) return this.generateWithLLM(ticket, resolution, classification);
+		return this.generateTemplate(ticket, resolution, classification);
+	}
+	async generateWithLLM(ticket, resolution, classification) {
+		const prompt = `You are a ${this.tone} support agent. Draft an email response.
+Ticket Subject: ${ticket.subject}
+Ticket Body: ${ticket.body}
+Detected Category: ${classification.category}
+Detected Priority: ${classification.priority}
+Resolution:
+${resolution.answer}
+Citations: ${resolution.citations.map((c) => c.label).join(", ")}`;
+		const body = (await this.llm.chat([{
+			role: "system",
+			content: [{
+				type: "text",
+				text: "Write empathetic, accurate support replies that cite sources when relevant."
+			}]
+		}, {
+			role: "user",
+			content: [{
+				type: "text",
+				text: prompt
+			}]
+		}], { model: this.model })).message.content.map((part) => "text" in part ? part.text : "").join("").trim();
+		return this.buildDraft(ticket, resolution, classification, body);
+	}
+	generateTemplate(ticket, resolution, classification) {
+		const body = `${ticket.customerName ? `Hi ${ticket.customerName},` : "Hi there,"}
+
+Thanks for contacting us about "${ticket.subject}". ${this.renderCategoryIntro(classification)}
+
+${resolution.answer}
+
+${this.renderCitations(resolution)}
+${this.closing}
+
+— ContractSpec Support`;
+		return this.buildDraft(ticket, resolution, classification, body);
+	}
+	buildDraft(ticket, resolution, classification, body) {
+		return {
+			ticketId: ticket.id,
+			subject: ticket.subject.startsWith("Re:") ? ticket.subject : `Re: ${ticket.subject}`,
+			body,
+			confidence: Math.min(resolution.confidence, classification.confidence),
+			requiresEscalation: resolution.actions.some((action) => action.type === "escalate") || Boolean(classification.escalationRequired),
+			citations: resolution.citations
+		};
+	}
+	renderCategoryIntro(classification) {
+		switch (classification.category) {
+			case "billing": return "I understand billing issues can be stressful, so let me clarify the situation.";
+			case "technical": return "I see you encountered a technical issue. Here is what happened and how to fix it.";
+			case "product": return "Thanks for sharing feedback about the product. Here are the next steps.";
+			case "account": return "Account access is critical, so let me walk you through the resolution.";
+			case "compliance": return "Compliance questions require precision. See the policy-aligned answer below.";
+			default: return "Here is what we found after reviewing your request.";
+		}
+	}
+	renderCitations(resolution) {
+		if (!resolution.citations.length) return "";
+		return `References:\n${resolution.citations.map((citation, index) => {
+			return `- ${citation.label || `Source ${index + 1}`}${citation.url ? ` (${citation.url})` : ""}`;
+		}).join("\n")}`;
+	}
+};
+
+//#endregion
+export { AutoResponder };

package/dist/libs/support-bot/dist/bot/index.js

@@ -0,0 +1,2 @@
+import { AutoResponder } from "./auto-responder.js";
+import "./tools.js";

package/dist/libs/support-bot/dist/bot/tools.js

@@ -0,0 +1,71 @@
+import * as z from "zod";
+
+//#region ../../libs/support-bot/dist/bot/tools.js
+const ticketSchema = z.object({
+	id: z.string(),
+	subject: z.string(),
+	body: z.string(),
+	channel: z.enum([
+		"email",
+		"chat",
+		"phone",
+		"portal"
+	]),
+	customerName: z.string().optional(),
+	customerEmail: z.string().optional(),
+	metadata: z.object().optional()
+});
+const supportCitationSchema = z.object({
+	label: z.string(),
+	url: z.string().optional(),
+	snippet: z.string().optional(),
+	score: z.number().optional()
+});
+const supportActionSchema = z.object({
+	type: z.enum([
+		"respond",
+		"escalate",
+		"refund",
+		"manual"
+	]),
+	label: z.string(),
+	payload: z.record(z.string(), z.string())
+});
+const supportResolutionSchema = z.object({
+	ticketId: z.string(),
+	answer: z.string(),
+	confidence: z.number(),
+	citations: supportCitationSchema.array(),
+	actions: supportActionSchema.array(),
+	escalationReason: z.string().optional(),
+	knowledgeUpdates: z.array(z.string()).optional()
+});
+const ticketClassificationSchema = z.object({
+	ticketId: z.string(),
+	category: z.enum([
+		"billing",
+		"technical",
+		"product",
+		"account",
+		"compliance",
+		"other"
+	]),
+	priority: z.enum([
+		"urgent",
+		"high",
+		"medium",
+		"low"
+	]),
+	sentiment: z.enum([
+		"positive",
+		"neutral",
+		"negative",
+		"frustrated"
+	]),
+	intents: z.array(z.string()),
+	tags: z.array(z.string()),
+	confidence: z.number(),
+	escalationRequired: z.boolean().optional()
+});
+
+//#endregion

package/dist/libs/support-bot/dist/rag/ticket-resolver.js

@@ -0,0 +1,63 @@
+//#region ../../libs/support-bot/dist/rag/ticket-resolver.js
+var TicketResolver = class {
+	knowledge;
+	minConfidence;
+	prependPrompt;
+	constructor(options) {
+		this.knowledge = options.knowledge;
+		this.minConfidence = options.minConfidence ?? .65;
+		this.prependPrompt = options.prependPrompt;
+	}
+	async resolve(ticket) {
+		const question = this.buildQuestion(ticket);
+		const answer = await this.knowledge.query(question);
+		return this.toResolution(ticket, answer);
+	}
+	buildQuestion(ticket) {
+		const header = [`Subject: ${ticket.subject}`, `Channel: ${ticket.channel}`];
+		if (ticket.customerName) header.push(`Customer: ${ticket.customerName}`);
+		return [
+			this.prependPrompt,
+			header.join("\n"),
+			"---",
+			ticket.body
+		].filter(Boolean).join("\n");
+	}
+	toResolution(ticket, answer) {
+		const citations = answer.references.map((ref) => {
+			return {
+				label: typeof ref.payload?.title === "string" ? ref.payload.title : typeof ref.payload?.documentId === "string" ? ref.payload.documentId : ref.id,
+				url: typeof ref.payload?.url === "string" ? ref.payload.url : void 0,
+				snippet: typeof ref.payload?.text === "string" ? ref.payload.text.slice(0, 280) : void 0,
+				score: ref.score
+			};
+		});
+		const confidence = this.deriveConfidence(answer);
+		const escalate = confidence < this.minConfidence || citations.length === 0;
+		return {
+			ticketId: ticket.id,
+			answer: answer.answer,
+			confidence,
+			citations,
+			actions: [escalate ? {
+				type: "escalate",
+				label: "Escalate for human review"
+			} : {
+				type: "respond",
+				label: "Send automated response"
+			}],
+			escalationReason: escalate ? "Insufficient confidence or missing knowledge references" : void 0,
+			knowledgeUpdates: escalate ? [ticket.body.slice(0, 200)] : void 0
+		};
+	}
+	deriveConfidence(answer) {
+		if (!answer.references.length) return .3;
+		const topScore = answer.references[0]?.score ?? .4;
+		const normalized = Math.min(1, Math.max(0, topScore));
+		const tokenPenalty = answer.usage?.completionTokens ? Math.min(answer.usage.completionTokens / 1e3, .2) : 0;
+		return Number((normalized - tokenPenalty).toFixed(2));
+	}
+};
+
+//#endregion
+export { TicketResolver };