@antelopejs/dms-ai 0.1.3 → 0.1.5

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

@@ -0,0 +1,34 @@
+import { STORAGE_CONVERSATION_ID_KEY } from "../constants/conversation";
+import { newUuid } from "../utils/ids";
+
+function readPersisted(): string | null {
+	try {
+		return window.localStorage.getItem(STORAGE_CONVERSATION_ID_KEY);
+	} catch {
+		return null;
+	}
+}
+
+function persist(id: string): void {
+	try {
+		window.localStorage.setItem(STORAGE_CONVERSATION_ID_KEY, id);
+	} catch {
+		return;
+	}
+}
+
+export function resolveConversationId(): string {
+	const existing = readPersisted();
+	if (existing !== null && existing.length > 0) return existing;
+	const next = newUuid();
+	persist(next);
+	return next;
+}
+
+export function persistConversationId(id: string): void {
+	persist(id);
+}
+
+export function newConversationId(): string {
+	return newUuid();
+}

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

@@ -0,0 +1,56 @@
+import { type Ref, ref } from "vue";
+import {
+	CLIENT_MESSAGE_TYPES,
+	SERVER_EVENT_TYPES,
+} from "../constants/protocol";
+import type { ConversationSummary } from "../types/conversation";
+
+export interface UseConversationListOptions {
+	send: (msg: object) => void;
+	onMessage: (handler: (msg: unknown) => void) => () => void;
+}
+
+export interface UseConversationListResult {
+	conversations: Ref<ConversationSummary[]>;
+	refresh: () => void;
+	remove: (id: string) => void;
+}
+
+interface ConversationListEvent {
+	type: typeof SERVER_EVENT_TYPES.CONVERSATION_LIST;
+	conversations: ConversationSummary[];
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object";
+}
+
+function getEventType(msg: unknown): string | null {
+	if (!isObject(msg)) return null;
+	const t = msg.type;
+	return typeof t === "string" ? t : null;
+}
+
+export function useConversationList(
+	options: UseConversationListOptions,
+): UseConversationListResult {
+	const conversations = ref<ConversationSummary[]>([]);
+
+	options.onMessage((msg: unknown): void => {
+		if (getEventType(msg) !== SERVER_EVENT_TYPES.CONVERSATION_LIST) return;
+		conversations.value = (msg as ConversationListEvent).conversations;
+	});
+
+	const refresh = (): void => {
+		options.send({ type: CLIENT_MESSAGE_TYPES.LIST_CONVERSATIONS });
+	};
+
+	const remove = (id: string): void => {
+		options.send({
+			type: CLIENT_MESSAGE_TYPES.DELETE_CONVERSATION,
+			conversationId: id,
+		});
+	};
+
+	return { conversations, refresh, remove };
+}

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

@@ -0,0 +1,59 @@
+import { type Ref, ref } from "vue";
+import type { PermissionDecision } from "../constants/permissions";
+import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
+import type { PermissionRequestData } from "../types/permission";
+
+export interface UsePermissionQueueOptions {
+	send: (msg: object) => void;
+}
+
+export interface UsePermissionQueueResult {
+	queue: Ref<PermissionRequestData[]>;
+	enqueue: (req: PermissionRequestData) => void;
+	respond: (requestId: string, decision: PermissionDecision) => void;
+	respondAll: (decision: PermissionDecision) => void;
+	clear: () => void;
+}
+
+function buildResponseMessage(
+	req: PermissionRequestData,
+	decision: PermissionDecision,
+): object {
+	return {
+		type: CLIENT_MESSAGE_TYPES.PERMISSION_RESPONSE,
+		conversationId: req.conversationId,
+		requestId: req.requestId,
+		decision,
+	};
+}
+
+export function usePermissionQueue(
+	options: UsePermissionQueueOptions,
+): UsePermissionQueueResult {
+	const queue = ref<PermissionRequestData[]>([]);
+
+	const enqueue = (req: PermissionRequestData): void => {
+		if (queue.value.some((q) => q.requestId === req.requestId)) return;
+		queue.value = [...queue.value, req];
+	};
+
+	const respond = (requestId: string, decision: PermissionDecision): void => {
+		const target = queue.value.find((q) => q.requestId === requestId);
+		if (target === undefined) return;
+		options.send(buildResponseMessage(target, decision));
+		queue.value = queue.value.filter((q) => q.requestId !== requestId);
+	};
+
+	const respondAll = (decision: PermissionDecision): void => {
+		for (const req of queue.value) {
+			options.send(buildResponseMessage(req, decision));
+		}
+		queue.value = [];
+	};
+
+	const clear = (): void => {
+		queue.value = [];
+	};
+
+	return { queue, enqueue, respond, respondAll, clear };
+}

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

@@ -0,0 +1,50 @@
+import { type Ref, ref } from "vue";
+import { CLIENT_MESSAGE_TYPES } from "../constants/protocol";
+import type { QuestionRequestData } from "../types/question";
+
+export interface UseQuestionQueueOptions {
+	send: (msg: object) => void;
+}
+
+export interface UseQuestionQueueResult {
+	queue: Ref<QuestionRequestData[]>;
+	enqueue: (req: QuestionRequestData) => void;
+	respond: (requestId: string, answers: string[]) => void;
+	clear: () => void;
+}
+
+function buildResponseMessage(
+	req: QuestionRequestData,
+	answers: string[],
+): object {
+	return {
+		type: CLIENT_MESSAGE_TYPES.QUESTION_RESPONSE,
+		conversationId: req.conversationId,
+		requestId: req.requestId,
+		answers,
+	};
+}
+
+export function useQuestionQueue(
+	options: UseQuestionQueueOptions,
+): UseQuestionQueueResult {
+	const queue = ref<QuestionRequestData[]>([]);
+
+	const enqueue = (req: QuestionRequestData): void => {
+		if (queue.value.some((q) => q.requestId === req.requestId)) return;
+		queue.value = [...queue.value, req];
+	};
+
+	const respond = (requestId: string, answers: string[]): void => {
+		const target = queue.value.find((q) => q.requestId === requestId);
+		if (target === undefined) return;
+		options.send(buildResponseMessage(target, answers));
+		queue.value = queue.value.filter((q) => q.requestId !== requestId);
+	};
+
+	const clear = (): void => {
+		queue.value = [];
+	};
+
+	return { queue, enqueue, respond, clear };
+}

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

@@ -0,0 +1,28 @@
+import { onBeforeUnmount, type Ref, ref, watch } from "vue";
+import { RUN_CLOCK_TICK_MS } from "../constants/run-status";
+
+/**
+ * The current time, ticking every second while `isActive` is true, so elapsed
+ * and quiet durations keep moving between two reports from the sidecar.
+ */
+export function useRunClock(isActive: Ref<boolean>): Ref<number> {
+	const nowMs = ref(Date.now());
+	let timer: ReturnType<typeof setInterval> | null = null;
+	const stop = (): void => {
+		if (timer === null) return;
+		clearInterval(timer);
+		timer = null;
+	};
+	const start = (): void => {
+		stop();
+		nowMs.value = Date.now();
+		timer = setInterval(() => {
+			nowMs.value = Date.now();
+		}, RUN_CLOCK_TICK_MS);
+	};
+	watch(isActive, (active) => (active ? start() : stop()), {
+		immediate: true,
+	});
+	onBeforeUnmount(stop);
+	return nowMs;
+}

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

@@ -0,0 +1,67 @@
+import { type Ref, ref } from "vue";
+import { DEFAULT_SETTINGS } from "../constants/settings";
+import {
+	CLIENT_MESSAGE_TYPES,
+	SERVER_EVENT_TYPES,
+} from "../constants/protocol";
+import type {
+	AppSettings,
+	ProviderAvailability,
+	ProviderName,
+} from "../types/settings";
+
+export interface UseSettingsOptions {
+	send: (msg: object) => void;
+	onMessage: (handler: (msg: unknown) => void) => () => void;
+}
+
+export interface UseSettingsResult {
+	settings: Ref<AppSettings>;
+	update: (next: Partial<AppSettings>) => void;
+}
+
+interface SettingsUpdateEvent {
+	type: typeof SERVER_EVENT_TYPES.SETTINGS_UPDATE;
+	settings: AppSettings;
+	builderAvailable?: boolean;
+	providers?: Record<ProviderName, ProviderAvailability>;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object";
+}
+
+function getEventType(msg: unknown): string | null {
+	if (!isObject(msg)) return null;
+	const t = msg.type;
+	return typeof t === "string" ? t : null;
+}
+
+export function useSettings(options: UseSettingsOptions): UseSettingsResult {
+	const settings = ref<AppSettings>({ ...DEFAULT_SETTINGS });
+
+	options.onMessage((msg: unknown): void => {
+		if (getEventType(msg) !== SERVER_EVENT_TYPES.SETTINGS_UPDATE) return;
+		const event = msg as SettingsUpdateEvent;
+		settings.value = {
+			...event.settings,
+			builderAvailable: event.builderAvailable ?? false,
+			providers: event.providers ?? DEFAULT_SETTINGS.providers,
+		};
+	});
+
+	const update = (partial: Partial<AppSettings>): void => {
+		const next: AppSettings = { ...settings.value, ...partial };
+		settings.value = next;
+		options.send({
+			type: CLIENT_MESSAGE_TYPES.SET_SETTINGS,
+			provider: next.provider,
+			mode: next.mode,
+			thinking: next.thinking,
+			generationMode: next.generationMode,
+			allowLocalSkills: next.allowLocalSkills,
+		});
+	};
+
+	return { settings, update };
+}

package/frontend-vue/app/chat/constants/attachments.ts

@@ -0,0 +1,16 @@
+/**
+ * Mirror of the sidecar's attachment limits (sidecar/src/constants/attachments.ts),
+ * kept in sync by hand like the protocol's message types.
+ */
+export const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+export const MAX_ATTACHMENTS = 10;
+
+/** Media types shown with an image thumbnail, and inlined natively by the agent. */
+export const INLINE_IMAGE_MIME_TYPES = [
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+] as const;
+
+export const ATTACH_LABEL = "Attach files";

package/frontend-vue/app/chat/constants/connection-banner.ts

@@ -0,0 +1,7 @@
+export const BANNER_LABELS = {
+	connecting: "Connecting…",
+	reconnecting: "Reconnecting…",
+	disconnected: "Disconnected",
+} as const;
+
+export const RECONNECT_BUTTON_LABEL = "Reconnect now";

package/frontend-vue/app/chat/constants/conversation-drawer.ts

@@ -0,0 +1,13 @@
+export const DRAWER_TITLE = "Conversations";
+export const NEW_CONVERSATION_LABEL = "+ New";
+export const EMPTY_LIST_LABEL = "No conversations yet";
+export const DELETE_BUTTON_LABEL = "Delete";
+export const DELETE_BUTTON_GLYPH = "🗑";
+export const TOGGLE_DRAWER_LABEL = "Conversations";
+export const CLOSE_DRAWER_LABEL = "Close";
+
+export const RELATIVE_TIME_NOW = "just now";
+export const SECONDS_PER_MINUTE = 60;
+export const MINUTES_PER_HOUR = 60;
+export const HOURS_PER_DAY = 24;
+export const DAYS_BEFORE_DATE = 7;

package/frontend-vue/app/chat/constants/conversation.ts

@@ -0,0 +1,75 @@
+export const MESSAGE_ROLES = {
+	USER: "user",
+	ASSISTANT: "assistant",
+	TOOL: "tool",
+	ERROR: "error",
+} as const;
+
+export const STORED_TOOL_USE_ROLE = "tool_use";
+export const STORED_TOOL_RESULT_ROLE = "tool_result";
+export const STORED_ERROR_ROLE = "error";
+
+export const TOOL_STATUS = {
+	PENDING: "pending",
+	SUCCESS: "success",
+	ERROR: "error",
+} as const;
+
+export const TODO_WRITE_TOOL_NAME = "TodoWrite";
+
+export const TODO_STATUS = {
+	PENDING: "pending",
+	IN_PROGRESS: "in_progress",
+	COMPLETED: "completed",
+} as const;
+
+export const TODO_PANEL_TITLE = "Plan";
+
+export const STORAGE_CONVERSATION_ID_KEY = "dms-ai-conversation-id";
+
+export const SEND_HOTKEY = "Enter";
+export const NEWLINE_HOTKEY_MODIFIER = "shiftKey";
+
+export const ROLE_LABELS = {
+	USER: "You",
+	ASSISTANT: "Assistant",
+	TOOL: "Tool",
+	ERROR: "The run did not finish",
+} as const;
+
+export const STATUS_LABELS = {
+	PENDING: "running",
+	SUCCESS: "success",
+	ERROR: "error",
+} as const;
+
+/** Shown when a message could not even leave the chat. */
+export const NOT_SENT_MESSAGE =
+	"Your message was not sent: the assistant is not connected. Reconnect, then retry.";
+
+/** Shown when a retry needs files that only the original message still had. */
+export const RETRY_NEEDS_FILES_MESSAGE =
+	"Attach the files again to retry: they are no longer available after a reload.";
+
+/** Shown when Stop could not reach the sidecar, so the run is let go locally. */
+export const STOP_NOT_DELIVERED_MESSAGE =
+	"The assistant could not be reached to stop the run. Reconnect to see where it stands.";
+
+/** Result given to a tool that was still running when its run ended. */
+export const TOOL_CUT_SHORT_RESULT = "The run ended before this tool finished.";
+
+export const RETRY_LABEL = "Retry";
+
+export const TOOL_CLUSTER_LABEL = "Used";
+
+/**
+ * A live cluster peeks only its most recent rows; the rest hide behind a
+ * reveal.
+ */
+export const TOOL_CLUSTER_VISIBLE_LIMIT = 3;
+
+/**
+ * How long a cluster stays open after it stops being the active workspace, so
+ * a fast hand-off to the next cluster doesn't flash.
+ */
+export const TOOL_CLUSTER_COLLAPSE_LINGER_MS = 600;

package/frontend-vue/app/chat/constants/permissions.ts

@@ -0,0 +1,50 @@
+export const PERMISSION_DECISION_VALUES = [
+	"allow_once",
+	"allow_session",
+	"deny",
+] as const;
+
+export type PermissionDecision = (typeof PERMISSION_DECISION_VALUES)[number];
+
+export const PERMISSION_DECISIONS = {
+	ALLOW_ONCE: "allow_once",
+	ALLOW_SESSION: "allow_session",
+	DENY: "deny",
+} as const;
+
+export const PERMISSION_BUTTONS: ReadonlyArray<{
+	label: string;
+	decision: PermissionDecision;
+	variant: "primary" | "secondary" | "danger";
+}> = [
+	{
+		label: "Approve once",
+		decision: PERMISSION_DECISIONS.ALLOW_ONCE,
+		variant: "primary",
+	},
+	{
+		label: "Approve session",
+		decision: PERMISSION_DECISIONS.ALLOW_SESSION,
+		variant: "secondary",
+	},
+	{
+		label: "Deny",
+		decision: PERMISSION_DECISIONS.DENY,
+		variant: "danger",
+	},
+] as const;
+
+export const PERMISSION_LABELS = {
+	TOOL_NAME: "Tool",
+	SUMMARY: "Action",
+	ARGS_TOGGLE_SHOW: "Show details",
+	ARGS_TOGGLE_HIDE: "Hide details",
+	ARGS_HEADING: "Arguments",
+} as const;
+
+export const PERMISSION_INLINE_LABELS = {
+	HEADING_ONE: "Permission required",
+	HEADING_MANY: "Permissions required",
+	APPLY_ALL: "Allow all",
+	DENY_ALL: "Deny all",
+} as const;

package/frontend-vue/app/chat/constants/protocol.ts

@@ -0,0 +1,48 @@
+export const CLIENT_MESSAGE_TYPES = {
+	HELLO: "hello",
+	USER_MESSAGE: "user_message",
+	PERMISSION_RESPONSE: "permission_response",
+	QUESTION_RESPONSE: "question_response",
+	LIST_CONVERSATIONS: "list_conversations",
+	DELETE_CONVERSATION: "delete_conversation",
+	SET_SETTINGS: "set_settings",
+	INTERRUPT_TURN: "interrupt_turn",
+	QUEUE_ENQUEUE: "queue_enqueue",
+	QUEUE_CANCEL: "queue_cancel",
+} as const;
+
+/**
+ * Route of the dms-ai Settings page, reached from the chat's cogwheel. Module
+ * pages live under `/modules/<moduleId>/<slug>`.
+ */
+export const SETTINGS_PAGE_PATH = "/modules/ai/settings";
+
+export const SERVER_EVENT_TYPES = {
+	ASSISTANT_MESSAGE_CHUNK: "assistant_message_chunk",
+	TOOL_CALL_START: "tool_call_start",
+	TOOL_CALL_END: "tool_call_end",
+	RUN_DONE: "run_done",
+	RUN_ERROR: "run_error",
+	RUN_RESUMED: "run_resumed",
+	CONVERSATION_SNAPSHOT: "conversation_snapshot",
+	CONVERSATION_LIST: "conversation_list",
+	SETTINGS_UPDATE: "settings_update",
+	PERMISSION_REQUEST: "permission_request",
+	ASK_QUESTION: "ask_question",
+	QUEUE_STATE: "queue_state",
+	USER_MESSAGE_ECHO: "user_message_echo",
+	RUN_PROGRESS: "run_progress",
+} as const;
+
+/** The role the chat says hello with. */
+export const CHAT_ROLE = "chat";
+
+export const CONNECTION_STATUSES = {
+	CONNECTING: "connecting",
+	CONNECTED: "connected",
+	DISCONNECTED: "disconnected",
+	RECONNECTING: "reconnecting",
+} as const;
+
+export type ConnectionStatus =
+	(typeof CONNECTION_STATUSES)[keyof typeof CONNECTION_STATUSES];

package/frontend-vue/app/chat/constants/run-status.ts

@@ -0,0 +1,50 @@
+import type { ActivityKind } from "../types/conversation";
+
+/** What a running turn can be busy with, as the sidecar reports it. */
+export const ACTIVITY_KINDS = {
+	THINKING: "thinking",
+	RESPONDING: "responding",
+	WRITING: "writing",
+	TOOL: "tool",
+	COMPACTING: "compacting",
+	RETRYING: "retrying",
+} as const;
+
+/** What a running turn shows while the agent works, by reported activity. */
+export const ACTIVITY_LABELS: Record<ActivityKind, string> = {
+	[ACTIVITY_KINDS.THINKING]: "Thinking",
+	[ACTIVITY_KINDS.RESPONDING]: "Writing the answer",
+	[ACTIVITY_KINDS.WRITING]: "Preparing",
+	[ACTIVITY_KINDS.TOOL]: "Running",
+	[ACTIVITY_KINDS.COMPACTING]: "Compacting the conversation",
+	[ACTIVITY_KINDS.RETRYING]: "The model is busy, retrying",
+};
+
+/** Activities whose detail names a tool, shown with the tool's own label. */
+export const TOOL_DETAIL_ACTIVITIES: readonly ActivityKind[] = [
+	ACTIVITY_KINDS.WRITING,
+	ACTIVITY_KINDS.TOOL,
+];
+
+/** Activities during which a silent agent is expected, so never called quiet. */
+export const SILENT_ACTIVITIES: readonly ActivityKind[] = [ACTIVITY_KINDS.TOOL];
+
+export const DEFAULT_ACTIVITY_LABEL = "Thinking";
+export const ACTIVITY_ELLIPSIS = "…";
+
+/**
+ * How long a running turn may go without any word from the sidecar, heartbeats
+ * included, before the chat says it lost track of it. The sidecar beats every
+ * 5 seconds, so this is several missed beats, never a slow step.
+ */
+export const STALL_AFTER_MS = 20_000;
+
+/** From how long without agent activity the chat says so next to the label. */
+export const QUIET_NOTICE_AFTER_MS = 60_000;
+
+export const RUN_CLOCK_TICK_MS = 1_000;
+
+export const STALLED_LABEL = "No news from the assistant for";
+export const QUIET_LABEL = "no activity for";
+export const RECONNECT_LABEL = "Reconnect";
+export const STOP_LABEL = "Stop";

package/frontend-vue/app/chat/constants/settings.ts

@@ -0,0 +1,60 @@
+import type { AppSettings, ChatMode, ProviderName } from "../types/settings";
+
+export const DEFAULT_SETTINGS: AppSettings = {
+	provider: "claude",
+	mode: "normal",
+	thinking: "medium",
+	generationMode: "safe",
+	allowLocalSkills: false,
+	builderAvailable: false,
+	providers: {
+		claude: { available: true },
+		codex: { available: false },
+	},
+};
+
+export const OPEN_SETTINGS_LABEL = "Settings";
+
+export const MODE_SECTION_LABEL = "Mode";
+export const PROVIDER_SECTION_LABEL = "Agent";
+
+export const PROVIDER_OPTIONS: { value: ProviderName; label: string }[] = [
+	{ value: "claude", label: "Claude" },
+	{ value: "codex", label: "Codex" },
+];
+
+/**
+ * Shown in place of the hint when the sidecar reports the provider as
+ * unavailable, so the reason travels with the greyed-out option.
+ */
+export const PROVIDER_UNAVAILABLE_PREFIX = "Unavailable: ";
+
+/**
+ * Sessions belong to the backend that opened them, so a switch tears them down.
+ * The transcript survives; what the agent remembers of it does not — and that
+ * is not something to discover after the fact.
+ */
+export const PROVIDER_SWITCH_WARNING =
+	"Switching agent starts a new session: open conversations lose what the agent remembers of them. Transcripts are kept.";
+export const PROVIDER_SWITCH_CONFIRM = `${PROVIDER_SWITCH_WARNING}\n\nSwitch now?`;
+export const PROVIDER_BUSY_HINT =
+	"Stop the current turn before switching agent.";
+
+export const MODE_OPTIONS: { value: ChatMode; label: string }[] = [
+	{ value: "normal", label: "Normal" },
+	{ value: "acceptEdits", label: "Accept edits" },
+	{ value: "plan", label: "Plan" },
+	{ value: "auto", label: "Auto" },
+];
+
+export const MODE_HINTS: Record<ChatMode, string> = {
+	normal: "Ask before each tool action",
+	acceptEdits: "Auto-accept file edits, ask for the rest",
+	plan: "Plan only — propose without making changes",
+	auto: "Auto-approve every tool action",
+};
+
+// Safe mode refuses raw edits whatever the mode, and Auto stops short of
+// approving everything there, so the mode hint says so while it is active.
+export const SAFE_MODE_MODE_NOTE =
+	"Safe mode: raw edits and shell commands stay blocked, and Auto still asks before other actions.";