@antelopejs/dms-ai 0.6.0 → 0.7.0

package/frontend-vue/app/chat/components/UndoConflictModal.vue

@@ -0,0 +1,98 @@
+<script setup lang="ts">
+import type { PendingUndo } from "../composables/useChangeSetActions";
+import { useChatI18n } from "../composables/useChatI18n";
+
+interface Props {
+	/** The undo waiting on the user; the modal is open while there is one. */
+	pending: PendingUndo | null;
+}
+
+interface Emits {
+	confirm: [includeLater: boolean];
+	cancel: [];
+}
+
+defineProps<Props>();
+const emit = defineEmits<Emits>();
+const { t } = useChatI18n();
+
+function onOpenChange(isOpen: boolean): void {
+	if (!isOpen) emit("cancel");
+}
+</script>
+
+<template>
+	<UModal
+		:open="pending !== null"
+		:title="t('dms_ai.panel.change.conflict_title')"
+		@update:open="onOpenChange"
+	>
+		<template #body>
+			<p class="chat-view-conflict">
+				{{
+					t("dms_ai.panel.change.conflict_text", {
+						number: pending?.number ?? 0,
+					})
+				}}
+			</p>
+			<ul class="chat-view-conflicts">
+				<li
+					v-for="conflict in pending?.conflicts ?? []"
+					:key="conflict.changeSetId"
+				>
+					<b>#{{ conflict.number }}</b>
+					{{ conflict.title }}
+					<span>{{ conflict.files.join(", ") }}</span>
+				</li>
+			</ul>
+		</template>
+		<template #footer>
+			<div class="chat-view-conflict-foot">
+				<UButton
+					color="neutral"
+					variant="ghost"
+					:label="t('dms_ai.panel.change.undo_only')"
+					@click="emit('confirm', false)"
+				/>
+				<UButton
+					color="secondary"
+					:label="t('dms_ai.panel.change.undo_together')"
+					@click="emit('confirm', true)"
+				/>
+			</div>
+		</template>
+	</UModal>
+</template>
+
+<style scoped>
+.chat-view-conflict {
+	margin: 0 0 10px;
+	font-size: 13px;
+	line-height: 1.5;
+	color: var(--ui-text-muted);
+}
+
+.chat-view-conflicts {
+	display: grid;
+	gap: 6px;
+	margin: 0;
+	padding: 0;
+	list-style: none;
+	font-size: 12.5px;
+}
+
+.chat-view-conflicts span {
+	display: block;
+	font-family: var(--ai-font-mono, ui-monospace, monospace);
+	font-size: 11px;
+	color: var(--ui-text-muted);
+	overflow-wrap: anywhere;
+}
+
+.chat-view-conflict-foot {
+	display: flex;
+	justify-content: flex-end;
+	gap: 8px;
+	width: 100%;
+}
+</style>

package/frontend-vue/app/chat/composables/useChangeSetActions.ts

@@ -20,7 +20,7 @@ interface UndoPreview {
 }
 
 /** An undo waiting on the user: later sets touch the same files. */
-interface PendingUndo {
+export interface PendingUndo {
 	changeSetId: string;
 	number: number;
 	conflicts: UndoConflict[];

package/frontend-vue/app/plugins/ai.client.ts

@@ -26,6 +26,10 @@ import {
 	paletteAssistant,
 	paletteSource,
 } from "../runtime/assistant-commands";
+import {
+	ASSISTANT_ACTIONS_KEY,
+	publicAssistantActions,
+} from "../runtime/assistant-actions";
 import { installAssistantNotifications } from "../runtime/assistant-notifications";
 import {
 	ASSISTANT_SESSION_KEY,
@@ -264,8 +268,8 @@ function createSession(parts: SessionParts): AssistantSession {
 			intents.push({ kind: "open", conversationId });
 			panel.open();
 		},
-		startConversation: (prompt) => {
-			intents.push({ kind: "start", prompt });
+		startConversation: (prompt, mode) => {
+			intents.push({ kind: "start", prompt, mode });
 			panel.open();
 		},
 		holdStream: parts.holds.hold,
@@ -502,6 +506,10 @@ export default defineDmsPlugin((context) => {
 		i18n: createChatI18n(context.$i18n),
 	};
 	context.vueApp.provide(ASSISTANT_SESSION_KEY, provided.session);
+	context.vueApp.provide(
+		ASSISTANT_ACTIONS_KEY,
+		publicAssistantActions(provided.session),
+	);
 	context.vueApp.provide(CHAT_I18N_KEY, provided.i18n);
 	const appMounted = new Promise<void>((resolve) =>
 		context.hook("app:mounted", resolve),

package/frontend-vue/app/runtime/assistant-actions.ts

@@ -0,0 +1,41 @@
+import type {
+	AssistantSessionRef,
+	ConversationStartMode,
+} from "./assistant-session";
+
+/**
+ * The assistant as another module's layer may use it, without depending on dms-ai: injected under
+ * {@link ASSISTANT_ACTIONS_KEY} with a `null` default, which is what a project without dms-ai, or
+ * outside development, answers.
+ */
+export interface PublicAssistantActions {
+	/** The assistant runs in this tab, so a button that starts a conversation can be offered. Reactive. */
+	readonly isAvailable: boolean;
+	/**
+	 * Opens the assistant panel on a new conversation with `prompt` in the composer, unsent. With
+	 * `mode`, the conversation is set to it first: `plan` makes the agent end with a plan to approve.
+	 */
+	startConversation: (
+		prompt: string,
+		options?: { mode?: ConversationStartMode },
+	) => void;
+}
+
+/**
+ * The global key of {@link PublicAssistantActions}: `Symbol.for` resolves to the same symbol in
+ * every layer, so another module's layer injects it without importing dms-ai.
+ */
+export const ASSISTANT_ACTIONS_KEY = Symbol.for("dms-ai:assistant-actions");
+
+/** The public actions over the tab's assistant session, which may not run yet, or ever. */
+export function publicAssistantActions(
+	session: AssistantSessionRef,
+): PublicAssistantActions {
+	return {
+		get isAvailable() {
+			return session.value !== null;
+		},
+		startConversation: (prompt, options) =>
+			session.value?.startConversation(prompt, options?.mode),
+	};
+}

package/frontend-vue/app/runtime/assistant-session.ts

@@ -17,6 +17,9 @@ export interface ChatPanelState {
 	toggle: () => void;
 }
 
+/** The approval modes a conversation can be started in from outside the panel. */
+export type ConversationStartMode = "plan" | "normal";
+
 /**
  * The tab's assistant, as the plugin that owns it hands it to the panel, the
  * command palette's answer and the workspace pages: the sidecar's
@@ -31,8 +34,11 @@ export interface AssistantSession {
 	navigate: (path: string) => void;
 	/** Opens the panel on that conversation. */
 	openConversation: (conversationId: string) => void;
-	/** Opens the panel on a new conversation, the composer optionally prefilled. */
-	startConversation: (prompt?: string) => void;
+	/**
+	 * Opens the panel on a new conversation, the composer optionally prefilled, and the
+	 * conversation set to `mode` first when one is given.
+	 */
+	startConversation: (prompt?: string, mode?: ConversationStartMode) => void;
 	/**
 	 * Keeps the tab's stream open while the panel is closed, until the returned
 	 * function releases it: the command palette's answer streams through it.

package/frontend-vue/app/runtime/panel-intents.ts

@@ -1,4 +1,5 @@
 import { type Ref, ref } from "vue";
+import type { ConversationStartMode } from "./assistant-session";
 
 /** Opens the panel on a stored conversation. */
 interface OpenConversationIntent {
@@ -6,10 +7,11 @@ interface OpenConversationIntent {
 	conversationId: string;
 }
 
-/** Opens the panel on a new conversation, the composer optionally prefilled. */
+/** Opens the panel on a new conversation, the composer optionally prefilled, in `mode` when given. */
 interface StartConversationIntent {
 	kind: "start";
 	prompt?: string;
+	mode?: ConversationStartMode;
 }
 
 /** Puts the caret in the composer of the current conversation. */

package/frontend-vue/build/backend-boundary.ts

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import type { Plugin } from "vite";
+
+const BACKEND_PACKAGE = "@antelopejs/dms-ai";
+const BACKEND_SOURCE = "src";
+const QUERY_OR_HASH = /[?#].*$/;
+
+const backendRoots = new Map<string, string | null>();
+
+function packageName(manifest: string): string | undefined {
+	try {
+		const parsed: { name?: string } = JSON.parse(
+			readFileSync(manifest, "utf8"),
+		);
+		return parsed.name;
+	} catch {
+		return undefined;
+	}
+}
+
+function backendRoot(directory: string): string | null {
+	const known = backendRoots.get(directory);
+	if (known !== undefined) return known;
+	const manifest = join(directory, "package.json");
+	const parent = dirname(directory);
+	let root: string | null = null;
+	if (existsSync(manifest)) {
+		root = packageName(manifest) === BACKEND_PACKAGE ? directory : null;
+	} else if (parent !== directory) {
+		root = backendRoot(parent);
+	}
+	backendRoots.set(directory, root);
+	return root;
+}
+
+/**
+ * The real path of a resolved module id when it lies under the `src`
+ * directory of the backend package, or `undefined`. The package that owns the
+ * file decides, not a path, so the answer is the same in the repository and in
+ * the workspace the DMS builds the frontend in. Virtual ids and ids that are
+ * not files are ignored.
+ */
+function backendSourceFile(id: string): string | undefined {
+	const path = id.replace(QUERY_OR_HASH, "");
+	if (!isAbsolute(path)) return undefined;
+	let real: string;
+	try {
+		real = realpathSync(path);
+	} catch {
+		return undefined;
+	}
+	const root = backendRoot(dirname(real));
+	if (root === null) return undefined;
+	return relative(root, real).split(sep)[0] === BACKEND_SOURCE
+		? real
+		: undefined;
+}
+
+/**
+ * Fails the build, the dev server and the tests when a module of the frontend
+ * resolves to a file under the backend's `src`: the browser reaches the
+ * backend only through its HTTP routes. It checks what the whole resolution
+ * chain returns, so an alias is seen through and a symlink the resolver
+ * returns is followed to its real path, and it runs before the other plugins
+ * (`enforce: "pre"`).
+ */
+export function backendBoundary(): Plugin {
+	return {
+		name: "dms-ai:backend-boundary",
+		enforce: "pre",
+		async resolveId(source, importer, options) {
+			const resolved = await this.resolve(source, importer, {
+				...options,
+				skipSelf: true,
+			});
+			if (resolved === null || resolved.external) return resolved;
+			const file = backendSourceFile(resolved.id);
+			if (file === undefined) return resolved;
+			const from =
+				importer === undefined
+					? "an entry point"
+					: importer.replace(QUERY_OR_HASH, "");
+			return this.error(
+				`Backend boundary: ${from} imports ${file}, which is under src of ${BACKEND_PACKAGE}. The frontend reaches the backend only through its HTTP routes.`,
+			);
+		},
+	};
+}

package/frontend-vue/dms.frontend.build.ts

@@ -0,0 +1,6 @@
+import { defineDmsFrontendBuild } from "#dms/frontend-build";
+import { backendBoundary } from "./build/backend-boundary.ts";
+
+export default defineDmsFrontendBuild((build) => {
+	build.registerVitePlugins(() => [backendBoundary()]);
+});

package/frontend-vue/package.json

@@ -6,7 +6,7 @@
 	"license": "Apache-2.0",
 	"packageManager": "pnpm@10.6.5",
 	"engines": {
-		"@antelopejs/dms-frontend": ">=0.8.0 <0.9.0"
+		"@antelopejs/dms-frontend": ">=0.9.1 <0.10.0"
 	},
 	"scripts": {
 		"build": "pnpm --dir \"${DMS_FRONTEND_WORKSPACE:?Set DMS_FRONTEND_WORKSPACE to the generated Inertia workspace}\" build",
@@ -37,6 +37,7 @@
 		"prettier-plugin-tailwindcss": "^0.6.11",
 		"typescript": "^5.8.2",
 		"typescript-eslint": "^8.0.0",
+		"vite": "^7.3.2",
 		"vitest": "^4.1.5",
 		"vue-tsc": "^3.1.1"
 	}

package/frontend-vue/pnpm-lock.yaml

@@ -60,6 +60,9 @@ importers:
       typescript-eslint:
         specifier: ^8.0.0
         version: 8.70.0(eslint@9.39.4(jiti@2.7.0))(typescript@5.9.3)
+      vite:
+        specifier: ^7.3.2
+        version: 7.3.2(jiti@2.7.0)(terser@5.46.2)(yaml@2.8.4)
       vitest:
         specifier: ^4.1.5
         version: 4.1.5(jsdom@29.1.1)(vite@7.3.2(jiti@2.7.0)(terser@5.46.2)(yaml@2.8.4))

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

@@ -0,0 +1,72 @@
+// @vitest-environment jsdom
+import { flushPromises } from "@vue/test-utils";
+import { afterEach, describe, expect, it } from "vitest";
+import { shallowRef } from "vue";
+import { publicAssistantActions } from "../app/runtime/assistant-actions";
+import {
+	createHarness,
+	openPanel,
+	sentOfType,
+	unmountPanel,
+} from "./support/panel-harness";
+
+afterEach(() => {
+	unmountPanel();
+});
+
+const PROMPT =
+	"Use dms-external-database on connection roaster, module builder-db-roaster-tables.";
+
+describe("the assistant actions another module's layer injects", () => {
+	it("start a new conversation with the composer prefilled and nothing sent", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		const actions = publicAssistantActions(shallowRef(harness.session));
+		expect(actions.isAvailable).toBe(true);
+		actions.startConversation(PROMPT);
+		await flushPromises();
+		expect((panel.find("textarea").element as HTMLTextAreaElement).value).toBe(
+			PROMPT,
+		);
+		expect(sentOfType(harness, "user_message")).toEqual([]);
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([]);
+	});
+
+	it("set the new conversation to plan mode before prefilling it, when asked", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		const actions = publicAssistantActions(shallowRef(harness.session));
+		actions.startConversation(PROMPT, { mode: "plan" });
+		await flushPromises();
+		const started = sentOfType(harness, "hello").at(-1)?.conversationId;
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			expect.objectContaining({ conversationId: started, mode: "plan" }),
+		]);
+		expect((panel.find("textarea").element as HTMLTextAreaElement).value).toBe(
+			PROMPT,
+		);
+	});
+
+	it("set plan mode once the stream is up, when the panel opens before it", async () => {
+		const harness = createHarness();
+		await openPanel(harness);
+		harness.setChannelStatus("disconnected");
+		publicAssistantActions(shallowRef(harness.session)).startConversation(
+			PROMPT,
+			{ mode: "plan" },
+		);
+		await flushPromises();
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([]);
+		harness.setChannelStatus("connected");
+		await flushPromises();
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			expect.objectContaining({ mode: "plan" }),
+		]);
+	});
+
+	it("are unavailable without a session, and starting then does nothing", () => {
+		const actions = publicAssistantActions(shallowRef(null));
+		expect(actions.isAvailable).toBe(false);
+		expect(() => actions.startConversation(PROMPT)).not.toThrow();
+	});
+});

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();
+	});
+});