@huseynsnmz/pi-suite 0.0.0-stage → 0.2.0

package/packages/board/src/ui/chrome.ts

@@ -0,0 +1,20 @@
+/**
+ * The board blanks Pi's header and footer while it is up. Pi can only hand them back as its
+ * defaults, so this also tells any extension that drew its own to draw them again.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export const BOARD_CLOSED_EVENT = "agent-board:closed";
+
+let events: ExtensionAPI["events"] | null = null;
+
+export function announceBoardClosedOn(bus: ExtensionAPI["events"]): void {
+	events = bus;
+}
+
+export function restoreChrome(ctx: Pick<ExtensionContext, "ui">): void {
+	ctx.ui.setHeader(undefined);
+	ctx.ui.setFooter(undefined);
+	ctx.ui.setWorkingVisible(true);
+	events?.emit(BOARD_CLOSED_EVENT, undefined);
+}

package/packages/board/src/ui/dashboard-decisions.mjs

@@ -0,0 +1,55 @@
+/**
+ * Dashboard decision helpers for host prewarm and attach prelude (issue #70 A14).
+ *
+ * Pure functions extracted from src/ui/dashboard.ts so the branching contract is
+ * node-testable without pi's TS loader (same pattern as commands/attach-decision.mjs).
+ * `hostActive` covers starting/alive/stopping claims from store.loadRow — pending
+ * claims count as an already-registered launch, so prewarm never re-spawns them.
+ */
+
+/**
+ * Prewarm decision for the selected row.
+ * - "mark-only": the row has an active host claim — mark it prewarmed WITHOUT
+ *   calling prewarmHost (a pending/starting claim is already a launch; the old
+ *   hostAlive guard re-checked it on every debounce tick).
+ * - "skip": busy row without a host claim — no prewarm, no mark.
+ * - "prewarm": no claim — call service.prewarmHost once; the caller marks only on ok.
+ * @param {{ hostActive?: boolean, agentBusy?: boolean }} row
+ * @returns {{ action: "mark-only" | "skip" | "prewarm" }}
+ */
+export function planPrewarm({ hostActive, agentBusy }) {
+	if (hostActive) return { action: "mark-only" };
+	if (agentBusy) return { action: "skip" };
+	return { action: "prewarm" };
+}
+
+/**
+ * Attach prelude for a dashboard row. A hostActive row attaches directly — the
+ * async resolver owns starting/stopping wait, so no interrupt confirmation is
+ * offered even when the row is busy. A busy row WITHOUT a host claim keeps the
+ * existing stopFirst confirm; everything else attaches directly.
+ * @param {{ hostActive?: boolean, agentBusy?: boolean }} row
+ * @returns {{ plan: "attach" | "confirm-stop-first" }}
+ */
+export function planDashboardAttach({ hostActive, agentBusy }) {
+	if (!hostActive && agentBusy) return { plan: "confirm-stop-first" };
+	return { plan: "attach" };
+}
+
+/**
+ * Map a service reply() result to the dashboard notice (issue #70: queued and
+ * sent are different outcomes — a queued reply is durable, not yet delivered).
+ * Result shapes from service.reply(): {ok:false,error} | {ok:true,queued:true}
+ * | {ok:true,sent:true} | {ok:true,hostMode,fallbackReason?}.
+ * @param {{ ok?: boolean, error?: string, queued?: boolean, sent?: boolean, hostMode?: string|null, fallbackReason?: string }} res
+ * @returns {{ level: "info" | "warn" | "error", text: string }}
+ */
+export function replyNotice(res) {
+	if (!res?.ok) return { level: "error", text: res?.error ?? "Reply failed" };
+	if (res.queued) return { level: "info", text: "Reply queued — will deliver when the host is ready" };
+	if (res.sent) return { level: "info", text: "Reply sent" };
+	if (res.hostMode === "json-runner") {
+		return { level: "warn", text: `Reply sent with non-live fallback: ${res.fallbackReason ?? "PTY unavailable"}` };
+	}
+	return { level: "info", text: "Reply sent" };
+}

package/packages/board/src/ui/dashboard-evidence.mjs

@@ -0,0 +1,85 @@
+/** Pure evidence panel rendering helpers for dashboard evidence mode. */
+import { relativeTime, truncate } from "../core/heuristics.mjs";
+
+/**
+ * @param {{ row:any, evidence:any, diagnostics:any[], paths?:Record<string,string>, width:number, now?:number }} opts
+ * @returns {string[]}
+ */
+export function buildEvidencePanel(opts) {
+	const width = opts.width ?? 80;
+	const now = opts.now ?? Date.now();
+	const evidence = opts.evidence ?? {};
+	const diagnostics = Array.isArray(opts.diagnostics) ? opts.diagnostics : [];
+	const paths = opts.paths ?? {};
+	const lines = [];
+	lines.push(`Evidence / diagnostics for ${opts.row?.meta?.name ?? "session"}`);
+	lines.push(`State: ${opts.row?.state?.semanticState ?? "unknown"} · Outcome: ${evidence.outcome ?? "unknown"}${evidence.ready ? " · ready" : ""}`);
+	if (evidence.summary) lines.push(...wrap(`Summary: ${evidence.summary}`, width));
+	lines.push("");
+	lines.push(`Changed files (${evidence.fileChanges?.length ?? 0})`);
+	if (evidence.fileChanges?.length) {
+		for (const f of evidence.fileChanges.slice(-12)) lines.push(`  ${f.action ?? "changed"} ${f.path}${f.count > 1 ? ` ×${f.count}` : ""}`);
+	} else lines.push("  —");
+	lines.push("");
+	lines.push(`Commands (${evidence.commands?.length ?? 0})`);
+	if (evidence.commands?.length) {
+		for (const c of evidence.commands.slice(-12)) {
+			const status = c.status === "failed" ? "✗" : c.status === "passed" ? "✓" : c.status === "started" ? "…" : "?";
+			lines.push(...wrap(`  ${status} [${c.kind ?? "other"}] ${c.command || "command"}`, width, 2));
+			if (c.outputPreview) lines.push(...wrap(`    ${c.outputPreview}`, width, 2));
+		}
+	} else lines.push("  —");
+	lines.push("");
+	lines.push(`Errors (${evidence.errors?.length ?? 0})`);
+	if (evidence.errors?.length) {
+		for (const e of evidence.errors.slice(-8)) lines.push(...wrap(`  ${e.source ?? "error"}: ${e.message}`, width, 2));
+	} else lines.push("  —");
+	lines.push("");
+	lines.push("Latest assistant evidence");
+	const latest = evidence.assistantEvidence?.[evidence.assistantEvidence.length - 1]?.text;
+	lines.push(...wrap(`  ${latest || "—"}`, width, 8));
+	lines.push("");
+	lines.push(`Diagnostics (${diagnostics.length} shown)`);
+	if (diagnostics.length) {
+		for (const d of diagnostics.slice(-12)) {
+			const age = d.at ? relativeTime(d.at, now) : "?";
+			lines.push(...wrap(`  ${age} ${String(d.level ?? "info").toUpperCase()} ${d.code ?? "event"}: ${d.message ?? ""}`, width, 2));
+		}
+	} else lines.push("  —");
+	lines.push("");
+	lines.push("Artifacts");
+	for (const [name, value] of Object.entries(paths)) {
+		if (value) lines.push(...wrap(`  ${name}: ${value}`, width, 2));
+	}
+	if (Object.keys(paths).length === 0) lines.push("  —");
+	return lines.map((line) => clip(line, width));
+}
+
+/** @param {string} text @param {number} width @param {number} [maxLines] */
+function wrap(text, width, maxLines = 10) {
+	const words = String(text ?? "").split(/\s+/);
+	const out = [];
+	let line = "";
+	for (const word of words) {
+		if (!word) continue;
+		const next = line ? `${line} ${word}` : word;
+		if (visibleLength(next) > width && line) {
+			out.push(line);
+			line = word;
+		} else line = next;
+		if (out.length >= maxLines) break;
+	}
+	if (line && out.length < maxLines) out.push(line);
+	if (out.length === maxLines && words.length > 0) out[out.length - 1] = truncate(out[out.length - 1], Math.max(1, width - 1));
+	return out.length ? out : [""];
+}
+
+/** @param {string} line @param {number} width */
+function clip(line, width) {
+	return truncate(line, Math.max(1, width));
+}
+
+/** @param {string} s */
+function visibleLength(s) {
+	return String(s || "").replace(/\x1b\[[0-9;]*m/g, "").length;
+}