@antelopejs/dms-ai 0.1.6 → 0.2.0

package/frontend-vue/tests/chat/diff-and-keys.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from "vitest";
+import {
+	approvalKeyAction,
+	type ApprovalKeyInput,
+	stepIndex,
+} from "../../app/chat/utils/approval-keyboard";
+import { diffRows, limitRows } from "../../app/chat/utils/diff";
+import { moveItem } from "../../app/chat/utils/queue";
+import {
+	conversationTime,
+	groupConversations,
+} from "../../app/chat/utils/conversation-groups";
+import { formatDuration, formatTokens } from "../../app/chat/utils/format";
+import type { ConversationSummary } from "../../app/chat/types/conversation";
+
+describe("a diff is drawn with line numbers", () => {
+	const rows = diffRows([
+		{
+			oldStart: 41,
+			newStart: 41,
+			lines: [
+				{ kind: "context", text: "  vatNumber: InputText({" },
+				{ kind: "remove", text: '    label: "VAT",' },
+				{ kind: "add", text: '    label: "VAT number",' },
+				{ kind: "add", text: "    validate: check," },
+				{ kind: "context", text: "  })" },
+			],
+		},
+	]);
+
+	it("leads each hunk with its header", () => {
+		expect(rows[0]).toMatchObject({ kind: "hunk", text: "@@ −41 +41 @@" });
+	});
+
+	it("numbers removed lines in the old file and the rest in the new one", () => {
+		expect(
+			rows.slice(1).map((row) => [row.kind, row.number, row.sign]),
+		).toEqual([
+			["context", "41", ""],
+			["remove", "42", "−"],
+			["add", "42", "+"],
+			["add", "43", "+"],
+			["context", "44", ""],
+		]);
+	});
+
+	it("keeps numbers the sidecar sent", () => {
+		const [, line] = diffRows([
+			{
+				oldStart: 1,
+				newStart: 1,
+				lines: [{ kind: "add", text: "x", newLine: 9 }],
+			},
+		]);
+		expect(line.number).toBe("9");
+	});
+
+	it("shows the first rows of a long diff and counts the rest", () => {
+		expect(limitRows(rows, 4)).toMatchObject({ hidden: 2 });
+		expect(limitRows(rows, 10).hidden).toBe(0);
+	});
+});
+
+describe("the approvals dock answers to the keyboard", () => {
+	const key = (value: string, extra: Partial<ApprovalKeyInput> = {}) =>
+		approvalKeyAction({
+			key: value,
+			shiftKey: false,
+			metaKey: false,
+			ctrlKey: false,
+			altKey: false,
+			isTextTarget: false,
+			...extra,
+		});
+
+	it("maps ↵, N, J and K", () => {
+		expect(key("Enter")).toBe("allow");
+		expect(key("n")).toBe("deny");
+		expect(key("N")).toBe("deny");
+		expect(key("j")).toBe("next");
+		expect(key("k")).toBe("previous");
+		expect(key("x")).toBeNull();
+	});
+
+	it("leaves text fields and shortcuts alone", () => {
+		expect(key("n", { isTextTarget: true })).toBeNull();
+		expect(key("k", { metaKey: true, shiftKey: true })).toBeNull();
+		expect(key("Enter", { shiftKey: true })).toBeNull();
+	});
+
+	it("wraps around the requests", () => {
+		expect(stepIndex(1, 1, 2)).toBe(0);
+		expect(stepIndex(0, -1, 2)).toBe(1);
+		expect(stepIndex(0, 1, 0)).toBe(0);
+	});
+});
+
+describe("the queue reorders in place", () => {
+	const queue = [{ id: "a" }, { id: "b" }, { id: "c" }];
+
+	it("moves an item to its new index", () => {
+		expect(moveItem(queue, "c", 0).map((item) => item.id)).toEqual([
+			"c",
+			"a",
+			"b",
+		]);
+		expect(moveItem(queue, "a", 9).map((item) => item.id)).toEqual([
+			"b",
+			"c",
+			"a",
+		]);
+		expect(moveItem(queue, "z", 0)).toEqual(queue);
+	});
+});
+
+describe("the history drawer groups and dates chats", () => {
+	const now = new Date(2026, 9, 7, 15, 0).getTime();
+	const chat = (
+		id: string,
+		updatedAtMs: number,
+		extra = {},
+	): ConversationSummary => ({
+		id,
+		title: id,
+		createdAtMs: updatedAtMs,
+		updatedAtMs,
+		messageCount: 1,
+		...extra,
+	});
+
+	it("pins working and waiting chats above Today, This week and Older", () => {
+		const groups = groupConversations(
+			[
+				chat("old", new Date(2026, 8, 1).getTime()),
+				chat("today", now - 3_600_000),
+				chat("week", now - 3 * 86_400_000),
+				chat("waiting", now - 30 * 86_400_000, { pendingApprovals: 2 }),
+				chat("running", now - 60_000, { isRunning: true }),
+			],
+			now,
+		);
+		expect(
+			groups.map((group) => [group.key, group.items.map((i) => i.id)]),
+		).toEqual([
+			["active", ["running", "waiting"]],
+			["today", ["today"]],
+			["week", ["week"]],
+			["older", ["old"]],
+		]);
+	});
+
+	it("filters by title", () => {
+		const groups = groupConversations(
+			[chat("VAT check", now), chat("Refunds", now)],
+			now,
+			"vat",
+		);
+		expect(groups.flatMap((group) => group.items.map((i) => i.id))).toEqual([
+			"VAT check",
+		]);
+	});
+
+	it("says now, minutes, then a time", () => {
+		expect(conversationTime(now - 10_000, now, "en-GB", "now")).toBe("now");
+		expect(conversationTime(now - 120_000, now, "en-GB", "now")).toBe("2m");
+		expect(conversationTime(now - 2 * 3_600_000, now, "en-GB", "now")).toBe(
+			"13:00",
+		);
+	});
+
+	it("formats tokens and durations compactly", () => {
+		expect(formatTokens(840)).toBe("840");
+		expect(formatTokens(9_600)).toBe("9.6k");
+		expect(formatTokens(22_000)).toBe("22k");
+		expect(formatDuration(600)).toBe("0.6s");
+		expect(formatDuration(72_000)).toBe("1:12");
+	});
+});

package/frontend-vue/tests/chat/tool-lexicon.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from "vitest";
+import {
+	bareToolName,
+	describeTool,
+	namedArguments,
+	readableToolName,
+	TOOL_VERB_KEYS,
+	toolVerb,
+} from "../../app/chat/utils/tool-lexicon";
+import { toolRowState } from "../../app/chat/utils/tool-state";
+import type { ToolCallMessage } from "../../app/chat/types/conversation";
+import type { PermissionRequestData } from "../../app/chat/types/permission";
+import { findWaitingRequest } from "../../app/chat/utils/tool-state";
+import { permissionCardText } from "../../app/chat/utils/permission-view";
+
+const echo = (key: string): string => key;
+
+function tool(overrides: Partial<ToolCallMessage> = {}): ToolCallMessage {
+	return {
+		id: "m1",
+		role: "tool",
+		callId: "call-1",
+		toolName: "Edit",
+		args: { file_path: "/repo/crm/customer.form.ts" },
+		status: "pending",
+		timestampMs: 0,
+		...overrides,
+	};
+}
+
+describe("the tool lexicon names a call by what it does", () => {
+	it("reads a file edit as a verb and the file's name", () => {
+		const description = describeTool("Edit", {
+			file_path: "/repo/crm/customer.form.ts",
+		});
+		expect(toolVerb(description, echo)).toBe("dms_ai.tools.edit_file");
+		expect(description.target).toBe("customer.form.ts");
+	});
+
+	it("names a Builder block by its name and type, through the MCP prefix", () => {
+		const description = describeTool("mcp__dms-ai__BuilderAddBlock", {
+			page: "sales/overview",
+			name: "Top customers",
+			type: "TopListCard",
+		});
+		expect(description.verbKey).toBe("add_block");
+		expect(description.target).toBe("Top customers · TopListCard");
+	});
+
+	it("shows a command, a search and a URL the way a person reads them", () => {
+		expect(describeTool("Bash", { command: "pnpm add jsvat" }).target).toBe(
+			"pnpm add jsvat",
+		);
+		expect(describeTool("Grep", { pattern: "vatNumber" }).target).toBe(
+			"“vatNumber”",
+		);
+		expect(
+			describeTool("WebFetch", { url: "https://api.vies.eu/check?x=1" }).target,
+		).toBe("api.vies.eu/check");
+	});
+
+	it("covers every Builder tool and the assistant's own", () => {
+		const builder = [
+			"BuilderCatalog",
+			"BuilderDeletePage",
+			"BuilderMoveBlock",
+			"BuilderDeleteResource",
+			"BuilderRemoveField",
+			"BuilderRemoveQuery",
+			"BuilderQueryTemplates",
+		];
+		for (const name of [...builder, "AskUser", "Typecheck", "NavigateToPage"])
+			expect(describeTool(`mcp__dms-ai__${name}`, {}).verbKey).not.toBeNull();
+	});
+
+	it("falls back to a readable form of a tool it does not know", () => {
+		const description = describeTool("mcp__other__FetchInvoiceTotals", {
+			name: "Q3",
+		});
+		expect(description.verbKey).toBeNull();
+		expect(toolVerb(description, echo)).toBe("Fetch invoice totals");
+		expect(description.target).toBe("Q3");
+		expect(readableToolName("some_tool")).toBe("Some tool");
+		expect(bareToolName("mcp__dms-ai__AskUser")).toBe("AskUser");
+	});
+
+	it("lists named arguments, values on one line", () => {
+		expect(namedArguments({ page: "sales", position: { row: 2 } })).toEqual([
+			{ name: "page", value: "sales" },
+			{ name: "position", value: '{"row":2}' },
+		]);
+	});
+
+	it("has no verb twice", () => {
+		expect(new Set(TOOL_VERB_KEYS).size).toBe(TOOL_VERB_KEYS.length);
+	});
+});
+
+describe("a tool row is in one of seven states", () => {
+	it("takes the sidecar's outcome when there is one", () => {
+		for (const outcome of [
+			"done",
+			"failed",
+			"denied",
+			"blocked",
+			"stopped",
+		] as const)
+			expect(toolRowState(tool({ outcome, status: "error" }), true, null)).toBe(
+				outcome,
+			);
+	});
+
+	it("tells running, waiting and stopped apart for an open call", () => {
+		const request = {
+			requestId: "r1",
+			callId: "call-1",
+			toolName: "Edit",
+		} as PermissionRequestData;
+		const waiting = findWaitingRequest(tool(), [request]);
+		expect(waiting).toEqual({ index: 0, total: 1, requestId: "r1" });
+		expect(toolRowState(tool(), true, waiting)).toBe("waiting");
+		expect(toolRowState(tool(), true, null)).toBe("running");
+		expect(toolRowState(tool(), false, null)).toBe("stopped");
+	});
+
+	it("matches a request without call id by its tool", () => {
+		const request = {
+			requestId: "r2",
+			toolName: "Edit",
+		} as PermissionRequestData;
+		expect(findWaitingRequest(tool(), [request])?.requestId).toBe("r2");
+		expect(
+			findWaitingRequest(tool({ toolName: "Bash" }), [request]),
+		).toBeNull();
+	});
+});
+
+describe("permission cards are titled from the preview, never the raw tool", () => {
+	const t = (key: string, params?: Record<string, string | number>): string =>
+		`${key}${params ? JSON.stringify(params) : ""}`;
+	const base = {
+		requestId: "r",
+		conversationId: "c",
+		args: {},
+		summary: "Use tool: BuilderDeletePage",
+		alwaysAsk: true,
+		ruleOptions: [],
+		createdAtMs: 0,
+		expiresAtMs: 0,
+	};
+
+	it("names a Builder deletion by what it deletes", () => {
+		const text = permissionCardText(
+			{
+				...base,
+				toolName: "mcp__dms-ai__BuilderDeletePage",
+				kind: "destructive",
+				preview: {
+					type: "destructive",
+					operation: "BuilderDeletePage",
+					target: "/home",
+					consequence: "removes_code",
+					canKeepData: false,
+				},
+			},
+			t,
+		);
+		expect(text.title).toBe(
+			'dms_ai.panel.approvals.destructive.delete_page{"target":"/home"}',
+		);
+		expect(text.sub).toBe("dms_ai.panel.approvals.consequence_removes_code");
+	});
+
+	it("titles a generic request with the lexicon, not the summary", () => {
+		const text = permissionCardText(
+			{
+				...base,
+				toolName: "mcp__dms-ai__BuilderRemoveBlock",
+				args: { path: "home/contactForm" },
+				kind: "builder",
+				preview: { type: "generic", args: {} },
+			},
+			t,
+		);
+		expect(text.title).toBe("dms_ai.tools.remove_block home/contactForm");
+		expect(text.sub).toBe("");
+	});
+});

package/frontend-vue/tests/chat/useConversation.test.ts

@@ -2,11 +2,8 @@ import { describe, expect, it } from "vitest";
 import { ref } from "vue";
 import { useConversation } from "../../app/chat/composables/useConversation";
 import {
+	LOCAL_ERROR_KEYS,
 	MESSAGE_ROLES,
-	NOT_SENT_MESSAGE,
-	RETRY_NEEDS_FILES_MESSAGE,
-	STOP_NOT_DELIVERED_MESSAGE,
-	TOOL_CUT_SHORT_RESULT,
 	TOOL_STATUS,
 } from "../../app/chat/constants/conversation";
 import {
@@ -20,6 +17,8 @@ import {
 import type { RunProgress } from "../../app/chat/types/conversation";
 import type { PendingAttachment } from "../../app/chat/utils/attachments";
 import { isAgentQuiet } from "../../app/chat/utils/run-status";
+import { toolRowState } from "../../app/chat/utils/tool-state";
+import type { ToolCallMessage } from "../../app/chat/types/conversation";
 
 const CONVERSATION_ID = "conv-chat-1";
 const FILE_DATA = "PGh0bWw+PC9odG1sPg==";
@@ -96,7 +95,7 @@ describe("a run that fails reaches the user", () => {
 		});
 		expect(messages.find((m) => m.role === MESSAGE_ROLES.TOOL)).toMatchObject({
 			status: TOOL_STATUS.ERROR,
-			result: TOOL_CUT_SHORT_RESULT,
+			outcome: "stopped",
 		});
 	});
 
@@ -107,28 +106,40 @@ describe("a run that fails reaches the user", () => {
 		expect(h.conversation.isRunning.value).toBe(false);
 		expect(h.conversation.messages.value.at(-1)).toMatchObject({
 			role: MESSAGE_ROLES.ERROR,
-			content: NOT_SENT_MESSAGE,
+			contentKey: LOCAL_ERROR_KEYS.NOT_SENT,
 		});
 	});
 
-	it("retries the last message with its file", () => {
+	it("asks the sidecar to run a failed turn again", () => {
 		const h = harness();
 		h.conversation.sendUserMessage("reproduire sans casser le design", [
 			attachment(),
 		]);
 		h.receive({ type: SERVER_EVENT_TYPES.RUN_ERROR, error: "API Error: 529" });
 		h.conversation.retry();
-		const resent = h.sent.filter(
-			(msg) => msg.type === CLIENT_MESSAGE_TYPES.USER_MESSAGE,
-		);
-		expect(resent).toHaveLength(2);
-		expect(resent[1]).toMatchObject({
-			content: "reproduire sans casser le design",
-			attachments: [{ name: "OP_Manager_v176.html", data: FILE_DATA }],
+		expect(
+			h.sent.filter((msg) => msg.type === CLIENT_MESSAGE_TYPES.USER_MESSAGE),
+		).toHaveLength(1);
+		expect(h.sent.at(-1)).toEqual({
+			type: CLIENT_MESSAGE_TYPES.RETRY_TURN,
+			conversationId: CONVERSATION_ID,
 		});
 		expect(h.conversation.isRunning.value).toBe(true);
 	});
 
+	it("resends a message that never left, with its file", () => {
+		const h = harness();
+		h.setConnected(false);
+		h.conversation.sendUserMessage("reproduire", [attachment()]);
+		h.setConnected(true);
+		h.conversation.retry();
+		expect(h.sent.at(-1)).toMatchObject({
+			type: CLIENT_MESSAGE_TYPES.USER_MESSAGE,
+			content: "reproduire",
+			attachments: [{ name: "OP_Manager_v176.html", data: FILE_DATA }],
+		});
+	});
+
 	it("shows an unsent message once, even after a retry", () => {
 		const h = harness();
 		h.setConnected(false);
@@ -169,30 +180,22 @@ describe("a run that fails reaches the user", () => {
 		expect(overloaded).toMatchObject({ isRetryable: true });
 	});
 
-	it("asks for the files again when a reload dropped them", () => {
+	it("asks for the files again when an unsent message lost them", () => {
 		const h = harness();
-		h.receive({
-			type: SERVER_EVENT_TYPES.CONVERSATION_SNAPSHOT,
-			messages: [
-				{
-					role: "user",
-					content: "reproduire sans casser le design",
-					attachments: [
-						{ name: "OP_Manager_v176.html", mimeType: "text/html", size: 13 },
-					],
-					timestampMs: 1,
-				},
-				{ role: "error", content: "The run was stopped.", timestampMs: 2 },
-			],
-		});
+		h.setConnected(false);
+		h.conversation.sendUserMessage("reproduire", [attachment()]);
+		const unsent = h.conversation.messages.value[0];
+		if (unsent.role !== MESSAGE_ROLES.USER) throw new Error("no user message");
+		unsent.attachments = [{ name: "a.html", mimeType: "text/html", size: 1 }];
+		h.setConnected(true);
 		h.conversation.retry();
 		expect(h.sent).toEqual([]);
 		expect(h.conversation.messages.value.at(-1)).toMatchObject({
-			content: RETRY_NEEDS_FILES_MESSAGE,
+			contentKey: LOCAL_ERROR_KEYS.RETRY_NEEDS_FILES,
 		});
 	});
 
-	it("shows a stored error and settles tools left open after a reload", () => {
+	it("shows a stored error, and a tool left open as stopped after a reload", () => {
 		const h = harness();
 		h.receive({
 			type: SERVER_EVENT_TYPES.CONVERSATION_SNAPSHOT,
@@ -209,7 +212,7 @@ describe("a run that fails reaches the user", () => {
 			],
 		});
 		const [, tool, error] = h.conversation.messages.value;
-		expect(tool).toMatchObject({ status: TOOL_STATUS.ERROR });
+		expect(toolRowState(tool as ToolCallMessage, false, null)).toBe("stopped");
 		expect(error).toMatchObject({
 			role: MESSAGE_ROLES.ERROR,
 			content: "The run was stopped.",
@@ -223,7 +226,7 @@ describe("a run that fails reaches the user", () => {
 		h.conversation.interrupt();
 		expect(h.conversation.isRunning.value).toBe(false);
 		expect(h.conversation.messages.value.at(-1)).toMatchObject({
-			content: STOP_NOT_DELIVERED_MESSAGE,
+			contentKey: LOCAL_ERROR_KEYS.STOP_NOT_DELIVERED,
 		});
 	});
 });