@duckmind/dm-darwin-arm64 0.33.2 → 0.33.4

package/extensions/dm-ask/ask.ts

@@ -1,348 +0,0 @@
-/**
- * dm-ask — /ask side-question slash command.
- *
- * Asks the same primary model a one-off side question using the cloned primary
- * conversation as context. Answer is rendered ephemerally in a bottom-slot
- * overlay (never enters main agent's messages). History persists per-session-file
- * via globalThis-keyed storage; process-scoped only (no disk persistence).
- */
-
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import {
-	type AssistantMessage,
-	completeSimple,
-	type Message,
-	type StopReason,
-	type UserMessage,
-} from "@mariozechner/pi-ai";
-import {
-	convertToLlm,
-	type ExtensionAPI,
-	type ExtensionCommandContext,
-	type ExtensionContext,
-	type SessionEntry,
-} from "@mariozechner/pi-coding-agent";
-import { showAskOverlay } from "./ask-ui.js";
-
-// ---------------------------------------------------------------------------
-// Constants — flat named consts, grouped by concern (advisor pattern, b9428e9)
-// ---------------------------------------------------------------------------
-
-// Identity
-export const ASK_COMMAND_NAME = "ask";
-
-// Storage — globalThis-keyed survives module re-import on /new, /fork, /resume.
-// Lost on DM process exit (intentional — no disk persistence).
-export const ASK_STATE_KEY = Symbol.for("dm-ask");
-
-// Cross-session pattern hint: how many recent question-strings to inject
-export const CROSS_SESSION_HINT_LIMIT = 10;
-
-// Messages (static)
-const MSG_REQUIRES_INTERACTIVE = "/ask requires interactive mode";
-const MSG_USAGE = "Usage: /ask <question>";
-const MSG_NO_MODEL = "/ask requires an active model";
-
-// Errors (static)
-const ERR_EMPTY_RESPONSE = "/ask returned no text content.";
-
-// Errors (parameterized)
-const errMisconfigured = (label: string, err: string) => `/ask model (${label}) is misconfigured: ${err}`;
-const errNoApiKey = (label: string) => `/ask model (${label}) has no API key available.`;
-const errCallFailed = (err: string | undefined) => `/ask call failed: ${err ?? "unknown error"}`;
-const errCallThrew = (msg: string) => `/ask call threw: ${msg}`;
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-// Real messages — no fabrication. userMessage is built at call time; assistantMessage
-// is the unmodified completeSimple response. Stable object references across calls →
-// byte-identical prompt prefix on subsequent /ask invocations (cache parity).
-export interface AskTurn {
-	userMessage: UserMessage;
-	assistantMessage: AssistantMessage;
-}
-
-export interface AskState {
-	histories: Map<string, AskTurn[]>;
-	snapshots: Map<string, { messages: Message[] }>;
-}
-
-// ---------------------------------------------------------------------------
-// System prompt — loaded once at module init from prompts/ask-system.txt
-// ---------------------------------------------------------------------------
-
-export const ASK_SYSTEM_PROMPT = readFileSync(
-	fileURLToPath(new URL("./prompts/ask-system.txt", import.meta.url)),
-	"utf-8",
-).trimEnd();
-
-// ---------------------------------------------------------------------------
-// Storage — globalThis-keyed, survives module re-import on /new, /fork, /resume.
-// Standard Node.js `globalThis + Symbol.for()` idiom for cross-import-graph
-// singleton state (used by OpenTelemetry, etc.); lost on process exit.
-// ---------------------------------------------------------------------------
-
-function getState(): AskState {
-	const g = globalThis as unknown as { [k: symbol]: AskState | undefined };
-	let state = g[ASK_STATE_KEY];
-	if (!state) {
-		state = {
-			histories: new Map(),
-			snapshots: new Map(),
-		};
-		g[ASK_STATE_KEY] = state;
-	}
-	return state;
-}
-
-function getSessionFile(ctx: ExtensionContext): string {
-	return ctx.sessionManager.getSessionFile() ?? `memory:${ctx.sessionManager.getSessionId()}`;
-}
-
-function getSessionHistory(ctx: ExtensionContext): AskTurn[] {
-	const key = getSessionFile(ctx);
-	const state = getState();
-	let turns = state.histories.get(key);
-	if (!turns) {
-		turns = [];
-		state.histories.set(key, turns);
-	}
-	return turns;
-}
-
-function pushSessionTurn(ctx: ExtensionContext, turn: AskTurn): void {
-	getSessionHistory(ctx).push(turn);
-}
-
-export function clearSessionHistory(ctx: ExtensionContext): void {
-	getState().histories.set(getSessionFile(ctx), []);
-}
-
-function getSnapshot(ctx: ExtensionContext): { messages: Message[] } | undefined {
-	return getState().snapshots.get(getSessionFile(ctx));
-}
-
-function setSnapshot(ctx: ExtensionContext, snapshot: { messages: Message[] }): void {
-	getState().snapshots.set(getSessionFile(ctx), snapshot);
-}
-
-export function invalidateSnapshot(ctx: ExtensionContext): void {
-	getState().snapshots.delete(getSessionFile(ctx));
-}
-
-// Extract text from a UserMessage's content.
-export function userMessageText(msg: UserMessage): string {
-	if (typeof msg.content === "string") return msg.content;
-	return msg.content
-		.filter((c): c is { type: "text"; text: string } => c.type === "text")
-		.map((c) => c.text)
-		.join("\n");
-}
-
-// Extract text from an AssistantMessage's content (text parts only).
-export function assistantMessageText(msg: AssistantMessage): string {
-	return msg.content
-		.filter((c): c is { type: "text"; text: string } => c.type === "text")
-		.map((c) => c.text)
-		.join("\n");
-}
-
-// Cross-session pattern hint — last N question-strings across ALL sessions.
-function getCrossSessionHint(): string {
-	const allTurns: { q: string; ts: number }[] = [];
-	for (const turns of getState().histories.values()) {
-		for (const t of turns) {
-			allTurns.push({ q: userMessageText(t.userMessage), ts: t.userMessage.timestamp });
-		}
-	}
-	if (allTurns.length === 0) return "";
-	const recent = allTurns.sort((a, b) => a.ts - b.ts).slice(-CROSS_SESSION_HINT_LIMIT);
-	const lines = recent.map((t, i) => `${i + 1}. ${t.q.replace(/\s+/g, " ").slice(0, 200)}`);
-	return `\n\n## Recent /ask questions across sessions (oldest first)\n\n${lines.join("\n")}`;
-}
-
-// ---------------------------------------------------------------------------
-// Executor — auth, message threading, completeSimple, four StopReason branches
-// Modeled after rpiv-advisor/advisor.ts:225-336
-// ---------------------------------------------------------------------------
-
-export interface AskExecResult {
-	ok: boolean;
-	answer?: string;
-	userMessage?: UserMessage;
-	assistantMessage?: AssistantMessage;
-	error?: string;
-	stopReason?: StopReason;
-	aborted?: boolean;
-}
-
-function readBranchMessages(ctx: ExtensionContext): Message[] {
-	const cached = getSnapshot(ctx);
-	if (cached) return cached.messages;
-	// Cold start (no message_end fired yet) — fall back to live read
-	const branch = ctx.sessionManager.getBranch() as SessionEntry[];
-	const agentMessages = branch
-		.filter((e): e is SessionEntry & { type: "message" } => e.type === "message")
-		.map((e) => e.message);
-	return convertToLlm(agentMessages);
-}
-
-function buildAskMessages(ctx: ExtensionContext, userMessage: UserMessage): Message[] {
-	const branchMessages = readBranchMessages(ctx);
-	const history = getSessionHistory(ctx);
-	// Reusing stored real UserMessage/AssistantMessage object references across calls
-	// preserves byte-identical prompt prefix (cache parity).
-	const historyMessages: Message[] = history.flatMap((h) => [h.userMessage, h.assistantMessage]);
-	return [...branchMessages, ...historyMessages, userMessage];
-}
-
-function buildSystemPrompt(): string {
-	return ASK_SYSTEM_PROMPT + getCrossSessionHint();
-}
-
-export async function executeAsk(
-	question: string,
-	ctx: ExtensionContext,
-	controller: AbortController,
-): Promise<AskExecResult> {
-	const model = ctx.model;
-	if (!model) {
-		return { ok: false, error: MSG_NO_MODEL };
-	}
-	const modelLabel = `${model.provider}:${model.id}`;
-
-	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-	if (!auth.ok) {
-		return { ok: false, error: errMisconfigured(modelLabel, auth.error) };
-	}
-	if (!auth.apiKey) {
-		return { ok: false, error: errNoApiKey(modelLabel) };
-	}
-
-	const userMessage: UserMessage = {
-		role: "user",
-		content: [{ type: "text", text: question }],
-		timestamp: Date.now(),
-	};
-	const messages = buildAskMessages(ctx, userMessage);
-	const systemPrompt = buildSystemPrompt();
-
-	try {
-		const response = await completeSimple(
-			model,
-			{ systemPrompt, messages, tools: [] },
-			{
-				apiKey: auth.apiKey,
-				headers: auth.headers,
-				signal: controller.signal, // own AbortController, NOT ctx.signal (Decision 8)
-			},
-		);
-
-		if (response.stopReason === "aborted") {
-			return { ok: false, aborted: true, stopReason: response.stopReason };
-		}
-		if (response.stopReason === "error") {
-			return {
-				ok: false,
-				error: errCallFailed(response.errorMessage),
-				stopReason: response.stopReason,
-			};
-		}
-
-		const answerText = assistantMessageText(response).trim();
-		if (!answerText) {
-			return { ok: false, error: ERR_EMPTY_RESPONSE, stopReason: response.stopReason };
-		}
-
-		return {
-			ok: true,
-			answer: answerText,
-			userMessage,
-			assistantMessage: response,
-			stopReason: response.stopReason,
-		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		if (controller.signal.aborted) {
-			return { ok: false, aborted: true };
-		}
-		return { ok: false, error: errCallThrew(message) };
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Registrars — 3 hooks total: command + message_end snapshot + compact/tree invalidate
-// ---------------------------------------------------------------------------
-
-export function registerMessageEndSnapshot(pi: ExtensionAPI): void {
-	pi.on("message_end", async (event, ctx) => {
-		const msg = event.message;
-		if (msg.role !== "assistant") return;
-		if ((msg as AssistantMessage).stopReason === "toolUse") return;
-		const branch = ctx.sessionManager.getBranch() as SessionEntry[];
-		const agentMessages = branch
-			.filter((e): e is SessionEntry & { type: "message" } => e.type === "message")
-			.map((e) => e.message);
-		setSnapshot(ctx, { messages: convertToLlm(agentMessages) });
-	});
-}
-
-export function registerInvalidationHooks(pi: ExtensionAPI): void {
-	pi.on("session_compact", async (_e, ctx) => invalidateSnapshot(ctx));
-	pi.on("session_tree", async (_e, ctx) => invalidateSnapshot(ctx));
-}
-
-export function registerAskCommand(pi: ExtensionAPI): void {
-	pi.registerCommand(ASK_COMMAND_NAME, {
-		description: "Ask a side question without polluting the main conversation",
-		handler: (args: string, ctx: ExtensionCommandContext) => handleAskCommand(pi, args, ctx),
-	});
-}
-
-async function handleAskCommand(_pi: ExtensionAPI, args: string, ctx: ExtensionCommandContext): Promise<void> {
-	if (!ctx.hasUI) {
-		ctx.ui.notify(MSG_REQUIRES_INTERACTIVE, "error");
-		return;
-	}
-	const question = args.trim();
-	if (!question) {
-		ctx.ui.notify(MSG_USAGE, "warning");
-		return;
-	}
-	if (!ctx.model) {
-		ctx.ui.notify(MSG_NO_MODEL, "error");
-		return;
-	}
-
-	const controller = new AbortController();
-	const historySnapshot = [...getSessionHistory(ctx)];
-
-	const { overlayPromise, controllerReady } = showAskOverlay({
-		ctx,
-		question,
-		history: historySnapshot,
-		controller,
-		onClearHistory: () => clearSessionHistory(ctx),
-	});
-
-	const overlayCtl = await controllerReady;
-	const result = await executeAsk(question, ctx, controller);
-
-	if (result.ok && result.answer && result.userMessage && result.assistantMessage) {
-		overlayCtl.setAnswer(result.answer);
-		pushSessionTurn(ctx, {
-			userMessage: result.userMessage,
-			assistantMessage: result.assistantMessage,
-		});
-		// No disk persistence — process-scoped only (Decision 4)
-	} else if (result.aborted) {
-		// User Esc'd — overlay already dismissed via done(); no further action
-	} else if (result.error) {
-		overlayCtl.setError(result.error);
-	}
-
-	await overlayPromise;
-}

package/extensions/dm-ask/btw-ui.test.ts

@@ -1,270 +0,0 @@
-import type { Theme } from "@mariozechner/pi-coding-agent";
-import { type TUI, visibleWidth } from "@mariozechner/pi-tui";
-import { makeTui } from "@juicesharp/rpiv-test-utils";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { AskTurn } from "./ask.js";
-import { AskOverlayController, showAskOverlay } from "./ask-ui.js";
-
-const identityTheme = {
-	fg: (_c: string, s: string) => s,
-	bg: (_c: string, s: string) => s,
-	bold: (s: string) => s,
-	strikethrough: (s: string) => s,
-} as unknown as Theme;
-
-function makeTurn(q: string, a = "ans"): AskTurn {
-	return {
-		userMessage: { role: "user", content: q, timestamp: 0 },
-		assistantMessage: {
-			role: "assistant",
-			content: [{ type: "text", text: a }],
-			api: "anthropic" as never,
-			provider: "anthropic" as never,
-			model: "m",
-			usage: {} as never,
-			stopReason: "done" as never,
-			timestamp: 0,
-		},
-	};
-}
-
-function makeController(opts: { question?: string; history?: AskTurn[]; tui?: TUI; rows?: number } = {}) {
-	const tui = opts.tui ?? (makeTui() as unknown as TUI);
-	(tui as unknown as { terminal: { rows: number } }).terminal = { rows: opts.rows ?? 24 };
-	const done = vi.fn();
-	const controller = new AbortController();
-	const onClearHistory = vi.fn();
-	const ctl = new AskOverlayController(
-		opts.question ?? "what?",
-		opts.history ?? [],
-		identityTheme,
-		tui,
-		done,
-		controller,
-		onClearHistory,
-	);
-	return { ctl, tui, done, controller, onClearHistory };
-}
-
-afterEach(() => {
-	vi.restoreAllMocks();
-});
-
-describe("AskOverlayController — initial (pending) render", () => {
-	it("contains the banner, echo line, pending glyph, and dismiss footer", () => {
-		const { ctl } = makeController({ question: "hello?" });
-		const out = ctl.render(80).join("\n");
-		expect(out).toContain("/ask hello?");
-		expect(out).toContain("…"); // PENDING_GLYPH
-		expect(out).toContain("Esc to dismiss");
-	});
-
-	it("does NOT show 'scroll' or 'clear' hints when pending + no history", () => {
-		const { ctl } = makeController({ question: "q" });
-		const out = ctl.render(80).join("\n");
-		expect(out).not.toContain("↑/↓ to scroll");
-		expect(out).not.toContain("x to clear history");
-	});
-
-	it("shows 'x to clear history' hint when history is non-empty", () => {
-		const { ctl } = makeController({ history: [makeTurn("prev")] });
-		const out = ctl.render(80).join("\n");
-		expect(out).toContain("x to clear history");
-	});
-});
-
-describe("AskOverlayController — setAnswer", () => {
-	it("replaces pending glyph with the answer text", () => {
-		const { ctl, tui } = makeController();
-		ctl.setAnswer("forty-two");
-		const out = ctl.render(80).join("\n");
-		expect(out).toContain("forty-two");
-		expect(out).not.toContain("…");
-		expect(tui.requestRender).toHaveBeenCalled();
-	});
-
-	it("enables the 'scroll' footer hint once the mode is no longer pending", () => {
-		const { ctl } = makeController();
-		ctl.setAnswer("a");
-		expect(ctl.render(80).join("\n")).toContain("↑/↓ to scroll");
-	});
-
-	it("wraps multi-line answers into the answer body", () => {
-		const { ctl } = makeController();
-		ctl.setAnswer("line1\nline2\nline3");
-		const out = ctl.render(80);
-		expect(out.some((l) => l.includes("line1"))).toBe(true);
-		expect(out.some((l) => l.includes("line2"))).toBe(true);
-		expect(out.some((l) => l.includes("line3"))).toBe(true);
-	});
-});
-
-describe("AskOverlayController — setError", () => {
-	it("renders the error message in the answer slot", () => {
-		const { ctl } = makeController();
-		ctl.setError("boom: nope");
-		const out = ctl.render(80).join("\n");
-		expect(out).toContain("boom: nope");
-		expect(out).not.toContain("…");
-	});
-});
-
-describe("AskOverlayController — handleInput", () => {
-	it("Esc aborts the controller and resolves done()", () => {
-		const { ctl, controller, done } = makeController();
-		ctl.handleInput("\u001b");
-		expect(controller.signal.aborted).toBe(true);
-		expect(done).toHaveBeenCalled();
-	});
-
-	it("'x' clears in-memory history and invokes onClearHistory", () => {
-		const { ctl, onClearHistory, tui } = makeController({ history: [makeTurn("a"), makeTurn("b")] });
-		ctl.handleInput("x");
-		expect(onClearHistory).toHaveBeenCalledTimes(1);
-		const out = ctl.render(80).join("\n");
-		expect(out).not.toContain("/ask a");
-		expect(out).not.toContain("/ask b");
-		expect(out).not.toContain("x to clear history");
-		expect(tui.requestRender).toHaveBeenCalled();
-	});
-
-	it("unknown keys do not abort or clear", () => {
-		const { ctl, controller, done, onClearHistory } = makeController();
-		ctl.handleInput("z");
-		expect(controller.signal.aborted).toBe(false);
-		expect(done).not.toHaveBeenCalled();
-		expect(onClearHistory).not.toHaveBeenCalled();
-	});
-});
-
-describe("AskOverlayController — scroll + clipping", () => {
-	it("render() returns all natural lines when within maxRows", () => {
-		const { ctl } = makeController({ rows: 100 });
-		ctl.setAnswer("answer-body");
-		const lines = ctl.render(80);
-		// banner + blank + 0 history + echo + blank + 1 answer + blank + footer = 7
-		expect(lines.length).toBe(7);
-	});
-
-	it("clips top when content overflows terminal height; scroll↑ reveals older history", () => {
-		// Use distinct non-overlapping markers so substring matches are unambiguous.
-		const history: AskTurn[] = Array.from({ length: 20 }, (_, i) => makeTurn(`mark-${i + 1}-end`));
-		const { ctl } = makeController({ history, rows: 10 });
-		ctl.setAnswer("A");
-		const base = ctl.render(80);
-		const maxRows = Math.floor(10 * 0.85); // 8
-		expect(base.length).toBe(maxRows);
-		// Bottom-anchored: footer + answer visible; earliest history hidden
-		expect(base.join("\n")).not.toContain("mark-1-end");
-		expect(base.join("\n")).toContain("mark-20-end");
-		expect(base.join("\n")).toContain("Esc to dismiss");
-		// Scroll up reveals older history at the top.
-		ctl.handleInput("\u001b[A");
-		const scrolled = ctl.render(80);
-		expect(scrolled.length).toBe(maxRows);
-	});
-
-	it("scroll↓ at bottom stays clamped (no throw, still renders maxRows)", () => {
-		const history: AskTurn[] = Array.from({ length: 20 }, (_, i) => makeTurn(`mark-${i + 1}-end`));
-		const { ctl } = makeController({ history, rows: 10 });
-		ctl.setAnswer("A");
-		ctl.handleInput("\u001b[B"); // down
-		const out = ctl.render(80);
-		const maxRows = Math.floor(10 * 0.85);
-		expect(out.length).toBe(maxRows);
-	});
-
-	it("invalidate() is a callable no-op", () => {
-		const { ctl } = makeController();
-		expect(() => ctl.invalidate()).not.toThrow();
-	});
-});
-
-describe("AskOverlayController — banner + echo formatting", () => {
-	it("banner is padded to full visible width", () => {
-		const { ctl } = makeController({ question: "q" });
-		const banner = ctl.render(40)[0];
-		expect(visibleWidth(banner)).toBe(40);
-	});
-
-	it("truncates long questions in the banner with ellipsis", () => {
-		const long = "a".repeat(200);
-		const { ctl } = makeController({ question: long });
-		const banner = ctl.render(40)[0];
-		expect(visibleWidth(banner)).toBe(40);
-		expect(banner).toContain("…");
-	});
-
-	it("history echo uses '/ask ' prefix and trims whitespace", () => {
-		const { ctl } = makeController({ history: [makeTurn("  multi\nline   q  ")] });
-		const out = ctl.render(80).join("\n");
-		expect(out).toContain("/ask multi line q");
-	});
-});
-
-describe("showAskOverlay — factory wiring", () => {
-	it("invokes ctx.ui.custom with overlay options and resolves controllerReady with the AskOverlayController", async () => {
-		const requestRender = vi.fn();
-		const tui = { requestRender, terminal: { rows: 24 } } as unknown as TUI;
-		const custom = vi.fn((factory: unknown, opts: unknown) => {
-			const f = factory as (
-				tui: TUI,
-				theme: Theme,
-				kb: undefined,
-				done: (v: undefined) => void,
-			) => AskOverlayController;
-			const ctl = f(tui, identityTheme, undefined, () => {});
-			// Keep `opts` addressable for the assertion below.
-			(custom as unknown as { lastOpts: unknown }).lastOpts = opts;
-			return new Promise<void>(() => {
-				// keep pending so we can inspect the controller
-				void ctl;
-			});
-		});
-		const ctx = { ui: { custom } } as never;
-
-		const { controllerReady } = showAskOverlay({
-			ctx,
-			question: "q",
-			history: [],
-			controller: new AbortController(),
-			onClearHistory: vi.fn(),
-		});
-
-		const ctl = await controllerReady;
-		expect(ctl).toBeInstanceOf(AskOverlayController);
-		expect(custom).toHaveBeenCalledTimes(1);
-		const opts = (custom as unknown as { lastOpts: { overlay: boolean; overlayOptions: unknown } }).lastOpts;
-		expect(opts).toMatchObject({ overlay: true });
-		expect(opts.overlayOptions).toMatchObject({ anchor: "bottom-center" });
-	});
-
-	it("controller returned by the factory is the same one exposed via controllerReady", async () => {
-		let factoryCtl: AskOverlayController | undefined;
-		const custom = vi.fn((factory: unknown) => {
-			const f = factory as (
-				tui: TUI,
-				theme: Theme,
-				kb: undefined,
-				done: (v: undefined) => void,
-			) => AskOverlayController;
-			factoryCtl = f(
-				{ requestRender: vi.fn(), terminal: { rows: 24 } } as unknown as TUI,
-				identityTheme,
-				undefined,
-				() => {},
-			);
-			return new Promise<void>(() => {});
-		});
-		const ctx = { ui: { custom } } as never;
-		const { controllerReady } = showAskOverlay({
-			ctx,
-			question: "q",
-			history: [],
-			controller: new AbortController(),
-			onClearHistory: vi.fn(),
-		});
-		const ctl = await controllerReady;
-		expect(ctl).toBe(factoryCtl);
-	});
-});