@antelopejs/dms-ai 0.1.3 → 0.1.5

package/frontend-vue/app/chat/types/conversation.ts

@@ -0,0 +1,87 @@
+import type { ACTIVITY_KINDS } from "../constants/run-status";
+import type { PendingAttachment } from "../utils/attachments";
+
+export type MessageRole = "user" | "assistant" | "tool" | "error";
+export type ToolStatus = "pending" | "success" | "error";
+export type ActivityKind = (typeof ACTIVITY_KINDS)[keyof typeof ACTIVITY_KINDS];
+
+/**
+ * A file attached to a user message. `dataUrl` is only present for messages
+ * sent in this session (drives the image thumbnail); after a reload the
+ * snapshot carries just the metadata, so it is absent.
+ */
+export interface MessageAttachment {
+	name: string;
+	mimeType: string;
+	size: number;
+	dataUrl?: string;
+}
+
+export interface UserMessage {
+	id: string;
+	role: "user";
+	content: string;
+	attachments?: MessageAttachment[];
+	isUnsent?: boolean;
+	timestampMs: number;
+}
+
+export interface AssistantMessage {
+	id: string;
+	role: "assistant";
+	content: string;
+	timestampMs: number;
+}
+
+/** Why a run stopped or a message could not be sent, with a way to retry. */
+export interface ErrorMessage {
+	id: string;
+	role: "error";
+	content: string;
+	isRetryable: boolean;
+	timestampMs: number;
+}
+
+/**
+ * What the running turn is doing, as last reported by the sidecar.
+ * `receivedAtMs` is the local time of that report, from which the elapsed and
+ * quiet durations keep counting until the next one.
+ */
+export interface RunProgress {
+	activity: ActivityKind;
+	detail?: string;
+	elapsedMs: number;
+	idleMs: number;
+	receivedAtMs: number;
+}
+
+export interface ToolCallMessage {
+	id: string;
+	role: "tool";
+	callId: string;
+	toolName: string;
+	args: unknown;
+	result?: unknown;
+	status: ToolStatus;
+	timestampMs: number;
+}
+
+export type ConversationMessage =
+	| UserMessage
+	| AssistantMessage
+	| ToolCallMessage
+	| ErrorMessage;
+
+export interface QueuedMessage {
+	id: string;
+	content: string;
+	attachments: PendingAttachment[];
+}
+
+export interface ConversationSummary {
+	id: string;
+	title: string;
+	createdAtMs: number;
+	updatedAtMs: number;
+	messageCount: number;
+}

package/frontend-vue/app/chat/types/permission.ts

@@ -0,0 +1,7 @@
+export interface PermissionRequestData {
+	requestId: string;
+	conversationId: string;
+	toolName: string;
+	args: unknown;
+	summary: string;
+}

package/frontend-vue/app/chat/types/question.ts

@@ -0,0 +1,17 @@
+export interface QuestionOptionData {
+	label: string;
+	description: string;
+	preview?: string;
+}
+
+export interface QuestionData {
+	question: string;
+	header: string;
+	options: QuestionOptionData[];
+}
+
+export interface QuestionRequestData {
+	requestId: string;
+	conversationId: string;
+	questions: QuestionData[];
+}

package/frontend-vue/app/chat/types/settings.ts

@@ -0,0 +1,27 @@
+export type ChatMode = "normal" | "acceptEdits" | "plan" | "auto";
+export type ThinkingLevel = "off" | "low" | "medium" | "high";
+export type GenerationMode = "safe" | "vibe";
+export type ProviderName = "claude" | "codex";
+
+export interface ProviderAvailability {
+	available: boolean;
+	/** Why the provider cannot be picked; absent when it is available. */
+	reason?: string;
+}
+
+export interface AppSettings {
+	provider: ProviderName;
+	mode: ChatMode;
+	thinking: ThinkingLevel;
+	generationMode: GenerationMode;
+	allowLocalSkills: boolean;
+	/**
+	 * Read-only capability pushed by the sidecar: whether the Builder is present.
+	 */
+	builderAvailable: boolean;
+	/**
+	 * Read-only capability pushed by the sidecar: which backends this install can
+	 * actually drive.
+	 */
+	providers: Record<ProviderName, ProviderAvailability>;
+}

package/frontend-vue/app/chat/utils/attachments.ts

@@ -0,0 +1,62 @@
+import {
+	INLINE_IMAGE_MIME_TYPES,
+	MAX_ATTACHMENT_BYTES,
+} from "../constants/attachments";
+import { newUuid } from "./ids";
+
+/**
+ * A file the user has staged in the composer. `data` is the base64 payload (no
+ * `data:` prefix) sent to the sidecar; `dataUrl` is the full data URL kept for
+ * local image previews.
+ */
+export interface PendingAttachment {
+	id: string;
+	name: string;
+	mimeType: string;
+	size: number;
+	data: string;
+	dataUrl: string;
+}
+
+export function isInlineImage(mimeType: string): boolean {
+	return (INLINE_IMAGE_MIME_TYPES as readonly string[]).includes(mimeType);
+}
+
+export function formatBytes(size: number): string {
+	if (size < 1024) return `${size} B`;
+	if (size < 1024 * 1024) return `${(size / 1024).toFixed(0)} KB`;
+	return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export function exceedsSizeLimit(file: File): boolean {
+	return file.size > MAX_ATTACHMENT_BYTES;
+}
+
+/** The base64 payload of a data URL, without its `data:…;base64,` prefix. */
+export function splitDataUrl(dataUrl: string): string {
+	const comma = dataUrl.indexOf(",");
+	return comma >= 0 ? dataUrl.slice(comma + 1) : dataUrl;
+}
+
+/**
+ * Read a File into a PendingAttachment (base64 + data URL) via FileReader. The
+ * browser never exposes the real disk path, so we always carry the bytes.
+ */
+export function readFileAsAttachment(file: File): Promise<PendingAttachment> {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onerror = () => reject(reader.error ?? new Error("read failed"));
+		reader.onload = () => {
+			const dataUrl = String(reader.result);
+			resolve({
+				id: newUuid(),
+				name: file.name,
+				mimeType: file.type || "application/octet-stream",
+				size: file.size,
+				data: splitDataUrl(dataUrl),
+				dataUrl,
+			});
+		};
+		reader.readAsDataURL(file);
+	});
+}

package/frontend-vue/app/chat/utils/format.ts

@@ -0,0 +1,14 @@
+/**
+ * Render an arbitrary tool argument / result value for display: strings pass
+ * through, everything else is pretty-printed JSON, with a safe fallback for
+ * values JSON can't serialize (e.g. circular refs).
+ */
+export function stringifyValue(value: unknown): string {
+	if (value === undefined) return "";
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}

package/frontend-vue/app/chat/utils/ids.ts

@@ -0,0 +1,34 @@
+const UUID_BYTE_COUNT = 16;
+const VERSION_BYTE_INDEX = 6;
+const VARIANT_BYTE_INDEX = 8;
+const VERSION_MASK = 0x0f;
+const VERSION_4 = 0x40;
+const VARIANT_MASK = 0x3f;
+const VARIANT_RFC_4122 = 0x80;
+const HEX_RADIX = 16;
+const HEX_BYTE_WIDTH = 2;
+const UUID_GROUP_ENDS = [8, 12, 16, 20, 32];
+
+function formatUuid(bytes: Uint8Array): string {
+	const hex = Array.from(bytes, (byte) =>
+		byte.toString(HEX_RADIX).padStart(HEX_BYTE_WIDTH, "0"),
+	).join("");
+	return UUID_GROUP_ENDS.map((end, index) =>
+		hex.slice(UUID_GROUP_ENDS[index - 1] ?? 0, end),
+	).join("-");
+}
+
+/**
+ * A random v4 UUID. `crypto.randomUUID` only exists in secure contexts, and the
+ * chat is also opened over plain HTTP from another machine (a LAN or Tailscale
+ * address), where `crypto.getRandomValues` is still there.
+ */
+export function newUuid(): string {
+	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	const bytes = crypto.getRandomValues(new Uint8Array(UUID_BYTE_COUNT));
+	bytes[VERSION_BYTE_INDEX] =
+		(bytes[VERSION_BYTE_INDEX] & VERSION_MASK) | VERSION_4;
+	bytes[VARIANT_BYTE_INDEX] =
+		(bytes[VARIANT_BYTE_INDEX] & VARIANT_MASK) | VARIANT_RFC_4122;
+	return formatUuid(bytes);
+}

package/frontend-vue/app/chat/utils/markdown.ts

@@ -0,0 +1,188 @@
+import DOMPurify, { type Config, type DOMPurify as Purifier } from "dompurify";
+import MarkdownIt, { type Token } from "markdown-it";
+
+const ALLOWED_TAGS = [
+	"a",
+	"blockquote",
+	"br",
+	"code",
+	"del",
+	"em",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"hr",
+	"li",
+	"ol",
+	"p",
+	"pre",
+	"s",
+	"strong",
+	"table",
+	"tbody",
+	"td",
+	"th",
+	"thead",
+	"tr",
+	"ul",
+];
+
+const ALLOWED_ATTR = ["href", "title", "target", "rel", "start"];
+
+const SAFE_URL = /^(?:(?:https?|mailto):|[^a-z]|[a-z+.-]+(?:[^a-z+.\-:]|$))/i;
+
+const SANITIZE_CONFIG: Config = {
+	ALLOWED_TAGS,
+	ALLOWED_ATTR,
+	ALLOWED_URI_REGEXP: SAFE_URL,
+	ALLOW_DATA_ATTR: false,
+	ALLOW_ARIA_ATTR: false,
+	ALLOW_UNKNOWN_PROTOCOLS: false,
+};
+
+const LINK_TARGET = "_blank";
+const LINK_REL = "noopener noreferrer";
+const NEWLINES = /\r\n?/g;
+const LINE_BREAK = "\n";
+
+const md = new MarkdownIt({
+	html: false,
+	linkify: true,
+	breaks: true,
+});
+
+md.validateLink = (url) => SAFE_URL.test(url.trim());
+
+md.renderer.rules.link_open = (tokens, idx, options, _env, self) => {
+	tokens[idx].attrSet("target", LINK_TARGET);
+	tokens[idx].attrSet("rel", LINK_REL);
+	return self.renderToken(tokens, idx, options);
+};
+
+function imageDestination(src: string): string {
+	try {
+		return new URL(src).host || src;
+	} catch {
+		return src;
+	}
+}
+
+function imageLinkLabel(alt: string, src: string): string {
+	const destination = imageDestination(src);
+	return alt ? `${alt} (${destination})` : destination;
+}
+
+md.renderer.rules.image = (tokens, idx, options, env, self) => {
+	const token = tokens[idx];
+	const src = token.attrGet("src") ?? "";
+	const alt = self.renderInlineAsText(token.children ?? [], options, env);
+	const label = md.utils.escapeHtml(imageLinkLabel(alt, src));
+	return `<a href="${md.utils.escapeHtml(src)}" target="${LINK_TARGET}" rel="${LINK_REL}">${label}</a>`;
+};
+
+let purifier: Purifier | null = null;
+
+function getPurifier(): Purifier {
+	if (purifier !== null) return purifier;
+	purifier = DOMPurify(globalThis.window);
+	purifier.addHook("afterSanitizeAttributes", (node) => {
+		if (node.tagName !== "A" || !node.hasAttribute("href")) return;
+		node.setAttribute("target", LINK_TARGET);
+		node.setAttribute("rel", LINK_REL);
+	});
+	return purifier;
+}
+
+function sanitize(html: string): string {
+	return getPurifier().sanitize(html, SANITIZE_CONFIG);
+}
+
+function normalize(source: string): string {
+	return (source ?? "").replace(NEWLINES, LINE_BREAK);
+}
+
+/** Model output as sanitized HTML, whole. */
+export function renderMarkdown(source: string): string {
+	return sanitize(md.render(normalize(source)));
+}
+
+interface TopLevelBlock {
+	tokens: Token[];
+	startLine: number;
+}
+
+function splitTopLevelBlocks(tokens: Token[]): TopLevelBlock[] {
+	const blocks: TopLevelBlock[] = [];
+	for (const token of tokens) {
+		const map = token.map;
+		const opensBlock =
+			token.level === 0 && token.nesting !== -1 && map !== null;
+		if (opensBlock) blocks.push({ tokens: [token], startLine: map[0] });
+		else blocks.at(-1)?.tokens.push(token);
+	}
+	return blocks;
+}
+
+function lineOffset(text: string, line: number): number {
+	let offset = 0;
+	for (let index = 0; index < line; index += 1) {
+		const next = text.indexOf(LINE_BREAK, offset);
+		if (next === -1) return text.length;
+		offset = next + 1;
+	}
+	return offset;
+}
+
+export interface MarkdownBlocks {
+	/** Top-level blocks that the text still to come can no longer change. */
+	settled: readonly string[];
+	/** The last block, which the next text may still extend. */
+	open: string;
+}
+
+export interface IncrementalMarkdown {
+	/** Renders `source`, reusing the settled blocks of the text it extends. */
+	render: (source: string) => MarkdownBlocks;
+}
+
+interface IncrementalState {
+	settledSource: string;
+	settled: string[];
+	env: Record<string, unknown>;
+}
+
+function renderBlock(block: TopLevelBlock, state: IncrementalState): string {
+	return sanitize(md.renderer.render(block.tokens, md.options, state.env));
+}
+
+function renderIncrement(
+	state: IncrementalState,
+	text: string,
+): MarkdownBlocks {
+	if (!text.startsWith(state.settledSource)) {
+		state.settledSource = "";
+		state.settled = [];
+		state.env = {};
+	}
+	const rest = text.slice(state.settledSource.length);
+	const blocks = splitTopLevelBlocks(md.parse(rest, state.env));
+	const open = blocks.pop();
+	if (open === undefined) return { settled: [...state.settled], open: "" };
+	for (const block of blocks) state.settled.push(renderBlock(block, state));
+	state.settledSource += rest.slice(0, lineOffset(rest, open.startLine));
+	return { settled: [...state.settled], open: renderBlock(open, state) };
+}
+
+/**
+ * Renders a message while it streams at a cost bounded by its last block: a
+ * top-level block is settled once markdown-it starts the next one, and is then
+ * rendered and sanitized once. Re-rendering the whole message on every chunk
+ * made a long answer quadratic, on the dashboard's own thread.
+ */
+export function createIncrementalMarkdown(): IncrementalMarkdown {
+	const state: IncrementalState = { settledSource: "", settled: [], env: {} };
+	return { render: (source) => renderIncrement(state, normalize(source)) };
+}

package/frontend-vue/app/chat/utils/run-status.ts

@@ -0,0 +1,90 @@
+import {
+	ACTIVITY_ELLIPSIS,
+	ACTIVITY_KINDS,
+	ACTIVITY_LABELS,
+	DEFAULT_ACTIVITY_LABEL,
+	QUIET_NOTICE_AFTER_MS,
+	SILENT_ACTIVITIES,
+	STALL_AFTER_MS,
+	TOOL_DETAIL_ACTIVITIES,
+} from "../constants/run-status";
+import type { ActivityKind, RunProgress } from "../types/conversation";
+import { toolLabel } from "./tool-summary";
+
+const MS_PER_SECOND = 1_000;
+const SECONDS_PER_MINUTE = 60;
+const SECONDS_WIDTH = 2;
+const DETAIL_SEPARATOR = " · ";
+
+const KNOWN_ACTIVITIES: readonly string[] = Object.values(ACTIVITY_KINDS);
+
+/** A reported activity, read as thinking when this chat does not know it. */
+export function toActivityKind(reported: string): ActivityKind {
+	if (!KNOWN_ACTIVITIES.includes(reported)) return ACTIVITY_KINDS.THINKING;
+	return reported as ActivityKind;
+}
+
+/** A duration as m:ss. */
+export function formatClock(ms: number): string {
+	const totalSeconds = Math.max(0, Math.floor(ms / MS_PER_SECOND));
+	const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE);
+	const seconds = String(totalSeconds % SECONDS_PER_MINUTE).padStart(
+		SECONDS_WIDTH,
+		"0",
+	);
+	return `${minutes}:${seconds}`;
+}
+
+function describeDetail(progress: RunProgress): string {
+	if (progress.detail === undefined || progress.detail === "") return "";
+	const namesTool = TOOL_DETAIL_ACTIVITIES.includes(progress.activity);
+	const detail = namesTool ? toolLabel(progress.detail) : progress.detail;
+	return `${DETAIL_SEPARATOR}${detail}`;
+}
+
+/** The line a running turn shows: what the agent is doing, and on what. */
+export function describeActivity(progress: RunProgress | null): string {
+	if (progress === null) return `${DEFAULT_ACTIVITY_LABEL}${ACTIVITY_ELLIPSIS}`;
+	const label = ACTIVITY_LABELS[progress.activity];
+	return `${label}${describeDetail(progress)}${ACTIVITY_ELLIPSIS}`;
+}
+
+function sinceReport(progress: RunProgress, nowMs: number): number {
+	return Math.max(0, nowMs - progress.receivedAtMs);
+}
+
+/** Time since the turn started, counted on from the last report. */
+export function runElapsedMs(
+	progress: RunProgress | null,
+	nowMs: number,
+): number {
+	if (progress === null) return 0;
+	return progress.elapsedMs + sinceReport(progress, nowMs);
+}
+
+/** Time since the agent last did anything, counted on from the last report. */
+export function agentQuietMs(
+	progress: RunProgress | null,
+	nowMs: number,
+): number {
+	if (progress === null) return 0;
+	return progress.idleMs + sinceReport(progress, nowMs);
+}
+
+/** Whether the agent has been quiet long enough for the chat to say so. */
+export function isAgentQuiet(
+	progress: RunProgress | null,
+	nowMs: number,
+): boolean {
+	if (progress === null) return false;
+	if (SILENT_ACTIVITIES.includes(progress.activity)) return false;
+	return agentQuietMs(progress, nowMs) >= QUIET_NOTICE_AFTER_MS;
+}
+
+/**
+ * Whether the sidecar has said nothing about a running turn, heartbeats
+ * included, for so long that the chat can no longer vouch for it.
+ */
+export function isRunStalled(lastEventAtMs: number, nowMs: number): boolean {
+	return nowMs - lastEventAtMs >= STALL_AFTER_MS;
+}

package/frontend-vue/app/chat/utils/todos.ts

@@ -0,0 +1,64 @@
+import {
+	MESSAGE_ROLES,
+	TODO_STATUS,
+	TODO_WRITE_TOOL_NAME,
+} from "../constants/conversation";
+import type {
+	ConversationMessage,
+	ToolCallMessage,
+} from "../types/conversation";
+
+export type TodoItemStatus = "pending" | "in_progress" | "completed";
+
+export interface TodoItem {
+	content: string;
+	status: TodoItemStatus;
+	activeForm: string;
+}
+
+const TODO_STATUS_VALUES: readonly TodoItemStatus[] = [
+	TODO_STATUS.PENDING,
+	TODO_STATUS.IN_PROGRESS,
+	TODO_STATUS.COMPLETED,
+];
+
+function toStatus(value: unknown): TodoItemStatus {
+	return TODO_STATUS_VALUES.includes(value as TodoItemStatus)
+		? (value as TodoItemStatus)
+		: TODO_STATUS.PENDING;
+}
+
+function toTodo(value: unknown): TodoItem | null {
+	if (value === null || typeof value !== "object") return null;
+	const record = value as Record<string, unknown>;
+	const content = typeof record.content === "string" ? record.content : "";
+	if (content.length === 0) return null;
+	const activeForm =
+		typeof record.activeForm === "string" && record.activeForm.length > 0
+			? record.activeForm
+			: content;
+	return { content, status: toStatus(record.status), activeForm };
+}
+
+export function extractTodos(args: unknown): TodoItem[] {
+	if (args === null || typeof args !== "object") return [];
+	const todos = (args as Record<string, unknown>).todos;
+	if (!Array.isArray(todos)) return [];
+	return todos.map(toTodo).filter((todo): todo is TodoItem => todo !== null);
+}
+
+export function isTodoWrite(message: ConversationMessage): boolean {
+	return (
+		message.role === MESSAGE_ROLES.TOOL &&
+		message.toolName === TODO_WRITE_TOOL_NAME
+	);
+}
+
+export function latestTodos(messages: ConversationMessage[]): TodoItem[] {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (!isTodoWrite(message)) continue;
+		return extractTodos((message as ToolCallMessage).args);
+	}
+	return [];
+}

package/frontend-vue/app/chat/utils/tool-summary.ts

@@ -0,0 +1,53 @@
+const MAX_DETAIL_CHARS = 80;
+const TRUNCATE_SUFFIX = "...";
+
+const TOOL_LABELS: Record<string, string> = {
+	Bash: "Run shell command",
+	Edit: "Edit file",
+	Write: "Write file",
+	Read: "Read file",
+	Glob: "Glob pattern",
+	Grep: "Grep pattern",
+};
+
+const DETAIL_ARG_KEYS: Record<string, string> = {
+	Bash: "command",
+	Edit: "file_path",
+	Write: "file_path",
+	Read: "file_path",
+	Glob: "pattern",
+	Grep: "pattern",
+};
+
+function shorten(value: string): string {
+	if (value.length <= MAX_DETAIL_CHARS) return value;
+	const sliceEnd = MAX_DETAIL_CHARS - TRUNCATE_SUFFIX.length;
+	return `${value.slice(0, sliceEnd)}${TRUNCATE_SUFFIX}`;
+}
+
+function readString(args: unknown, key: string): string {
+	if (args === null || typeof args !== "object") return "";
+	const value = (args as Record<string, unknown>)[key];
+	return typeof value === "string" ? value : "";
+}
+
+function detailFor(toolName: string, args: unknown): string {
+	const argKey = DETAIL_ARG_KEYS[toolName];
+	if (argKey === undefined) return "";
+	return shorten(readString(args, argKey));
+}
+
+/**
+ * Mirror of the sidecar's tool-summary helper: a tool name and its args as a
+ * short line for the collapsed cluster summary and the per-tool rows. Kept
+ * small: the server already sends a `summary` on permission requests; this
+ * only covers streamed tool calls, which carry raw args instead.
+ */
+export function toolSummary(toolName: string, args: unknown): string {
+	const detail = detailFor(toolName, args);
+	return detail.length > 0 ? detail : toolName;
+}
+
+export function toolLabel(toolName: string): string {
+	return TOOL_LABELS[toolName] ?? toolName;
+}