@antelopejs/dms-ai 0.1.6 → 0.2.0

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

@@ -1,107 +1,27 @@
-import { flushPromises, mount, type VueWrapper } from "@vue/test-utils";
+import { flushPromises, mount } from "@vue/test-utils";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { nextTick, ref } from "vue";
+import { nextTick } from "vue";
 import ChatPanel from "../app/components/ChatPanel.vue";
 import {
-	ASSISTANT_SESSION_KEY,
-	type AssistantSession,
-} from "../app/runtime/assistant-session";
-import type { ChannelStatus } from "../app/runtime/channel-client";
-import {
-	type ChatTransportHub,
-	createChatTransport,
-} from "../app/runtime/chat-transport";
-import { resetPrefsForTesting } from "../app/runtime/overlay-prefs";
-import { createChatPanelState } from "../app/runtime/panel-state";
-import type { SidecarStatus } from "../app/runtime/sidecar-status";
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	openPanel,
+	sendMessage,
+	sentOfType,
+	unmountPanel,
+	providedSession,
+} from "./support/panel-harness";
+import { PANEL_STUBS } from "./support/stubs";
 
-const CONVERSATION_ID = "conv-native-1";
 const STALL_AFTER_MS = 20_000;
 
-interface Harness {
-	session: AssistantSession;
-	hub: ChatTransportHub;
-	sent: Array<Record<string, unknown>>;
-	reconnects: number;
-	sidecarStatus: ReturnType<typeof ref<SidecarStatus>>;
-	setChannelStatus: (status: ChannelStatus) => void;
-	navigate: ReturnType<typeof vi.fn>;
-}
-
-function createHarness(): Harness {
-	let channelStatus: ChannelStatus = "connected";
-	const harness = {
-		sent: [] as Array<Record<string, unknown>>,
-		reconnects: 0,
-		sidecarStatus: ref<SidecarStatus>("connected"),
-		navigate: vi.fn(),
-	} as Harness;
-	harness.hub = createChatTransport({
-		send: (msg) => {
-			if (channelStatus !== "connected") return false;
-			harness.sent.push(msg as Record<string, unknown>);
-			return true;
-		},
-		reconnect: () => {
-			harness.reconnects += 1;
-		},
-		getStatus: () => channelStatus,
-	});
-	harness.setChannelStatus = (status) => {
-		channelStatus = status;
-		harness.hub.announceStatus(status);
-	};
-	harness.session = {
-		status: harness.sidecarStatus,
-		chat: harness.hub.transport,
-		panel: createChatPanelState(),
-		navigate: harness.navigate,
-	};
-	return harness;
-}
-
-let wrapper: VueWrapper | null = null;
-
-function mountPanel(harness: Harness): VueWrapper {
-	wrapper = mount(ChatPanel, {
-		attachTo: document.body,
-		global: {
-			provide: { [ASSISTANT_SESSION_KEY as symbol]: harness.session },
-			stubs: { UIcon: true, USelect: true },
-		},
-	});
-	return wrapper;
-}
-
-async function openPanel(harness: Harness): Promise<VueWrapper> {
-	const mounted = mountPanel(harness);
-	harness.session.panel.toggle();
-	await nextTick();
-	await flushPromises();
-	return mounted;
-}
-
-function deliver(harness: Harness, event: Record<string, unknown>): void {
-	harness.hub.deliver({ conversationId: CONVERSATION_ID, ...event });
-}
-
-async function sendMessage(panel: VueWrapper, text: string): Promise<void> {
-	await panel.find("textarea").setValue(text);
-	await panel.find("form.composer").trigger("submit");
-}
-
-function sentOfType(harness: Harness, type: string) {
-	return harness.sent.filter((msg) => msg.type === type);
-}
-
 beforeEach(() => {
 	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
 });
 
 afterEach(() => {
-	wrapper?.unmount();
-	wrapper = null;
-	resetPrefsForTesting();
+	unmountPanel();
 	localStorage.clear();
 	vi.useRealTimers();
 });
@@ -111,7 +31,9 @@ describe("the chat as a component of the dashboard", () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
 		expect(document.querySelector("iframe")).toBeNull();
-		expect(document.getElementById("dms-ai-overlay-root")).not.toBeNull();
+		expect(panel.find("[data-dms-side-panel] .dms-ai-panel").exists()).toBe(
+			true,
+		);
 		expect(panel.find(".chat-view").exists()).toBe(true);
 		expect(Reflect.has(globalThis, "dmsAiChatTransport")).toBe(false);
 	});
@@ -124,13 +46,26 @@ describe("the chat as a component of the dashboard", () => {
 		]);
 	});
 
-	it("keeps its conversation when the panel is closed and opened again", async () => {
+	it("leaves its conversation when the panel closes, and picks it up again when it opens", async () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
 		await sendMessage(panel, "build me a page");
 		harness.session.panel.close();
 		await nextTick();
+		expect(panel.find(".chat-view").exists()).toBe(false);
+		expect(sentOfType(harness, "leave_conversation")).toEqual([
+			{ type: "leave_conversation", conversationId: CONVERSATION_ID },
+		]);
 		harness.session.panel.toggle();
+		await flushPromises();
+		expect(sentOfType(harness, "hello")).toEqual([
+			{ type: "hello", role: "chat", conversationId: CONVERSATION_ID },
+			{ type: "hello", role: "chat", conversationId: CONVERSATION_ID },
+		]);
+		deliver(harness, {
+			type: "conversation_snapshot",
+			messages: [{ role: "user", content: "build me a page", timestampMs: 1 }],
+		});
 		await nextTick();
 		expect(panel.text()).toContain("build me a page");
 	});
@@ -138,61 +73,68 @@ describe("the chat as a component of the dashboard", () => {
 	it("opens the settings page through the dashboard router, not the sidecar", async () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
-		await panel.find('button[aria-label="Settings"]').trigger("click");
+		const settings = panel
+			.findAll(".u-dropdown-item")
+			.find((item) => item.text() === "Settings");
+		await settings?.trigger("click");
 		expect(harness.navigate).toHaveBeenCalledExactlyOnceWith(
 			"/modules/ai/settings",
 		);
 		expect(sentOfType(harness, "request_host_navigate")).toEqual([]);
 	});
 
-	it("closes from its own button, and on a click elsewhere in the dashboard", async () => {
+	it("asks for the conversation list again once a stream that was down connects", async () => {
+		const harness = createHarness();
+		harness.setChannelStatus("connecting");
+		await openPanel(harness);
+		expect(sentOfType(harness, "list_conversations")).toEqual([]);
+		harness.setChannelStatus("connected");
+		await nextTick();
+		expect(sentOfType(harness, "list_conversations")).toHaveLength(1);
+	});
+
+	it("closes from its own button, and stays open on a click elsewhere: docked, it is part of the page", async () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
-		panel
-			.find(".chat-view")
-			.element.dispatchEvent(
-				new PointerEvent("pointerdown", { bubbles: true, composed: true }),
-			);
-		expect(harness.session.panel.isOpen.value).toBe(true);
 		document.body.dispatchEvent(
 			new PointerEvent("pointerdown", { bubbles: true, composed: true }),
 		);
-		expect(harness.session.panel.isOpen.value).toBe(false);
-		harness.session.panel.toggle();
-		await nextTick();
+		expect(harness.session.panel.isOpen.value).toBe(true);
 		await panel.find('button[aria-label="Close"]').trigger("click");
 		expect(harness.session.panel.isOpen.value).toBe(false);
 	});
 
-	it("stays open on a click in what the dashboard portals out of the app", async () => {
-		const harness = createHarness();
-		await openPanel(harness);
-		const overlays = document.createElement("div");
-		overlays.id = "dms-overlays";
-		const toast = document.createElement("button");
-		overlays.append(toast);
-		document.body.append(overlays);
-		toast.dispatchEvent(
-			new PointerEvent("pointerdown", { bubbles: true, composed: true }),
+	it("shows the first connection while the session is not there yet", async () => {
+		const panel = mount(ChatPanel, {
+			global: { provide: providedSession(null), stubs: PANEL_STUBS },
+		});
+		await nextTick();
+		expect(panel.find(".dms-ai-panel-status").text()).toContain(
+			"Connecting the assistant",
 		);
-		expect(harness.session.panel.isOpen.value).toBe(true);
-		overlays.remove();
+		expect(panel.find(".chat-view").exists()).toBe(false);
+		panel.unmount();
 	});
 
-	it("covers the chat with the sidecar status while it is not reachable, and can still be closed", async () => {
+	it("keeps the transcript under a banner while the sidecar revives, and offers a restart once it gave up", async () => {
 		const harness = createHarness();
+		harness.lastError.value = "EADDRINUSE: port 5010 is already in use";
 		const panel = await openPanel(harness);
 		harness.sidecarStatus.value = "reviving";
 		await nextTick();
-		expect(panel.find(".dms-ai-panel-status").text()).toContain(
-			"Reconnecting the assistant",
-		);
+		expect(panel.find(".dms-ai-panel-status").exists()).toBe(false);
+		expect(panel.find(".connection-banner").text()).toContain("restarting");
 		harness.sidecarStatus.value = "unavailable";
 		await nextTick();
-		expect(panel.find(".dms-ai-panel-status").text()).toContain(
-			"Assistant unavailable",
-		);
-		await panel.find(".dms-ai-panel-status button").trigger("click");
+		const screen = panel.find(".dms-ai-panel-status");
+		expect(screen.text()).toContain("The assistant isn't running");
+		expect(screen.text()).toContain("EADDRINUSE");
+		const restart = screen
+			.findAll("button")
+			.find((button) => button.text() === "Restart assistant");
+		await restart?.trigger("click");
+		expect(harness.restart).toHaveBeenCalledOnce();
+		await screen.find('button[aria-label="Close"]').trigger("click");
 		expect(harness.session.panel.isOpen.value).toBe(false);
 		harness.sidecarStatus.value = "connected";
 		await nextTick();
@@ -271,7 +213,7 @@ describe("a running turn shows what it is doing, and never spins forever", () =>
 		expect(panel.find(".thinking").exists()).toBe(true);
 	});
 
-	it("shows a run error with Retry, which sends the message again", async () => {
+	it("shows a run error with Retry turn, which asks the sidecar to run it again", async () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
 		await sendMessage(panel, "reproduce this page");
@@ -279,8 +221,11 @@ describe("a running turn shows what it is doing, and never spins forever", () =>
 		await nextTick();
 		const error = panel.find(".message-bubble-error");
 		expect(error.text()).toContain("API Error: 529 overloaded");
-		await error.find("button").trigger("click");
-		expect(sentOfType(harness, "user_message")).toHaveLength(2);
+		const retry = error
+			.findAll("button")
+			.find((button) => button.text() === "Retry turn");
+		await retry?.trigger("click");
+		expect(sentOfType(harness, "retry_turn")).toHaveLength(1);
 	});
 
 	it("offers no Retry for a run error that sending again cannot fix", async () => {
@@ -295,7 +240,7 @@ describe("a running turn shows what it is doing, and never spins forever", () =>
 		await nextTick();
 		const error = panel.find(".message-bubble-error");
 		expect(error.text()).toContain("Prompt is too long");
-		expect(error.find("button").exists()).toBe(false);
+		expect(error.text()).not.toContain("Retry turn");
 	});
 
 	it("says a message was not sent when the stream dropped as it left", async () => {
@@ -333,7 +278,9 @@ describe("the shared stream going away and coming back", () => {
 		const panel = await openPanel(harness);
 		harness.setChannelStatus("reconnecting");
 		await nextTick();
-		expect(panel.find(".connection-banner").text()).toContain("Reconnecting");
+		expect(panel.find(".connection-banner").text()).toContain(
+			"Connection lost",
+		);
 		expect(panel.find("textarea").attributes("disabled")).toBeDefined();
 		harness.setChannelStatus("connected");
 		harness.hub.announceReady();

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

@@ -0,0 +1,118 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { TOOL_VERB_KEYS } from "../app/chat/utils/tool-lexicon";
+import en from "../i18n/locales/dms-ai-panel-en-GB.json";
+import fr from "../i18n/locales/dms-ai-panel-fr-FR.json";
+
+type Tree = Record<string, unknown>;
+
+const ROOT = resolve(__dirname, "..");
+const SOURCES = [
+	"app/chat",
+	"app/runtime",
+	"app/plugins",
+	"app/components/ChatPanel.vue",
+];
+const LITERAL_KEY =
+	/["'`](dms_ai\.(?:panel|tools|common)\.[A-Za-z0-9_.]+[A-Za-z0-9_])["'`]/g;
+const OWNED_NAMESPACES = ["panel", "tools", "common"];
+
+/** Keys built at run time from a value, each with every value it can take. */
+const DYNAMIC_FAMILIES: Record<string, readonly string[]> = {
+	"dms_ai.panel.tool.state": [
+		"done",
+		"running",
+		"waiting",
+		"denied",
+		"blocked",
+		"failed",
+		"stopped",
+	],
+	"dms_ai.panel.change.status": ["added", "modified", "deleted"],
+	"dms_ai.panel.change.typecheck": ["passed", "failed", "skipped"],
+	"dms_ai.common.scope": ["safe", "vibe"],
+	"dms_ai.common.agent": ["claude", "codex"],
+	"dms_ai.panel.composer.scope_desc": ["safe", "vibe"],
+	"dms_ai.panel.full_auto": [
+		"duration_turn",
+		"duration_30m",
+		"duration_chat",
+		"banner_turn",
+		"banner_30m",
+		"banner_chat",
+	],
+	"dms_ai.panel.drawer": [
+		"group_active",
+		"group_today",
+		"group_week",
+		"group_older",
+	],
+	"dms_ai.panel.empty": ["text_safe", "text_vibe"],
+	"dms_ai.panel.approvals": [
+		"why_deletes_data",
+		"why_removes_code",
+		"effect_adds_dependency",
+		"effect_removes_dependency",
+	],
+	"dms_ai.panel.rules": [
+		"kind_file",
+		"kind_directory",
+		"kind_command",
+		"kind_domain",
+	],
+};
+
+function files(path: string): string[] {
+	const full = join(ROOT, path);
+	if (!statSync(full).isDirectory()) return [full];
+	return readdirSync(full).flatMap((entry) => files(join(path, entry)));
+}
+
+function flatten(tree: Tree, prefix = ""): string[] {
+	return Object.entries(tree).flatMap(([key, value]) =>
+		value !== null && typeof value === "object"
+			? flatten(value as Tree, `${prefix}${key}.`)
+			: [`${prefix}${key}`],
+	);
+}
+
+function usedKeys(): string[] {
+	const source = SOURCES.flatMap(files)
+		.map((file) => readFileSync(file, "utf8"))
+		.join("\n");
+	return [
+		...new Set([...source.matchAll(LITERAL_KEY)].map((match) => match[1])),
+	];
+}
+
+const dynamicKeys = Object.entries(DYNAMIC_FAMILIES).flatMap(
+	([prefix, values]) => values.map((value) => `${prefix}.${value}`),
+);
+
+describe("the panel's strings", () => {
+	const english = new Set(flatten(en));
+	const french = new Set(flatten(fr));
+
+	it("exist in English and French alike", () => {
+		expect([...english].sort()).toEqual([...french].sort());
+	});
+
+	it("cover every key the panel uses", () => {
+		const keys = [
+			...usedKeys(),
+			...dynamicKeys,
+			...TOOL_VERB_KEYS.map((verb) => `dms_ai.tools.${verb}`),
+		];
+		expect(keys.filter((key) => !english.has(key))).toEqual([]);
+	});
+
+	it("stay in the panel's own namespaces", () => {
+		expect(Object.keys(en.dms_ai).sort()).toEqual([...OWNED_NAMESPACES].sort());
+	});
+
+	it("hold no character vue-i18n would read as syntax", () => {
+		const texts = [JSON.stringify(en), JSON.stringify(fr)];
+		for (const text of texts) expect(text).not.toMatch(/[@$]/);
+	});
+});

package/frontend-vue/tests/palette-assistant.test.ts

@@ -0,0 +1,220 @@
+import { flushPromises, mount, type VueWrapper } from "@vue/test-utils";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { nextTick, ref } from "vue";
+import PaletteAnswer from "../app/components/PaletteAnswer.vue";
+import type { CurrentPage } from "../app/chat/types/conversation";
+import {
+	assistantSidePanel,
+	launcherAction,
+	paletteAssistant,
+} from "../app/runtime/assistant-commands";
+import {
+	createHarness,
+	type Harness,
+	providedSession,
+	sentOfType,
+} from "./support/panel-harness";
+import { createTestI18n } from "./support/i18n";
+import { PANEL_STUBS } from "./support/stubs";
+
+const PROMPT = "What does this page show?";
+
+let answer: VueWrapper | null = null;
+
+afterEach(() => {
+	answer?.unmount();
+	answer = null;
+	localStorage.clear();
+});
+
+function askFromPalette(harness: Harness, close = vi.fn()): VueWrapper {
+	answer = mount(PaletteAnswer, {
+		props: { prompt: PROMPT, close },
+		global: { provide: providedSession(harness.session), stubs: PANEL_STUBS },
+	});
+	return answer;
+}
+
+function paletteConversation(harness: Harness): string {
+	const hello = sentOfType(harness, "hello")[0];
+	return String(hello?.conversationId);
+}
+
+function deliverToPalette(
+	harness: Harness,
+	event: Record<string, unknown>,
+): void {
+	harness.hub.deliver({
+		conversationId: paletteConversation(harness),
+		...event,
+	});
+}
+
+describe("the assistant's registrations in the dashboard", () => {
+	it("docks the panel by id, and lets the DMS toggle it from the launcher", () => {
+		const { t } = createTestI18n();
+		const panel = assistantSidePanel();
+		expect(panel).toMatchObject({
+			id: "dms-ai:assistant",
+			component: "DmsAiChatPanel",
+			ariaLabel: "$dms_ai.panel.launcher",
+		});
+		expect(panel.minWidth).toBeLessThan(panel.defaultWidth);
+		expect(panel.defaultWidth).toBeLessThan(panel.maxWidth);
+		const launcher = launcherAction(t);
+		expect(launcher.sidePanelId).toBe(panel.id);
+		expect(launcher).not.toHaveProperty("onSelect");
+		expect(launcher).not.toHaveProperty("isActive");
+	});
+
+	it("offers the palette prompts that fit the page on screen", () => {
+		const { t } = createTestI18n();
+		const page = ref<CurrentPage | null>({
+			path: "/sales/overview",
+			title: "Sales overview · DMS",
+		});
+		const assistant = paletteAssistant(t, page);
+		expect(assistant).toMatchObject({
+			id: "dms-ai:assistant",
+			answerComponent: "DmsAiPaletteAnswer",
+			label: "$dms_ai.panel.palette.assistant",
+			placeholder: "$dms_ai.panel.palette.placeholder",
+		});
+		expect(assistant.suggestions().map((item) => item.label)).toEqual([
+			"Explain what Sales overview shows",
+			"Add a chart to Sales overview",
+			"Add a filter to the table on Sales overview",
+		]);
+		page.value = { path: "/home", title: "Home" };
+		expect(assistant.suggestions().map((item) => item.label)).toContain(
+			"Explain how this project is organised",
+		);
+	});
+});
+
+describe("an answer in the command palette", () => {
+	it("asks read-only, in a conversation of its own it follows next to the panel's", async () => {
+		const harness = createHarness();
+		askFromPalette(harness);
+		await flushPromises();
+		const conversationId = paletteConversation(harness);
+		expect(sentOfType(harness, "hello")).toEqual([
+			{ type: "hello", role: "chat", conversationId, follow: true },
+		]);
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			{
+				type: "set_conversation_mode",
+				conversationId,
+				mode: "plan",
+				generationMode: "safe",
+			},
+		]);
+		expect(sentOfType(harness, "user_message")).toMatchObject([
+			{ conversationId, content: PROMPT },
+		]);
+		expect(harness.streamHolds).toBe(1);
+	});
+
+	it("waits for the stream before it asks", async () => {
+		const harness = createHarness();
+		harness.setChannelStatus("connecting");
+		askFromPalette(harness);
+		await flushPromises();
+		expect(sentOfType(harness, "user_message")).toEqual([]);
+		harness.setChannelStatus("connected");
+		harness.hub.announceReady();
+		await flushPromises();
+		expect(sentOfType(harness, "user_message")).toHaveLength(1);
+		expect(sentOfType(harness, "hello")[0]).toMatchObject({ follow: true });
+	});
+
+	it("streams the answer, and ignores the panel's conversation", async () => {
+		const harness = createHarness();
+		const view = askFromPalette(harness);
+		await flushPromises();
+		harness.hub.deliver({
+			conversationId: "conv-of-the-panel",
+			type: "assistant_message_chunk",
+			text: "not for the palette",
+		});
+		deliverToPalette(harness, {
+			type: "assistant_message_chunk",
+			text: "It lists the **sales** of the quarter.",
+		});
+		deliverToPalette(harness, { type: "run_done" });
+		await flushPromises();
+		expect(view.text()).toContain("It lists the sales of the quarter.");
+		expect(view.text()).not.toContain("not for the palette");
+		expect(view.text()).not.toContain(PROMPT);
+	});
+
+	it("continues in the assistant: the panel opens on that conversation and the turn keeps running", async () => {
+		const harness = createHarness();
+		const close = vi.fn();
+		const view = askFromPalette(harness, close);
+		await flushPromises();
+		const conversationId = paletteConversation(harness);
+		const button = view
+			.findAll("button")
+			.find((item) => item.text() === "Continue in the assistant");
+		await button?.trigger("click");
+		expect(close).toHaveBeenCalledOnce();
+		expect(harness.session.panel.isOpen.value).toBe(true);
+		expect(harness.session.intents.pending.value).toEqual({
+			kind: "open",
+			conversationId,
+		});
+		view.unmount();
+		answer = null;
+		expect(sentOfType(harness, "interrupt_turn")).toEqual([]);
+		expect(harness.streamHolds).toBe(0);
+	});
+
+	it("stops its turn when the palette closes on it, and lets the stream go", async () => {
+		const harness = createHarness();
+		const view = askFromPalette(harness);
+		await flushPromises();
+		const conversationId = paletteConversation(harness);
+		view.unmount();
+		answer = null;
+		expect(sentOfType(harness, "interrupt_turn")).toEqual([
+			{ type: "interrupt_turn", conversationId },
+		]);
+		expect(harness.streamHolds).toBe(0);
+	});
+
+	it("says when the agent waits for the user, who answers in the assistant", async () => {
+		const harness = createHarness();
+		const view = askFromPalette(harness);
+		await flushPromises();
+		deliverToPalette(harness, {
+			type: "ask_question",
+			requestId: "q1",
+			questions: [
+				{
+					header: "Scope",
+					question: "Which table?",
+					options: [{ label: "Orders" }, { label: "Customers" }],
+					multiSelect: false,
+				},
+			],
+			createdAtMs: Date.now(),
+			expiresAtMs: Date.now() + 60_000,
+		});
+		await nextTick();
+		expect(view.find('[role="alert"]').text()).toContain(
+			"The assistant is waiting for you",
+		);
+	});
+
+	it("says the assistant does not run in this tab without a session", () => {
+		answer = mount(PaletteAnswer, {
+			props: { prompt: PROMPT, close: vi.fn() },
+			global: { provide: providedSession(null), stubs: PANEL_STUBS },
+		});
+		expect(answer.text()).toContain("isn't running in this tab");
+		expect(answer.findAll("button").map((button) => button.text())).toEqual([
+			"Close",
+		]);
+	});
+});