@antelopejs/dms-ai 0.1.5 → 0.2.0

package/frontend-vue/app/chat/utils/conversation-messages.ts

@@ -0,0 +1,251 @@
+import {
+	MESSAGE_ROLES,
+	STORED_ERROR_ROLE,
+	STORED_TOOL_RESULT_ROLE,
+	STORED_TOOL_USE_ROLE,
+	TOOL_STATUS,
+} from "../constants/conversation";
+import type {
+	AssistantMessage,
+	ConversationMessage,
+	ErrorMessage,
+	MessageAttachment,
+	ToolCallMessage,
+	ToolStatus,
+	UserMessage,
+} from "../types/conversation";
+import type { SnapshotMessage, ToolOutcome } from "../types/protocol";
+import { newUuid } from "./ids";
+
+const STOPPED_OUTCOME: ToolOutcome = "stopped";
+
+const STATUS_BY_OUTCOME: Record<ToolOutcome, ToolStatus> = {
+	done: TOOL_STATUS.SUCCESS,
+	failed: TOOL_STATUS.ERROR,
+	denied: TOOL_STATUS.ERROR,
+	blocked: TOOL_STATUS.ERROR,
+	stopped: TOOL_STATUS.ERROR,
+};
+
+export function buildUserMessage(
+	content: string,
+	attachments?: MessageAttachment[],
+	pagePath?: string,
+	timestampMs: number = Date.now(),
+): UserMessage {
+	return {
+		id: newUuid(),
+		role: MESSAGE_ROLES.USER,
+		content,
+		attachments,
+		pagePath,
+		timestampMs,
+	};
+}
+
+export function buildAssistantMessage(
+	content: string,
+	timestampMs: number = Date.now(),
+): AssistantMessage {
+	return {
+		id: newUuid(),
+		role: MESSAGE_ROLES.ASSISTANT,
+		content,
+		timestampMs,
+	};
+}
+
+export function buildErrorMessage(
+	content: string,
+	isRetryable: boolean,
+	timestampMs: number = Date.now(),
+): ErrorMessage {
+	return {
+		id: newUuid(),
+		role: MESSAGE_ROLES.ERROR,
+		content,
+		isRetryable,
+		timestampMs,
+	};
+}
+
+/** An error the chat raises itself, translated when drawn. */
+export function buildLocalError(
+	contentKey: string,
+	isRetryable = true,
+): ErrorMessage {
+	return {
+		...buildErrorMessage("", isRetryable),
+		contentKey,
+		isLocal: true,
+	};
+}
+
+function normalizeToolStatus(raw: string | undefined): ToolStatus {
+	if (raw === TOOL_STATUS.SUCCESS) return TOOL_STATUS.SUCCESS;
+	if (raw === TOOL_STATUS.ERROR) return TOOL_STATUS.ERROR;
+	return TOOL_STATUS.PENDING;
+}
+
+/** The status a closed call reports: its outcome's, else the wire status. */
+export function closedStatus(
+	outcome: ToolOutcome | undefined,
+	status: string | undefined,
+): ToolStatus {
+	if (outcome !== undefined) return STATUS_BY_OUTCOME[outcome];
+	const normalized = normalizeToolStatus(status);
+	return normalized === TOOL_STATUS.PENDING ? TOOL_STATUS.SUCCESS : normalized;
+}
+
+function safeParse(raw: string): unknown {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+
+function isOpenTool(msg: ConversationMessage): msg is ToolCallMessage {
+	return (
+		msg.role === MESSAGE_ROLES.TOOL &&
+		msg.outcome === undefined &&
+		msg.status === TOOL_STATUS.PENDING
+	);
+}
+
+/** Calls a finished turn left open: it ended before they did. */
+export function settleOpenTools(
+	list: ConversationMessage[],
+): ConversationMessage[] {
+	if (!list.some(isOpenTool)) return list;
+	return list.map((msg) => {
+		if (!isOpenTool(msg)) return msg;
+		return { ...msg, status: TOOL_STATUS.ERROR, outcome: STOPPED_OUTCOME };
+	});
+}
+
+interface SnapshotBuild {
+	out: ConversationMessage[];
+	toolByCallId: Map<string, ToolCallMessage>;
+}
+
+function toolFromUse(snap: SnapshotMessage): ToolCallMessage | null {
+	if (snap.callId === undefined || snap.toolName === undefined) return null;
+	return {
+		id: newUuid(),
+		role: MESSAGE_ROLES.TOOL,
+		callId: snap.callId,
+		toolName: snap.toolName,
+		args: safeParse(snap.content),
+		status: TOOL_STATUS.PENDING,
+		allowedBy: snap.allowedBy,
+		timestampMs: snap.timestampMs,
+	};
+}
+
+function closeFromResult(tool: ToolCallMessage, snap: SnapshotMessage): void {
+	tool.result = safeParse(snap.content);
+	tool.status = closedStatus(snap.outcome, snap.status);
+	tool.outcome = snap.outcome;
+	tool.allowedBy = snap.allowedBy ?? tool.allowedBy;
+	tool.changeSetId = snap.changeSetId;
+	tool.endedAtMs = snap.timestampMs;
+}
+
+function addToolUse(build: SnapshotBuild, snap: SnapshotMessage): void {
+	const tool = toolFromUse(snap);
+	if (tool === null) return;
+	build.out.push(tool);
+	build.toolByCallId.set(tool.callId, tool);
+}
+
+function addToolResult(build: SnapshotBuild, snap: SnapshotMessage): void {
+	if (snap.callId === undefined) return;
+	const existing = build.toolByCallId.get(snap.callId);
+	if (existing !== undefined) {
+		closeFromResult(existing, snap);
+		return;
+	}
+	const orphan = toolFromUse({ ...snap, toolName: snap.toolName ?? "" });
+	if (orphan === null) return;
+	closeFromResult(orphan, snap);
+	build.out.push(orphan);
+}
+
+function addUser(build: SnapshotBuild, snap: SnapshotMessage): void {
+	build.out.push(
+		buildUserMessage(
+			snap.content,
+			snap.attachments,
+			undefined,
+			snap.timestampMs,
+		),
+	);
+}
+
+function addAssistant(build: SnapshotBuild, snap: SnapshotMessage): void {
+	build.out.push(buildAssistantMessage(snap.content, snap.timestampMs));
+}
+
+function addError(build: SnapshotBuild, snap: SnapshotMessage): void {
+	build.out.push(
+		buildErrorMessage(snap.content, snap.isRetryable ?? true, snap.timestampMs),
+	);
+}
+
+function addNotice(build: SnapshotBuild, snap: SnapshotMessage): void {
+	if (snap.notice === undefined) return;
+	build.out.push({
+		id: newUuid(),
+		role: MESSAGE_ROLES.NOTICE,
+		notice: snap.notice,
+		timestampMs: snap.timestampMs,
+	});
+}
+
+function addChangeSet(build: SnapshotBuild, snap: SnapshotMessage): void {
+	if (snap.changeSetId === undefined) return;
+	build.out.push({
+		id: newUuid(),
+		role: MESSAGE_ROLES.CHANGE_SET,
+		changeSetId: snap.changeSetId,
+		timestampMs: snap.timestampMs,
+	});
+}
+
+function addQuestionAnswer(build: SnapshotBuild, snap: SnapshotMessage): void {
+	if (snap.answers === undefined || snap.answers.length === 0) return;
+	build.out.push({
+		id: newUuid(),
+		role: MESSAGE_ROLES.QUESTION_ANSWER,
+		answers: snap.answers,
+		timestampMs: snap.timestampMs,
+	});
+}
+
+const SNAPSHOT_BUILDERS: Record<
+	string,
+	(build: SnapshotBuild, snap: SnapshotMessage) => void
+> = {
+	[MESSAGE_ROLES.USER]: addUser,
+	[MESSAGE_ROLES.ASSISTANT]: addAssistant,
+	[STORED_ERROR_ROLE]: addError,
+	[STORED_TOOL_USE_ROLE]: addToolUse,
+	[STORED_TOOL_RESULT_ROLE]: addToolResult,
+	[MESSAGE_ROLES.NOTICE]: addNotice,
+	[MESSAGE_ROLES.CHANGE_SET]: addChangeSet,
+	[MESSAGE_ROLES.QUESTION_ANSWER]: addQuestionAnswer,
+};
+
+/**
+ * The stored transcript as the chat draws it. Calls left open stay open: the
+ * turn may be resuming, and the row tells running from stopped by whether it
+ * is.
+ */
+export function snapshotToMessages(
+	snapshot: readonly SnapshotMessage[],
+): ConversationMessage[] {
+	const build: SnapshotBuild = { out: [], toolByCallId: new Map() };
+	for (const item of snapshot) SNAPSHOT_BUILDERS[item.role]?.(build, item);
+	return build.out;
+}

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

@@ -0,0 +1,78 @@
+import type { DiffHunk, DiffLine } from "../types/protocol";
+
+type DiffRowKind = "hunk" | "context" | "add" | "remove";
+
+/** One line of a unified diff as drawn: number, sign, text. */
+export interface DiffRow {
+	key: string;
+	kind: DiffRowKind;
+	/** The line's number in the file it belongs to: new for added and context, old for removed. */
+	number: string;
+	sign: string;
+	text: string;
+}
+
+const SIGN_BY_KIND: Record<DiffLine["kind"], string> = {
+	context: "",
+	add: "+",
+	remove: "−",
+};
+
+function lineNumber(line: DiffLine): string {
+	const value = line.kind === "remove" ? line.oldLine : line.newLine;
+	return value === undefined ? "" : String(value);
+}
+
+function hunkHeader(hunk: DiffHunk): string {
+	return `@@ −${hunk.oldStart} +${hunk.newStart} @@`;
+}
+
+/**
+ * Rows of a unified diff with line numbers, each hunk led by its header.
+ * Numbers the sidecar left out are counted from the hunk's start.
+ */
+export function diffRows(hunks: readonly DiffHunk[]): DiffRow[] {
+	return hunks.flatMap((hunk, hunkIndex) => {
+		let oldLine = hunk.oldStart;
+		let newLine = hunk.newStart;
+		const header: DiffRow = {
+			key: `h${hunkIndex}`,
+			kind: "hunk",
+			number: "",
+			sign: "",
+			text: hunkHeader(hunk),
+		};
+		const lines = hunk.lines.map((line, lineIndex): DiffRow => {
+			const numbered: DiffLine = {
+				...line,
+				oldLine: line.oldLine ?? (line.kind === "add" ? undefined : oldLine),
+				newLine: line.newLine ?? (line.kind === "remove" ? undefined : newLine),
+			};
+			if (line.kind !== "add") oldLine += 1;
+			if (line.kind !== "remove") newLine += 1;
+			return {
+				key: `h${hunkIndex}l${lineIndex}`,
+				kind: line.kind,
+				number: lineNumber(numbered),
+				sign: SIGN_BY_KIND[line.kind],
+				text: line.text,
+			};
+		});
+		return [header, ...lines];
+	});
+}
+
+export interface LimitedRows {
+	rows: DiffRow[];
+	/** How many more rows the full diff has. */
+	hidden: number;
+}
+
+/** The first `limit` rows of a diff. */
+export function limitRows(
+	rows: readonly DiffRow[],
+	limit: number,
+): LimitedRows {
+	if (rows.length <= limit) return { rows: [...rows], hidden: 0 };
+	return { rows: rows.slice(0, limit), hidden: rows.length - limit };
+}

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

@@ -1,3 +1,9 @@
+const THOUSAND = 1_000;
+const MILLION = 1_000_000;
+const MS_PER_SECOND = 1_000;
+const SECONDS_PER_MINUTE = 60;
+const SECONDS_WIDTH = 2;
+
 /**
  * Render an arbitrary tool argument / result value for display: strings pass
  * through, everything else is pretty-printed JSON, with a safe fallback for
@@ -12,3 +18,40 @@ export function stringifyValue(value: unknown): string {
 		return String(value);
 	}
 }
+
+function trimZero(value: number): string {
+	return value.toFixed(1).replace(/\.0$/, "");
+}
+
+/** A token count as the composer and the drawer show it: 840, 9.6k, 1.2M. */
+export function formatTokens(count: number): string {
+	if (count < THOUSAND) return String(Math.max(0, Math.round(count)));
+	if (count < MILLION) return `${trimZero(count / THOUSAND)}k`;
+	return `${trimZero(count / MILLION)}M`;
+}
+
+/** 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}`;
+}
+
+/** A tool's run time: 0.6s under a minute, m:ss beyond. */
+export function formatDuration(ms: number): string {
+	if (ms < SECONDS_PER_MINUTE * MS_PER_SECOND)
+		return `${trimZero(ms / MS_PER_SECOND)}s`;
+	return formatClock(ms);
+}
+
+/** A time of day in the interface language, 14:02. */
+export function formatTimeOfDay(timestampMs: number, locale: string): string {
+	return new Date(timestampMs).toLocaleTimeString(locale, {
+		hour: "2-digit",
+		minute: "2-digit",
+	});
+}

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

@@ -136,7 +136,7 @@ function lineOffset(text: string, line: number): number {
 	return offset;
 }
 
-export interface MarkdownBlocks {
+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. */

package/frontend-vue/app/chat/utils/permission-view.ts

@@ -0,0 +1,159 @@
+import type { PermissionRequestData } from "../types/permission";
+import type { Translate } from "../composables/useChatI18n";
+import type {
+	CommandPreview,
+	DestructivePreview,
+	DiffPreview,
+	PermissionPreview,
+	PermissionRule,
+	RuleKind,
+	WebPreview,
+} from "../types/protocol";
+import { bareToolName, describeTool, toolVerb } from "./tool-lexicon";
+
+/** How a card names its request, in the user's language. */
+export interface PermissionCardText {
+	title: string;
+	sub: string;
+	/** "Only this edit", "Only this command"… */
+	onceLabel: string;
+	allowLabel: string;
+	/** Why the request asks even where most do not; empty when it needs no word. */
+	why: string;
+}
+
+const PATH_SEPARATOR = "/";
+
+function baseName(path: string): string {
+	return path.split(PATH_SEPARATOR).filter(Boolean).at(-1) ?? path;
+}
+
+function verbAndTarget(req: PermissionRequestData, t: Translate): string {
+	const description = describeTool(req.toolName, req.args);
+	const verb = toolVerb(description, t);
+	return description.target === "" ? verb : `${verb} ${description.target}`;
+}
+
+type TextBuilder = (
+	req: PermissionRequestData,
+	preview: never,
+	t: Translate,
+) => PermissionCardText;
+
+const TEXT_BY_PREVIEW: Record<PermissionPreview["type"], TextBuilder> = {
+	diff: (_req, preview: DiffPreview, t) => ({
+		title: t(
+			preview.isNewFile
+				? "dms_ai.panel.approvals.create_file"
+				: "dms_ai.panel.approvals.edit_file",
+			{ file: baseName(preview.relativePath || preview.path) },
+		),
+		sub: preview.relativePath || preview.path,
+		onceLabel: t("dms_ai.panel.approvals.once_edit"),
+		allowLabel: t("dms_ai.panel.approvals.allow_edit"),
+		why: "",
+	}),
+	command: (_req, preview: CommandPreview, t) => ({
+		title: t("dms_ai.panel.approvals.run", { command: preview.command }),
+		sub: commandSub(preview, t),
+		onceLabel: t("dms_ai.panel.approvals.once_command"),
+		allowLabel: t("dms_ai.panel.approvals.allow_command"),
+		why: "",
+	}),
+	destructive: (req, preview: DestructivePreview, t) => ({
+		title: destructiveTitle(req, preview, t),
+		sub: t(`dms_ai.panel.approvals.consequence_${preview.consequence}`),
+		onceLabel: t("dms_ai.panel.approvals.once_time"),
+		allowLabel: t("dms_ai.panel.approvals.confirm_delete"),
+		why: t(`dms_ai.panel.approvals.why_${preview.consequence}`),
+	}),
+	web: (_req, preview: WebPreview, t) => ({
+		title: t("dms_ai.panel.approvals.fetch", { host: preview.host }),
+		sub: preview.url,
+		onceLabel: t("dms_ai.panel.approvals.once_request"),
+		allowLabel: t("dms_ai.panel.approvals.allow_request"),
+		why: "",
+	}),
+	generic: (req, _preview, t) => ({
+		title: verbAndTarget(req, t),
+		sub: "",
+		onceLabel: t("dms_ai.panel.approvals.once_time"),
+		allowLabel: t("dms_ai.panel.approvals.allow"),
+		why: req.kind === "builder" ? t("dms_ai.panel.approvals.why_builder") : "",
+	}),
+};
+
+/** "Delete the page {target}": the Builder's destructive operations by name. */
+const DESTRUCTIVE_TITLE_KEYS: Record<string, string> = {
+	BuilderDeletePage: "dms_ai.panel.approvals.destructive.delete_page",
+	BuilderDeleteResource: "dms_ai.panel.approvals.destructive.delete_table",
+	BuilderRemoveField: "dms_ai.panel.approvals.destructive.remove_field",
+	BuilderDeleteCategory: "dms_ai.panel.approvals.destructive.delete_category",
+	BuilderRemoveQuery: "dms_ai.panel.approvals.destructive.remove_query",
+};
+
+function destructiveTitle(
+	req: PermissionRequestData,
+	preview: DestructivePreview,
+	t: Translate,
+): string {
+	const operation = bareToolName(preview.operation || req.toolName);
+	const key = DESTRUCTIVE_TITLE_KEYS[operation];
+	if (key !== undefined) return t(key, { target: preview.target });
+	const verb = toolVerb(describeTool(operation, req.args), t);
+	return preview.target === "" ? verb : `${verb} ${preview.target}`;
+}
+
+function commandSub(preview: CommandPreview, t: Translate): string {
+	const touches = (preview.touches ?? []).join(", ");
+	if (preview.effect === undefined) return touches || preview.cwd;
+	const effect = t(`dms_ai.panel.approvals.effect_${preview.effect}`);
+	return touches === "" ? effect : `${effect} · ${touches}`;
+}
+
+/** The words of a permission card, read from its preview. */
+export function permissionCardText(
+	req: PermissionRequestData,
+	t: Translate,
+): PermissionCardText {
+	const build = TEXT_BY_PREVIEW[req.preview.type] ?? TEXT_BY_PREVIEW.generic;
+	return build(req, req.preview as never, t);
+}
+
+const RULE_LABEL_KEYS: Record<RuleKind, string> = {
+	file: "dms_ai.panel.approvals.rule_file",
+	directory: "dms_ai.panel.approvals.rule_directory",
+	command: "dms_ai.panel.approvals.rule_command",
+	domain: "dms_ai.panel.approvals.rule_domain",
+};
+
+/** A scope as the card offers it: "Every edit under crm/customers/". */
+export function ruleLabelKey(rule: PermissionRule): string {
+	return RULE_LABEL_KEYS[rule.kind];
+}
+
+const RULE_ICONS: Record<RuleKind, string> = {
+	file: "i-ph-pencil-simple-line",
+	directory: "i-ph-folder-simple",
+	command: "i-ph-terminal-window",
+	domain: "i-ph-globe",
+};
+
+export function ruleIcon(kind: RuleKind): string {
+	return RULE_ICONS[kind] ?? "i-ph-key";
+}
+
+const KIND_ICONS: Record<string, string> = {
+	edit: "i-ph-pencil-simple-line",
+	command: "i-ph-terminal-window",
+	web: "i-ph-globe",
+	destructive: "i-ph-trash",
+	builder: "i-ph-squares-four",
+	other: "i-ph-hand-palm",
+};
+
+/** The card's icon: by kind, else the tool's own. */
+export function permissionIcon(req: PermissionRequestData): string {
+	if (req.kind === "other") return describeTool(req.toolName, req.args).icon;
+	return KIND_ICONS[req.kind] ?? KIND_ICONS.other;
+}

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

@@ -0,0 +1,34 @@
+interface UserAgentData {
+	platform?: string;
+}
+
+interface NavigatorUserAgentData {
+	userAgentData?: UserAgentData;
+}
+
+const APPLE_PLATFORM = /mac|iphone|ipad|ipod/i;
+const APPLE_MODIFIER = "⌘";
+const OTHER_MODIFIER = "Ctrl+";
+const APPLE_SHIFT = "⇧";
+const OTHER_SHIFT = "Shift+";
+
+/**
+ * Shortcuts accept meta or ctrl, so hints show the modifier each platform
+ * actually uses: ⌘ on Apple, Ctrl elsewhere.
+ */
+function isApplePlatform(): boolean {
+	const nav = globalThis.navigator as
+		| (Navigator & NavigatorUserAgentData)
+		| undefined;
+	if (nav === undefined) return false;
+	const platform = nav.userAgentData?.platform ?? nav.platform ?? "";
+	return APPLE_PLATFORM.test(platform);
+}
+
+/** "⌘J" or "Ctrl+J"; with `withShift`, "⌘⇧K" or "Ctrl+Shift+K". */
+export function shortcutLabel(key: string, withShift = false): string {
+	const isApple = isApplePlatform();
+	const modifier = isApple ? APPLE_MODIFIER : OTHER_MODIFIER;
+	const shift = withShift ? (isApple ? APPLE_SHIFT : OTHER_SHIFT) : "";
+	return `${modifier}${shift}${key.toUpperCase()}`;
+}

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

@@ -0,0 +1,18 @@
+export interface Identified {
+	id: string;
+}
+
+/** The list with the item `id` moved to `toIndex`, clamped to the list. */
+export function moveItem<T extends Identified>(
+	list: readonly T[],
+	id: string,
+	toIndex: number,
+): T[] {
+	const from = list.findIndex((item) => item.id === id);
+	if (from === -1) return [...list];
+	const target = Math.min(Math.max(toIndex, 0), list.length - 1);
+	const next = [...list];
+	const [moved] = next.splice(from, 1);
+	next.splice(target, 0, moved);
+	return next;
+}