@duckmind/dm-darwin-x64 0.33.1 → 0.33.4

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

@@ -1,238 +0,0 @@
-/**
- * ask-ui — dynamic-height bottom-slot overlay for /ask.
- *
- * Layout (grows with content, bottom-anchored, max = terminal height):
- *   banner (theme.bg stripe, padded to width)        sticky top
- *   blank
- *   history  — "/ask <q>" (accent prefix + muted text), left-padded 2 cols
- *   echo     — "/ask <q>" (accent prefix + muted text), left-padded 2 cols
- *   blank
- *   answer   — body wrapped at width-2, left-padded 2 cols
- *   blank
- *   footer   — key hints (dim)                       sticky bottom
- *
- * Natural height = fixed(5: banner, 3 blanks, footer) + 2 (echo + 1 blank before answer)
- *                  + history.length + answerLines.length.
- * DM-tui bottom-anchors the overlay so it grows upward with each /ask message.
- * If natural height > terminal rows, we clip from the top (older history scrolls off)
- * and ↑/↓ scroll the clip window.
- *
- * Keys (via matchesKey — handles ANSI + Kitty):
- *   Esc → abort in-flight call + dismiss
- *   ↑/↓ → scroll (when content exceeds terminal)
- *   x   → clear current-session /ask history
- *   (f fork key deferred)
- */
-
-import type { ExtensionCommandContext, Theme } from "@mariozechner/pi-coding-agent";
-import type { OverlayOptions } from "@mariozechner/pi-tui";
-import {
-	type Component,
-	Key,
-	matchesKey,
-	type TUI,
-	truncateToWidth,
-	visibleWidth,
-	wrapTextWithAnsi,
-} from "@mariozechner/pi-tui";
-import { type AskTurn, userMessageText } from "./ask.js";
-
-const ASK_OVERLAY_OPTIONS: OverlayOptions = {
-	anchor: "bottom-center",
-	width: "100%",
-	maxHeight: "85%",
-	margin: { left: 0, right: 0, bottom: 0 },
-};
-
-const ASK_MAX_HEIGHT_RATIO = 0.85;
-
-const SIDE_PAD = "  "; // 2-col left gutter for history, echo, footer
-const ANSWER_PAD = "    "; // 4-col left gutter for answer body (double of SIDE_PAD)
-const ASK_LITERAL = "/ask";
-const PENDING_GLYPH = "…";
-const FOOTER_SCROLL = "↑/↓ to scroll";
-const FOOTER_CLEAR = "x to clear history";
-const FOOTER_DISMISS = "Esc to dismiss";
-const FOOTER_SEP = " · ";
-
-type Mode = "pending" | "answer" | "error";
-
-export interface ShowAskOverlayParams {
-	ctx: ExtensionCommandContext;
-	question: string;
-	history: AskTurn[];
-	controller: AbortController;
-	onClearHistory: () => void;
-}
-
-export interface ShowAskOverlayResult {
-	overlayPromise: Promise<void>;
-	controllerReady: Promise<AskOverlayController>;
-}
-
-export class AskOverlayController implements Component {
-	private mode: Mode = "pending";
-	private answer = "";
-	private error = "";
-	private scrollOffset = 0;
-	private history: AskTurn[];
-
-	constructor(
-		private readonly question: string,
-		history: AskTurn[],
-		private readonly theme: Theme,
-		private readonly tui: TUI,
-		private readonly done: (result?: undefined) => void,
-		private readonly controller: AbortController,
-		private readonly onClearHistory: () => void,
-	) {
-		this.history = [...history];
-	}
-
-	setAnswer(text: string): void {
-		this.mode = "answer";
-		this.answer = text;
-		this.tui.requestRender();
-	}
-
-	setError(message: string): void {
-		this.mode = "error";
-		this.error = message;
-		this.tui.requestRender();
-	}
-
-	handleInput(data: string): void {
-		if (matchesKey(data, Key.escape)) {
-			this.controller.abort();
-			this.done();
-			return;
-		}
-		if (matchesKey(data, Key.up)) {
-			this.scrollOffset = Math.max(0, this.scrollOffset - 1);
-			this.tui.requestRender();
-			return;
-		}
-		if (matchesKey(data, Key.down)) {
-			this.scrollOffset = this.scrollOffset + 1;
-			this.tui.requestRender();
-			return;
-		}
-		if (data === "x") {
-			this.history = [];
-			this.onClearHistory();
-			this.scrollOffset = 0;
-			this.tui.requestRender();
-			return;
-		}
-	}
-
-	render(width: number): string[] {
-		const banner = this.renderBanner(width);
-		const historyLines = this.history.map((h) => this.historyLine(userMessageText(h.userMessage), width));
-		const echoLine = this.echoLine(this.question, width);
-		const answerLines = this.renderAnswer(width);
-		const footerAvail = Math.max(1, width - SIDE_PAD.length);
-		const footerParts: string[] = [];
-		if (this.mode !== "pending") footerParts.push(FOOTER_SCROLL);
-		if (this.history.length > 0) footerParts.push(FOOTER_CLEAR);
-		footerParts.push(FOOTER_DISMISS);
-		const footer =
-			SIDE_PAD + truncateToWidth(this.theme.fg("dim", footerParts.join(FOOTER_SEP)), footerAvail, "…", false);
-
-		// Natural content: banner + blank + history + echo + blank + answer + blank + footer
-		const natural: string[] = [banner, "", ...historyLines, echoLine, "", ...answerLines, "", footer];
-
-		// Clip to terminal height if we overflow. Bottom-anchor keeps footer+answer visible;
-		// ↑/↓ scrolls the top (history) up into the clipped region.
-		const termRows = (this.tui.terminal as { rows?: number }).rows ?? 24;
-		const maxRows = Math.max(4, Math.floor(termRows * ASK_MAX_HEIGHT_RATIO));
-		if (natural.length <= maxRows) {
-			return natural;
-		}
-		const excess = natural.length - maxRows;
-		if (this.scrollOffset > excess) this.scrollOffset = excess;
-		// scrollOffset=0 shows the BOTTOM (newest). Scrolling up reveals older history.
-		const start = excess - this.scrollOffset;
-		return natural.slice(start, start + maxRows);
-	}
-
-	invalidate(): void {
-		// no-op — render recomputes from state each cycle
-	}
-
-	private renderBanner(width: number): string {
-		const prefix = `${SIDE_PAD}${ASK_LITERAL} `;
-		const prefixWidth = visibleWidth(prefix);
-		const qAvail = Math.max(0, width - prefixWidth);
-		const qTrunc = truncateToWidth(this.question, qAvail, "…", false);
-		const raw = prefix + qTrunc;
-		const padded = raw + " ".repeat(Math.max(0, width - visibleWidth(raw)));
-		return this.theme.bg("customMessageBg", this.theme.fg("customMessageText", padded));
-	}
-
-	private historyLine(question: string, width: number): string {
-		const qAvail = Math.max(0, width - SIDE_PAD.length);
-		const qClean = question.replace(/\s+/g, " ").trim();
-		const raw = `${ASK_LITERAL} ${qClean}`;
-		const trunc = truncateToWidth(raw, qAvail, "…", false);
-		return SIDE_PAD + this.theme.fg("muted", trunc);
-	}
-
-	private echoLine(question: string, width: number): string {
-		const bodyAvail = Math.max(1, width - SIDE_PAD.length);
-		const prefixWidth = visibleWidth(ASK_LITERAL) + 1; // "/ask "
-		const qAvail = Math.max(0, bodyAvail - prefixWidth);
-		const qClean = question.replace(/\s+/g, " ").trim();
-		const qTrunc = truncateToWidth(qClean, qAvail, "…", false);
-		return `${SIDE_PAD + this.theme.fg("accent", ASK_LITERAL)} ${this.theme.fg("muted", qTrunc)}`;
-	}
-
-	private renderAnswer(width: number): string[] {
-		const bodyWidth = Math.max(1, width - ANSWER_PAD.length);
-		const indent = (lines: string[]) => lines.map((l) => ANSWER_PAD + l);
-
-		if (this.mode === "pending") {
-			return indent([this.theme.fg("warning", PENDING_GLYPH)]);
-		}
-		if (this.mode === "error") {
-			const out: string[] = [];
-			for (const ln of this.error.split("\n")) {
-				const src = ln.length === 0 ? " " : ln;
-				out.push(...wrapTextWithAnsi(this.theme.fg("error", src), bodyWidth));
-			}
-			return indent(out);
-		}
-		const out: string[] = [];
-		for (const ln of this.answer.split("\n")) {
-			const src = ln.length === 0 ? " " : ln;
-			out.push(...wrapTextWithAnsi(src, bodyWidth));
-		}
-		return indent(out);
-	}
-}
-
-export function showAskOverlay(params: ShowAskOverlayParams): ShowAskOverlayResult {
-	let resolveReady!: (controller: AskOverlayController) => void;
-	const controllerReady = new Promise<AskOverlayController>((resolve) => {
-		resolveReady = resolve;
-	});
-
-	const overlayPromise = params.ctx.ui.custom<void>(
-		(tui, theme, _kb, done) => {
-			const controller = new AskOverlayController(
-				params.question,
-				params.history,
-				theme,
-				tui,
-				done,
-				params.controller,
-				params.onClearHistory,
-			);
-			resolveReady(controller);
-			return controller;
-		},
-		{ overlay: true, overlayOptions: ASK_OVERLAY_OPTIONS },
-	);
-
-	return { overlayPromise, controllerReady };
-}

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;
-}