@4djs/assistant 0.0.0

package/src/core/chat-history.ts

@@ -0,0 +1,113 @@
+import type { ChatActivityStep } from "./chat-activity.ts";
+import type { ReplySuggestions } from "./interactive-tools/index.ts";
+import { isValidReplySuggestions } from "./interactive-tools/index.ts";
+import type { AssistantMessage, AssistantWelcomeContext } from "./types.ts";
+
+const DEFAULT_HISTORY_KEY = "assistant-chat-history";
+const DEFAULT_MAX_STORED = 100;
+
+export interface ChatHistoryOptions {
+	storageKey?: string;
+	maxStored?: number;
+	welcomeMessage: (ctx: AssistantWelcomeContext) => AssistantMessage;
+}
+
+interface StoredChatMessage {
+	id: string;
+	role: "user" | "assistant" | "system";
+	content: string;
+	activity?: ChatActivityStep[];
+	toolCall?: { name: string; args: Record<string, unknown> };
+	replySuggestions?: ReplySuggestions;
+	isError?: boolean;
+	llmSetupRequired?: boolean;
+	timestamp: number;
+}
+
+function toStored(message: AssistantMessage): StoredChatMessage {
+	return {
+		id: message.id,
+		role: message.role,
+		content: message.content,
+		activity: message.activity,
+		toolCall: message.toolCall,
+		replySuggestions: message.replySuggestions,
+		isError: message.isError,
+		llmSetupRequired: message.llmSetupRequired,
+		timestamp: message.timestamp,
+	};
+}
+
+function fromStored(message: StoredChatMessage): AssistantMessage {
+	return {
+		id: message.id,
+		role: message.role,
+		content: message.content,
+		activity: message.activity,
+		toolCall: message.toolCall,
+		replySuggestions: isValidReplySuggestions(message.replySuggestions)
+			? message.replySuggestions
+			: undefined,
+		isError: message.isError,
+		llmSetupRequired: message.llmSetupRequired,
+		timestamp: message.timestamp,
+	};
+}
+
+function isStoredChatMessage(value: unknown): value is StoredChatMessage {
+	if (!value || typeof value !== "object") return false;
+	const message = value as StoredChatMessage;
+	return (
+		typeof message.id === "string" &&
+		(message.role === "user" ||
+			message.role === "assistant" ||
+			message.role === "system") &&
+		typeof message.content === "string" &&
+		typeof message.timestamp === "number"
+	);
+}
+
+export function createChatHistoryHelpers(options: ChatHistoryOptions) {
+	const storageKey = options.storageKey ?? DEFAULT_HISTORY_KEY;
+	const maxStored = options.maxStored ?? DEFAULT_MAX_STORED;
+
+	function getStored(): AssistantMessage[] | null {
+		try {
+			const raw = localStorage.getItem(storageKey);
+			if (!raw) return null;
+			const parsed: unknown = JSON.parse(raw);
+			if (!Array.isArray(parsed)) return null;
+			const messages = parsed.filter(isStoredChatMessage).map(fromStored);
+			return messages.length > 0 ? messages : null;
+		} catch {
+			return null;
+		}
+	}
+
+	function persist(messages: AssistantMessage[]) {
+		const storable = messages
+			.filter((message) => !message.streaming)
+			.slice(-maxStored)
+			.map(toStored);
+		localStorage.setItem(storageKey, JSON.stringify(storable));
+	}
+
+	function clear() {
+		localStorage.removeItem(storageKey);
+	}
+
+	function loadInitial(ctx: AssistantWelcomeContext): AssistantMessage[] {
+		const stored = getStored();
+		const welcome = options.welcomeMessage(ctx);
+		if (stored) {
+			const hasWelcome = stored.some((message) => message.id === "welcome");
+			if (hasWelcome) return stored;
+			return [welcome, ...stored];
+		}
+		return [welcome];
+	}
+
+	return { getStored, persist, clear, loadInitial };
+}
+
+export type { AssistantMessage };

package/src/core/chat-reply-suggestions-parse.ts

@@ -0,0 +1,119 @@
+export type SuggestionField = {
+	label: string;
+	value: string;
+};
+
+export type ParsedSuggestion =
+	| { kind: "compact"; text: string }
+	| {
+			kind: "structured";
+			title: string;
+			description?: string;
+			fields: SuggestionField[];
+			raw: string;
+	  }
+	| { kind: "custom"; text: string };
+
+const STRUCTURED_FIELD_LABELS = new Set([
+	"name",
+	"description",
+	"model",
+	"enabled",
+	"tools",
+	"prompt",
+	"agent",
+	"dataclass",
+	"filter",
+]);
+
+export function parseSuggestionText(text: string): ParsedSuggestion {
+	const trimmed = text.trim();
+	if (!trimmed) {
+		return { kind: "compact", text: trimmed };
+	}
+
+	if (isCustomDeclineSuggestion(trimmed)) {
+		return { kind: "custom", text: trimmed };
+	}
+
+	const fields = parseKeyValueFields(trimmed);
+	if (fields && fields.length >= 2) {
+		const nameField = fields.find(
+			(field) => field.label.toLowerCase() === "name",
+		);
+		const descriptionField = fields.find(
+			(field) => field.label.toLowerCase() === "description",
+		);
+		const detailFields = fields.filter(
+			(field) => !["name", "description"].includes(field.label.toLowerCase()),
+		);
+
+		return {
+			kind: "structured",
+			title: nameField?.value ?? trimmed,
+			description: descriptionField?.value,
+			fields: detailFields,
+			raw: trimmed,
+		};
+	}
+
+	if (trimmed.length <= 32 && !trimmed.includes(",")) {
+		return { kind: "compact", text: trimmed };
+	}
+
+	return { kind: "compact", text: trimmed };
+}
+
+function isCustomDeclineSuggestion(text: string): boolean {
+	return /\b(myself|my own|custom answer|provide the details|type my own|enter manually)\b/i.test(
+		text,
+	);
+}
+
+function parseKeyValueFields(text: string): SuggestionField[] | null {
+	const pattern = /([A-Za-z][A-Za-z\s]*?):\s*/g;
+	const matches = [...text.matchAll(pattern)];
+
+	if (matches.length < 2) {
+		return null;
+	}
+
+	const fields: SuggestionField[] = [];
+
+	for (let index = 0; index < matches.length; index += 1) {
+		const match = matches[index];
+		if (!match || match.index === undefined) {
+			continue;
+		}
+
+		const label = match[1]?.trim() ?? "";
+		if (!STRUCTURED_FIELD_LABELS.has(label.toLowerCase())) {
+			return null;
+		}
+
+		const valueStart = match.index + match[0].length;
+		const nextMatch = matches[index + 1];
+		const valueEnd = nextMatch?.index ?? text.length;
+		const value = text.slice(valueStart, valueEnd).replace(/,\s*$/, "").trim();
+
+		if (!label || !value) {
+			return null;
+		}
+
+		fields.push({ label, value });
+	}
+
+	return fields.length >= 2 ? fields : null;
+}
+
+export function splitToolValues(value: string): string[] {
+	const normalized = value.trim();
+	if (!normalized || /^none$/i.test(normalized)) {
+		return [];
+	}
+
+	return normalized
+		.split(/,\s*/)
+		.map((entry) => entry.trim())
+		.filter(Boolean);
+}

package/src/core/code-highlight.ts

@@ -0,0 +1,20 @@
+import hljs from "highlight.js/lib/core";
+import jsonLang from "highlight.js/lib/languages/json";
+import markdownLang from "highlight.js/lib/languages/markdown";
+
+hljs.registerLanguage("json", jsonLang);
+hljs.registerLanguage("markdown", markdownLang);
+
+export function normalizeCodeLineEndings(code: string): string {
+	return code.replace(/\r\n?/g, "\n");
+}
+
+export function highlightCode(code: string, language: string | null): string {
+	const source = normalizeCodeLineEndings(code);
+
+	if (language && hljs.getLanguage(language)) {
+		return hljs.highlight(source, { language, ignoreIllegals: true }).value;
+	}
+
+	return hljs.highlightAuto(source).value;
+}