@huseynsnmz/pi-suite 0.0.0-stage → 0.2.0

package/packages/board/src/core/screen-log.mjs

@@ -0,0 +1,160 @@
+import {
+	appendFileSync,
+	closeSync,
+	existsSync,
+	fstatSync,
+	fsyncSync,
+	openSync,
+	readSync,
+	renameSync,
+	statSync,
+	unlinkSync,
+	writeSync,
+} from "node:fs";
+
+export const SCREEN_LOG_REPLAY_BYTES = 100_000;
+export const SCREEN_LOG_MAX_BYTES = 5_000_000;
+
+export const defaultScreenLogFs = Object.freeze({
+	appendFileSync,
+	closeSync,
+	existsSync,
+	fstatSync,
+	fsyncSync,
+	openSync,
+	readSync,
+	renameSync,
+	statSync,
+	unlinkSync,
+	writeSync,
+});
+
+let tempSequence = 0;
+
+/** @param {string} file @param {number} maxBytes @param {typeof defaultScreenLogFs} fs */
+export function readScreenLogTailBytes(file, maxBytes = SCREEN_LOG_REPLAY_BYTES, fs = defaultScreenLogFs) {
+	return readTailResult(file, maxBytes, fs).data;
+}
+
+/** @param {string} file @param {number} maxBytes */
+export function readScreenLogTail(file, maxBytes = SCREEN_LOG_REPLAY_BYTES) {
+	return readScreenLogTailBytes(file, maxBytes).toString("utf8");
+}
+
+/**
+ * Compact an existing screen log when it exceeds maxBytes.
+ * @param {string} file
+ * @param {{ maxBytes?: number, retainBytes?: number, fs?: typeof defaultScreenLogFs }} [opts]
+ */
+export function reconcileScreenLog(file, opts = {}) {
+	const fs = opts.fs ?? defaultScreenLogFs;
+	const { maxBytes, retainBytes } = limits(opts);
+	const size = fileSize(file, 0, fs);
+	if (size <= maxBytes) return size;
+	const tail = readTailResult(file, retainBytes, fs);
+	if (!tail.ok || !replaceScreenLog(file, tail.data, fs)) return fileSize(file, size, fs);
+	return fileSize(file, tail.data.length, fs);
+}
+
+/**
+ * Append PTY output while bounding the persisted replay log.
+ * @param {string} file
+ * @param {string|Buffer} data
+ * @param {number} currentBytes
+ * @param {{ maxBytes?: number, retainBytes?: number, fs?: typeof defaultScreenLogFs }} [opts]
+ */
+export function appendBoundedScreenLog(file, data, currentBytes, opts = {}) {
+	const fs = opts.fs ?? defaultScreenLogFs;
+	const { maxBytes, retainBytes } = limits(opts);
+	const payload = Buffer.isBuffer(data) ? data : Buffer.from(data);
+	let size = Number.isFinite(currentBytes) && currentBytes >= 0 ? currentBytes : fileSize(file, 0, fs);
+
+	if (size > maxBytes) {
+		size = reconcileScreenLog(file, { maxBytes, retainBytes, fs });
+		if (size > maxBytes) return size;
+	}
+	if (payload.length === 0) return size;
+	if (payload.length >= maxBytes) {
+		const tail = payload.subarray(Math.max(0, payload.length - retainBytes));
+		if (!replaceScreenLog(file, tail, fs)) return fileSize(file, size, fs);
+		return fileSize(file, tail.length, fs);
+	}
+
+	try {
+		fs.appendFileSync(file, payload);
+	} catch {
+		return fileSize(file, size, fs);
+	}
+	size += payload.length;
+	if (size <= maxBytes) return size;
+	return reconcileScreenLog(file, { maxBytes, retainBytes, fs });
+}
+
+/** @param {string} file @param {number} maxBytes @param {typeof defaultScreenLogFs} fs */
+function readTailResult(file, maxBytes, fs) {
+	if (!file || maxBytes <= 0 || !fs.existsSync(file)) return { ok: true, data: Buffer.alloc(0) };
+	let fd;
+	try {
+		fd = fs.openSync(file, "r");
+		const size = fs.fstatSync(fd).size;
+		const length = Math.min(size, Math.floor(maxBytes));
+		if (length <= 0) return { ok: true, data: Buffer.alloc(0) };
+		const output = Buffer.allocUnsafe(length);
+		const start = size - length;
+		let offset = 0;
+		while (offset < length) {
+			const read = fs.readSync(fd, output, offset, length - offset, start + offset);
+			if (read === 0) break;
+			offset += read;
+		}
+		return { ok: true, data: offset === length ? output : output.subarray(0, offset) };
+	} catch {
+		return { ok: false, data: Buffer.alloc(0) };
+	} finally {
+		if (fd !== undefined) {
+			try { fs.closeSync(fd); } catch {}
+		}
+	}
+}
+
+/** @param {{ maxBytes?: number, retainBytes?: number }} opts */
+function limits(opts) {
+	const maxBytes = positiveInt(opts.maxBytes, SCREEN_LOG_MAX_BYTES);
+	return { maxBytes, retainBytes: Math.min(positiveInt(opts.retainBytes, SCREEN_LOG_REPLAY_BYTES), maxBytes) };
+}
+
+/** @param {string} file @param {Buffer} data @param {typeof defaultScreenLogFs} fs */
+function replaceScreenLog(file, data, fs) {
+	const temp = `${file}.${process.pid}.${tempSequence++}.tmp`;
+	let fd;
+	try {
+		fd = fs.openSync(temp, "w");
+		let offset = 0;
+		while (offset < data.length) offset += fs.writeSync(fd, data, offset, data.length - offset, offset);
+		fs.fsyncSync(fd);
+		fs.closeSync(fd);
+		fd = undefined;
+		fs.renameSync(temp, file);
+		return true;
+	} catch {
+		if (fd !== undefined) {
+			try { fs.closeSync(fd); } catch {}
+		}
+		try { fs.unlinkSync(temp); } catch {}
+		return false;
+	}
+}
+
+/** @param {string} file @param {number} fallback @param {typeof defaultScreenLogFs} fs */
+function fileSize(file, fallback, fs) {
+	try {
+		return fs.statSync(file).size;
+	} catch {
+		return fallback;
+	}
+}
+
+function positiveInt(value, fallback) {
+	const number = Number(value);
+	return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}

package/packages/board/src/core/session-view.mjs

@@ -0,0 +1,174 @@
+/**
+ * Read and project a managed Pi session file into a simple display model for the
+ * dashboard's non-interrupting session view.
+ *
+ * We show the current active branch only: starting from the last appended entry
+ * (the active leaf in normal Pi append semantics), walk parentId links to root,
+ * then render messages / visible custom messages / summaries on that branch.
+ */
+import { existsSync, readFileSync } from "node:fs";
+
+/**
+ * @typedef {Object} SessionViewItem
+ * @property {string} id
+ * @property {"user"|"assistant"|"custom"|"note"} role
+ * @property {string} label
+ * @property {string} text
+ * @property {string} timestamp
+ * @property {string} entryType
+ */
+
+/**
+ * @typedef {Object} SessionViewData
+ * @property {{ id:string, cwd:string }|null} header
+ * @property {SessionViewItem[]} items
+ * @property {string|null} error
+ */
+
+/**
+ * Load and parse one session file.
+ * @param {string} sessionFile
+ * @returns {SessionViewData}
+ */
+export function loadSessionView(sessionFile) {
+	if (!sessionFile || !existsSync(sessionFile)) {
+		return { header: null, items: [], error: "Session file not created yet." };
+	}
+	try {
+		return parseSessionText(readFileSync(sessionFile, "utf8"));
+	} catch (err) {
+		return {
+			header: null,
+			items: [],
+			error: `Couldn't read session: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+}
+
+/**
+ * Parse session JSONL into a displayable active branch.
+ * @param {string} text
+ * @returns {SessionViewData}
+ */
+export function parseSessionText(text) {
+	/** @type {{ id:string, cwd:string }|null} */
+	let header = null;
+	/** @type {any[]} */
+	const entries = [];
+	/** @type {Map<string, any>} */
+	const byId = new Map();
+
+	for (const rawLine of String(text || "").split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line) continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry?.type === "session") {
+			header = { id: String(entry.id || ""), cwd: String(entry.cwd || "") };
+			continue;
+		}
+		if (!entry || typeof entry !== "object" || typeof entry.id !== "string") continue;
+		entries.push(entry);
+		byId.set(entry.id, entry);
+	}
+
+	if (entries.length === 0) return { header, items: [], error: null };
+
+	const leaf = entries[entries.length - 1];
+	const branch = activeBranch(leaf, byId);
+	const items = branch.flatMap(displayItemsForEntry);
+	return { header, items, error: null };
+}
+
+/**
+ * Walk from `leaf` to root following parentId pointers.
+ * @param {any} leaf
+ * @param {Map<string, any>} byId
+ * @returns {any[]}
+ */
+function activeBranch(leaf, byId) {
+	/** @type {any[]} */
+	const out = [];
+	const seen = new Set();
+	let cur = leaf;
+	while (cur && typeof cur.id === "string" && !seen.has(cur.id)) {
+		out.push(cur);
+		seen.add(cur.id);
+		cur = cur.parentId ? byId.get(cur.parentId) ?? null : null;
+	}
+	out.reverse();
+	return out;
+}
+
+/**
+ * @param {any} entry
+ * @returns {SessionViewItem[]}
+ */
+function displayItemsForEntry(entry) {
+	switch (entry?.type) {
+		case "message": {
+			const role = entry.message?.role;
+			const text = contentText(entry.message?.content);
+			if (!text) return [];
+			if (role === "user") {
+				return [{ id: entry.id, role: "user", label: "you", text, timestamp: String(entry.timestamp || ""), entryType: entry.type }];
+			}
+			if (role === "assistant") {
+				return [{ id: entry.id, role: "assistant", label: "agent", text, timestamp: String(entry.timestamp || ""), entryType: entry.type }];
+			}
+			return [{ id: entry.id, role: "note", label: String(role || "message"), text, timestamp: String(entry.timestamp || ""), entryType: entry.type }];
+		}
+		case "custom_message": {
+			if (entry.display === false) return [];
+			const text = contentText(entry.content);
+			if (!text) return [];
+			return [{
+				id: entry.id,
+				role: "custom",
+				label: String(entry.customType || "context"),
+				text,
+				timestamp: String(entry.timestamp || ""),
+				entryType: entry.type,
+			}];
+		}
+		case "branch_summary":
+			return [{
+				id: entry.id,
+				role: "note",
+				label: "branch summary",
+				text: String(entry.summary || "").trim(),
+				timestamp: String(entry.timestamp || ""),
+				entryType: entry.type,
+			}].filter((x) => x.text);
+		case "compaction":
+			return [{
+				id: entry.id,
+				role: "note",
+				label: "compaction",
+				text: String(entry.summary || "").trim(),
+				timestamp: String(entry.timestamp || ""),
+				entryType: entry.type,
+			}].filter((x) => x.text);
+		default:
+			return [];
+	}
+}
+
+/**
+ * Convert Pi message/content blocks to plain text.
+ * @param {any} content
+ * @returns {string}
+ */
+function contentText(content) {
+	if (typeof content === "string") return content.trim();
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((b) => b && b.type === "text" && typeof b.text === "string")
+		.map((b) => b.text)
+		.join("\n")
+		.trim();
+}

package/packages/board/src/core/slash-commands.mjs

@@ -0,0 +1,52 @@
+/**
+ * Pi's own commands. It doesn't export this list, and pi.getCommands() leaves them out.
+ * From pi-coding-agent 1.5.0, dist/core/slash-commands.js.
+ */
+export const BUILTIN_COMMANDS = [
+	["settings", "Open settings menu"],
+	["model", "Select model (opens selector UI)"],
+	["tree", "Navigate session tree (switch branches)"],
+	["thinking", "Set thinking level"],
+	["scoped-models", "Enable/disable models for Ctrl+P cycling"],
+	["export", "Export session (HTML default, or specify path: .html/.jsonl)"],
+	["import", "Import a JSONL session, preserving its ID and working directory"],
+	["share", "Share session via a Radius artifact or a GitHub gist"],
+	["bug", "Report a bug to the Pi developers"],
+	["copy", "Copy last agent message to clipboard"],
+	["name", "Set session display name"],
+	["session", "Show session info and stats"],
+	["changelog", "Show changelog entries"],
+	["hotkeys", "Show all keyboard shortcuts"],
+	["fork", "Create a new fork from a previous user message"],
+	["clone", "Duplicate the current session at the current position"],
+	["trust", "Save project trust decision for future sessions"],
+	["login", "Configure provider authentication"],
+	["logout", "Remove provider authentication"],
+	["new", "Start a new session"],
+	["compact", "Manually compact the session context"],
+	["resume", "Resume another session"],
+	["reload", "Reload keybindings, extensions, skills, prompts, themes, and context files"],
+	["quit", "Quit Pi"],
+].map(([name, description]) => ({ name, description, source: "builtin" }));
+
+/**
+ * What the board offers after `/`: Pi's commands, then what extensions, templates and skills add.
+ * @param {{ name: string, description?: string, source: string }[]} added from pi.getCommands()
+ */
+export function boardCommands(added) {
+	const seen = new Set(BUILTIN_COMMANDS.map((command) => command.name));
+	return [...BUILTIN_COMMANDS, ...added.filter((command) => !seen.has(command.name))];
+}
+
+/**
+ * Commands act on the Pi the board is open in. Templates and skills are prompts, so they
+ * start a session like any task, and so does anything that isn't a command.
+ * @param {string} text
+ * @param {{ name: string, source: string }[]} commands
+ */
+export function runsInPi(text, commands) {
+	if (!text.startsWith("/")) return false;
+	const name = text.slice(1).split(/\s/, 1)[0];
+	const command = commands.find((candidate) => candidate.name === name);
+	return command !== undefined && command.source !== "prompt" && command.source !== "skill";
+}