@antelopejs/dms-ai 0.6.1 → 0.8.0

package/frontend-vue/tests/backend-boundary.test.ts

@@ -0,0 +1,130 @@
+import {
+	mkdirSync,
+	mkdtempSync,
+	realpathSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { build, type Plugin } from "vite";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { backendBoundary } from "../build/backend-boundary.ts";
+
+let root: string;
+
+function write(file: string, text: string): void {
+	const path = join(root, file);
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, text);
+}
+
+function manifest(directory: string, name: string): void {
+	write(`${directory}/package.json`, JSON.stringify({ name }));
+}
+
+/** A frontend entry with `source` as its only import, built for real. */
+async function buildEntry(source: string, extra: Plugin[] = []): Promise<void> {
+	write(
+		"frontend/entry.ts",
+		`import "${source}";\nexport const frontend = 1;\n`,
+	);
+	await build({
+		root: join(root, "frontend"),
+		configFile: false,
+		logLevel: "silent",
+		plugins: [backendBoundary(), ...extra],
+		build: {
+			write: false,
+			lib: { entry: join(root, "frontend/entry.ts"), formats: ["es"] },
+		},
+	});
+}
+
+beforeEach(() => {
+	root = realpathSync(mkdtempSync(join(tmpdir(), "dms-ai-boundary-")));
+	manifest("backend", "@antelopejs/dms-ai");
+	write("backend/src/routes/status.ts", "export const status = 1;\n");
+	write("backend/dist/index.js", "export const built = 1;\n");
+	write("backend/srcfoo/index.ts", "export const sibling = 1;\n");
+	manifest("other", "another-package");
+	write("other/src/index.ts", "export const other = 1;\n");
+	manifest("frontend", "@antelopejs/dms-ai-frontend-vue");
+});
+
+afterEach(() => {
+	rmSync(root, { recursive: true, force: true });
+});
+
+describe("the backend boundary of a real build", () => {
+	it("fails when the frontend imports a file under the backend's src", async () => {
+		await expect(buildEntry("../backend/src/routes/status.ts")).rejects.toThrow(
+			/frontend\/entry\.ts imports .*backend\/src\/routes\/status\.ts/,
+		);
+	});
+
+	it("fails when the import carries a query", async () => {
+		await expect(
+			buildEntry("../backend/src/routes/status.ts?raw"),
+		).rejects.toThrow(/Backend boundary/);
+	});
+
+	it("follows a symlink a resolver returns to the file it points at", async () => {
+		symlinkSync(
+			join(root, "backend/src/routes"),
+			join(root, "frontend/routes"),
+		);
+		const linked: Plugin = {
+			name: "test:linked",
+			enforce: "pre",
+			resolveId: (source) =>
+				source === "@linked/status"
+					? join(root, "frontend/routes/status.ts")
+					: null,
+		};
+		await expect(buildEntry("@linked/status", [linked])).rejects.toThrow(
+			/backend\/src\/routes\/status\.ts/,
+		);
+	});
+
+	it("sees through an alias another plugin resolves", async () => {
+		const alias: Plugin = {
+			name: "test:alias",
+			enforce: "pre",
+			resolveId: (source) =>
+				source === "@backend/status"
+					? join(root, "backend/src/routes/status.ts")
+					: null,
+		};
+		await expect(buildEntry("@backend/status", [alias])).rejects.toThrow(
+			/Backend boundary/,
+		);
+	});
+
+	it("lets the backend's built output through", async () => {
+		await expect(
+			buildEntry("../backend/dist/index.js"),
+		).resolves.toBeUndefined();
+	});
+
+	it("lets a sibling directory whose name starts with src through", async () => {
+		await expect(
+			buildEntry("../backend/srcfoo/index.ts"),
+		).resolves.toBeUndefined();
+	});
+
+	it("lets the src of another package through", async () => {
+		await expect(buildEntry("../other/src/index.ts")).resolves.toBeUndefined();
+	});
+
+	it("ignores a virtual module", async () => {
+		const virtual: Plugin = {
+			name: "test:virtual",
+			enforce: "pre",
+			resolveId: (source) => (source === "virtual:ok" ? "\0virtual:ok" : null),
+			load: (id) => (id === "\0virtual:ok" ? "export const v = 1;" : null),
+		};
+		await expect(buildEntry("virtual:ok", [virtual])).resolves.toBeUndefined();
+	});
+});

package/frontend-vue/tests/panel-approvals.test.ts

@@ -0,0 +1,190 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { nextTick } from "vue";
+import {
+	buttonWithText,
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	openPanel,
+	sentOfType,
+	unmountPanel,
+} from "./support/panel-harness";
+import {
+	COMMAND_REQUEST,
+	DELETE_REQUEST,
+	DIFF_REQUEST,
+	keydown,
+} from "./support/panel-fixtures";
+
+beforeEach(() => {
+	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
+});
+
+afterEach(() => {
+	unmountPanel();
+	localStorage.clear();
+	vi.useRealTimers();
+});
+
+describe("the approvals dock", () => {
+	it("previews a diff with line numbers and allows a scope with ↵", async () => {
+		// The countdown reads the clock: frozen at the request's creation, it
+		// shows the full grace period however slow the run is.
+		vi.useFakeTimers({ toFake: ["Date"] });
+		vi.setSystemTime(DIFF_REQUEST.createdAtMs);
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, COMMAND_REQUEST);
+		await nextTick();
+		const dock = panel.find(".cb-approve");
+		expect(dock.attributes("role")).toBe("alertdialog");
+		expect(dock.text()).toContain("Needs your approval · 1 of 2");
+		expect(dock.text()).toContain("denies in 4:12");
+		expect(panel.find(".perm.is-focused .perm__title").text()).toBe(
+			"Edit customer.form.ts",
+		);
+		expect(panel.findAll(".ln").map((row) => row.text())).toEqual([
+			"@@ −42 +42 @@",
+			'42−label: "VAT",',
+			'42+label: "VAT number",',
+		]);
+		expect(dock.text()).toContain("Every edit under crm/customers/");
+		await panel.findAll(".perm.is-focused .scope-opt input")[2].setValue(true);
+		keydown(dock.element, "Enter");
+		await nextTick();
+		expect(sentOfType(harness, "permission_response")[0]).toEqual({
+			type: "permission_response",
+			conversationId: CONVERSATION_ID,
+			requestId: "r1",
+			decision: "allow_rule",
+			rule: { kind: "directory", value: "crm/customers/" },
+		});
+		expect(panel.find(".perm.is-focused .perm__title").text()).toBe(
+			"Run pnpm add jsvat",
+		);
+		expect(panel.find(".perm.is-focused").text()).toContain(
+			"adds a dependency · package.json, pnpm-lock.yaml",
+		);
+	});
+
+	it("moves with J and K, denies with N, and denies everything at once", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, COMMAND_REQUEST);
+		await nextTick();
+		const dock = panel.find(".cb-approve");
+		keydown(dock.element, "j");
+		await nextTick();
+		expect(dock.text()).toContain("2 of 2");
+		keydown(dock.element, "k");
+		await nextTick();
+		expect(dock.text()).toContain("1 of 2");
+		keydown(dock.element, "n");
+		await nextTick();
+		expect(sentOfType(harness, "permission_response")[0]).toMatchObject({
+			requestId: "r1",
+			decision: "deny",
+		});
+		deliver(harness, DIFF_REQUEST);
+		await nextTick();
+		await buttonWithText(
+			panel.find(".cb-approve"),
+			"Deny both and stop",
+		).trigger("click");
+		expect(sentOfType(harness, "permission_response").at(-1)).toMatchObject({
+			decision: "deny_all",
+		});
+	});
+
+	it("denies with the user's suggestion", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		await nextTick();
+		await buttonWithText(panel, "Suggest a change").trigger("click");
+		await panel
+			.find(".u-textarea")
+			.setValue("Use the Builder's validation instead");
+		await buttonWithText(panel, "Deny and send").trigger("click");
+		expect(sentOfType(harness, "permission_response")[0]).toMatchObject({
+			decision: "deny",
+			feedback: "Use the Builder's validation instead",
+		});
+	});
+
+	it("makes a data loss typed, offers to keep the data, and never a chat-wide rule", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DELETE_REQUEST);
+		await nextTick();
+		const card = panel.find(".perm.is-danger");
+		expect(card.text()).toContain("Data loss");
+		expect(card.text()).not.toContain("this chat");
+		const confirm = buttonWithText(card, "Delete");
+		expect(confirm.attributes("disabled")).toBeDefined();
+		await card.find(".perm__confirm input").setValue("legacy_coupons");
+		expect(
+			buttonWithText(card, "Delete").attributes("disabled"),
+		).toBeUndefined();
+		await card.find('input[type="checkbox"]').setValue(true);
+		await buttonWithText(card, "Remove the code only").trigger("click");
+		expect(sentOfType(harness, "permission_response")[0]).toMatchObject({
+			decision: "allow_once",
+			keepData: true,
+		});
+	});
+
+	it("turns an expired request into a card that asks again", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, {
+			type: "permission_expired",
+			requestId: "r1",
+			toolName: "Edit",
+			summary: "Edit customer.form.ts",
+			expiredAtMs: Date.now(),
+		});
+		await nextTick();
+		expect(panel.find(".cb-approve").exists()).toBe(false);
+		const card = panel.find(".cb-expired");
+		expect(card.text()).toContain("Edit file request expired");
+		await buttonWithText(card, "Ask again").trigger("click");
+		expect(sentOfType(harness, "user_message")[0].content).toContain(
+			"Edit customer.form.ts",
+		);
+		expect(panel.find(".cb-expired").exists()).toBe(false);
+	});
+
+	it("lists the rules allowed in this chat and revokes one", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, {
+			type: "rules_state",
+			rules: [
+				{
+					id: "rule-1",
+					kind: "command",
+					value: "pnpm test",
+					label: "Commands starting pnpm test",
+					createdAtMs: 1,
+				},
+			],
+		});
+		await nextTick();
+		const rules = panel.find(".cb-approve .cb-rules");
+		expect(rules.text()).toContain("Commands starting pnpm test");
+		await buttonWithText(rules, "Revoke").trigger("click");
+		expect(sentOfType(harness, "revoke_rule")).toEqual([
+			{
+				type: "revoke_rule",
+				conversationId: CONVERSATION_ID,
+				ruleId: "rule-1",
+			},
+		]);
+	});
+});

package/frontend-vue/tests/panel-questions.test.ts

@@ -0,0 +1,169 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { nextTick } from "vue";
+import {
+	buttonWithText,
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	openPanel,
+	sendMessage,
+	sentOfType,
+	unmountPanel,
+} from "./support/panel-harness";
+import { keydown } from "./support/panel-fixtures";
+
+beforeEach(() => {
+	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
+});
+
+afterEach(() => {
+	unmountPanel();
+	localStorage.clear();
+	vi.useRealTimers();
+});
+
+describe("questions, queue and modes", () => {
+	const QUESTIONS = {
+		type: "ask_question",
+		requestId: "q1",
+		questions: [
+			{
+				question: "Where should the page live?",
+				header: "Placement",
+				options: [
+					{
+						label: "Finance › Overdue invoices",
+						description: "Next to Invoices",
+					},
+					{ label: "A tab on Invoices", description: "" },
+				],
+			},
+			{
+				question: "Default sort?",
+				header: "Sort",
+				options: [
+					{ label: "Days overdue", description: "" },
+					{ label: "Amount", description: "" },
+				],
+			},
+		],
+	};
+
+	it("pages through questions with numbers, Other… and Skip, then keeps the answers", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, QUESTIONS);
+		await nextTick();
+		const dock = panel.find(".cb-ask");
+		expect(dock.text()).toContain("Question 1 of 2 · Placement");
+		expect(dock.find(".opt-card.is-selected").text()).toContain("Suggested");
+		keydown(dock.element, "3");
+		await nextTick();
+		await dock.find(".cb-ask__custom").setValue("Under Finance, as a tab");
+		await buttonWithText(dock.find(".cb-ask__foot"), "Next").trigger("click");
+		expect(dock.text()).toContain("Question 2 of 2 · Sort");
+		await buttonWithText(dock, "Skip, you decide").trigger("click");
+		expect(sentOfType(harness, "question_response")[0]).toEqual({
+			type: "question_response",
+			conversationId: CONVERSATION_ID,
+			requestId: "q1",
+			answers: ["Under Finance, as a tab", ""],
+			skipped: [false, true],
+		});
+		await nextTick();
+		const record = panel.find(".cb-answers");
+		expect(record.text()).toContain("“Under Finance, as a tab”");
+		expect(record.text()).toContain("Skipped: the assistant decides");
+	});
+
+	it("edits, reorders and clears the queue", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, {
+			type: "queue_state",
+			items: [
+				{ id: "a", content: "Sort by order count" },
+				{ id: "b", content: "Limit to 3 orders" },
+			],
+		});
+		await nextTick();
+		await panel
+			.find('button[aria-label="Edit queued message"]')
+			.trigger("click");
+		await panel.find(".cb-queued__editor").setValue("Sort by revenue");
+		await buttonWithText(panel.find(".cb-queue"), "Save").trigger("click");
+		keydown(panel.findAll(".cb-queued__handle")[1].element, "ArrowUp");
+		await nextTick();
+		expect(panel.findAll(".cb-queued__txt").map((item) => item.text())).toEqual(
+			["Limit to 3 orders", "Sort by revenue"],
+		);
+		await buttonWithText(panel.find(".cb-queue"), "Clear").trigger("click");
+		expect(
+			harness.sent
+				.map((msg) => msg.type)
+				.filter((type) => String(type).startsWith("queue_")),
+		).toEqual(["queue_update", "queue_move", "queue_clear"]);
+	});
+
+	it("switches the chat's mode and scope, and confirms Full auto with a duration", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await buttonWithText(panel, "Plan only").trigger("click");
+		await buttonWithText(panel, "Full auto…").trigger("click");
+		await nextTick();
+		const modal = panel.find(".u-modal");
+		expect(modal.text()).toContain("Turn on Full auto?");
+		await buttonWithText(modal, "30 minutes").trigger("click");
+		await buttonWithText(modal, "Turn on Full auto").trigger("click");
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			{
+				type: "set_conversation_mode",
+				conversationId: CONVERSATION_ID,
+				mode: "plan",
+			},
+			{
+				type: "set_conversation_mode",
+				conversationId: CONVERSATION_ID,
+				fullAuto: { duration: "30m" },
+			},
+		]);
+		await nextTick();
+		const banner = panel.find(".cb-banner-auto");
+		expect(banner.text()).toContain("Full auto · for 30 minutes");
+		await buttonWithText(banner, "Turn off").trigger("click");
+		expect(sentOfType(harness, "set_conversation_mode").at(-1)).toMatchObject({
+			fullAuto: null,
+		});
+	});
+
+	it("runs a proposed plan in Ask first", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await sendMessage(panel, "plan a customer health page");
+		deliver(harness, {
+			type: "tool_call_start",
+			callId: "p1",
+			toolName: "ExitPlanMode",
+			args: { plan: "1. Create the page\n2. Add a query" },
+		});
+		deliver(harness, {
+			type: "tool_call_end",
+			callId: "p1",
+			status: "success",
+			result: "",
+			outcome: "done",
+		});
+		deliver(harness, { type: "run_done" });
+		await nextTick();
+		const plan = panel.find(".cb-plan");
+		expect(plan.text()).toContain("Proposed plan · 2 steps");
+		await buttonWithText(plan, "Run with Ask first").trigger("click");
+		expect(sentOfType(harness, "set_conversation_mode")[0]).toMatchObject({
+			mode: "normal",
+		});
+		expect(sentOfType(harness, "user_message").at(-1)).toMatchObject({
+			content: "Go ahead with the plan.",
+		});
+	});
+});