@makefinks/daemon 0.1.0

package/src/utils/debug-logger.ts

@@ -0,0 +1,69 @@
+/**
+ * Debug logger for TUI development.
+ * Writes to a file instead of stdout to avoid UI glitches.
+ *
+ * Usage:
+ *   import { debug } from "../utils/debug-logger";
+ *   debug.log("message", someObject);
+ *
+ * Then run `tail -f debug.log` in a separate terminal.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { getAppConfigDir } from "./preferences";
+
+const LOG_FILE = path.join(getAppConfigDir(), "debug.log");
+const ENABLED = process.env.DEBUG_LOG === "1" || process.env.DEBUG_LOG === "true";
+
+function ensureLogDir(): void {
+	try {
+		fs.mkdirSync(getAppConfigDir(), { recursive: true });
+	} catch {
+		// Silently fail if we can't create the directory
+	}
+}
+
+function formatValue(value: unknown): string {
+	if (value === undefined) return "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+
+function writeLog(level: string, args: unknown[]): void {
+	if (!ENABLED) return;
+
+	const timestamp = new Date().toISOString();
+	const formatted = args.map(formatValue).join(" ");
+	const line = `[${timestamp}] [${level}] ${formatted}\n`;
+
+	try {
+		ensureLogDir();
+		fs.appendFileSync(LOG_FILE, line);
+	} catch {
+		// Silently fail if we can't write
+	}
+}
+
+export const debug = {
+	log: (...args: unknown[]) => writeLog("LOG", args),
+	info: (...args: unknown[]) => writeLog("INFO", args),
+	warn: (...args: unknown[]) => writeLog("WARN", args),
+	error: (...args: unknown[]) => writeLog("ERROR", args),
+
+	/** Clear the log file */
+	clear: () => {
+		if (!ENABLED) return;
+		try {
+			ensureLogDir();
+			fs.writeFileSync(LOG_FILE, "");
+		} catch {
+			// Silently fail
+		}
+	},
+};

package/src/utils/formatters.ts

@@ -0,0 +1,242 @@
+/**
+ * Utility functions for formatting display values in the UI.
+ */
+
+import type { TodoItem } from "../types";
+import { REASONING_ANIMATION } from "../ui/constants";
+
+const MAX_TOOL_INPUT_LINES = 10;
+const MAX_TOOL_INPUT_LINE_CHARS = 140;
+
+/**
+ * Format reasoning content as a single-line preview for ticker/history.
+ */
+export function formatReasoningPreview(content: string): string {
+	const normalized = content.replace(/\n/g, " ");
+	if (!normalized) return "";
+	if (normalized.length <= REASONING_ANIMATION.LINE_WIDTH) return normalized;
+	return normalized.slice(-REASONING_ANIMATION.LINE_WIDTH);
+}
+
+/**
+ * Check if content has any non-whitespace characters.
+ */
+export function hasVisibleText(content: string): boolean {
+	return content.trim().length > 0;
+}
+
+type ElapsedFormatStyle = "compact" | "detailed";
+
+interface FormatElapsedOptions {
+	style?: ElapsedFormatStyle;
+}
+
+/**
+ * Format elapsed time from milliseconds into s / m+s / h+m+s.
+ */
+export function formatElapsedTime(ms: number, options: FormatElapsedOptions = {}): string {
+	const style = options.style ?? "compact";
+	if (!Number.isFinite(ms) || ms <= 0) {
+		return style === "detailed" ? "0.01s" : "0s";
+	}
+
+	if (style === "detailed") {
+		const seconds = ms / 1000;
+		if (seconds < 1) {
+			const clamped = Math.max(0.01, Math.round(seconds * 100) / 100);
+			return `${clamped.toFixed(2)}s`;
+		}
+		if (seconds < 10) {
+			const value = seconds.toFixed(1).replace(/\.0$/, "");
+			return `${value}s`;
+		}
+	}
+
+	const totalSeconds = Math.floor(ms / 1000);
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+
+	const totalMinutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	if (totalMinutes < 60) {
+		return `${totalMinutes}m ${String(seconds).padStart(2, "0")}s`;
+	}
+
+	const hours = Math.floor(totalMinutes / 60);
+	const minutes = totalMinutes % 60;
+	return `${hours}h ${String(minutes).padStart(2, "0")}m ${String(seconds).padStart(2, "0")}s`;
+}
+
+/**
+ * Format a value for display in tool input
+ */
+export function formatValue(value: unknown): string {
+	if (value === null || value === undefined) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		// For arrays of strings, show inline if short enough
+		if (value.every((v) => typeof v === "string")) {
+			const joined = value.join(", ");
+			if (joined.length < 80) return joined;
+		}
+		return `[${value.length} items]`;
+	}
+	return JSON.stringify(value);
+}
+
+/**
+ * Format tool input as display lines
+ */
+export function formatToolInputLines(input: unknown): string[] {
+	try {
+		if (typeof input !== "object" || input === null) {
+			return [String(input)];
+		}
+
+		const lines: string[] = [];
+		for (const [key, value] of Object.entries(input)) {
+			const formatted = formatValue(value);
+			const line = formatted ? `${key}: ${formatted}` : key;
+			// Truncate long lines
+			if (line.length > MAX_TOOL_INPUT_LINE_CHARS) {
+				lines.push(`${line.slice(0, MAX_TOOL_INPUT_LINE_CHARS - 1)}…`);
+			} else {
+				lines.push(line);
+			}
+		}
+
+		if (lines.length > MAX_TOOL_INPUT_LINES) {
+			return [...lines.slice(0, MAX_TOOL_INPUT_LINES), "… (truncated)"];
+		}
+		return lines;
+	} catch (error: unknown) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		return [`[error: ${err.message}]`];
+	}
+}
+
+/**
+ * Todo input structure for the todoManager tool
+ */
+export interface TodoInput {
+	action: "write" | "update" | "list";
+	todos?: Array<{ content: string; status?: string }>;
+	index?: number;
+	status?: string;
+	sessionId?: string;
+}
+
+/**
+ * Formatted todo item with display info
+ */
+export interface FormattedTodoItem {
+	text: string;
+	status: string;
+}
+
+const STATUS_ICON: Record<string, string> = {
+	pending: "○",
+	in_progress: "◐",
+	completed: "●",
+	cancelled: "✕",
+};
+
+/**
+ * Format a single todo item for display
+ */
+export function formatTodoItem(todo: { content: string; status?: string }, idx: number): FormattedTodoItem {
+	const status = todo.status || "pending";
+	const icon = STATUS_ICON[status] || "[ ]";
+	return {
+		text: `${icon} ${todo.content}`,
+		status,
+	};
+}
+
+/**
+ * Format todo list for display based on tool input.
+ * If a snapshot is provided, use it instead of fetching current state.
+ * @param input - The todo tool input
+ * @param snapshot - Optional snapshot of todos for historical display
+ * @param currentTodos - Current todos from the store (for live display of update/list actions)
+ */
+export function formatTodoDisplayLines(
+	input: TodoInput,
+	snapshot?: Array<{ content: string; status: string }>,
+	currentTodos: TodoItem[] = []
+): FormattedTodoItem[] {
+	// If we have a snapshot, always use it (for historical display in conversation)
+	if (snapshot && snapshot.length > 0) {
+		return snapshot.map((todo, idx) => formatTodoItem(todo, idx));
+	}
+
+	if (input.action === "write" && input.todos) {
+		return input.todos.map((todo, idx) => formatTodoItem(todo, idx));
+	}
+
+	if (input.action === "update" || input.action === "list") {
+		// Use passed-in todos for live display
+		if (currentTodos.length === 0) {
+			return [{ text: "(no todos)", status: "pending" }];
+		}
+		// For update, apply the pending status change to display what it will look like
+		if (input.action === "update" && input.index !== undefined && input.status) {
+			const idx = input.index - 1;
+			return currentTodos.map((todo: TodoItem, i: number) => {
+				if (i === idx) {
+					return formatTodoItem({ content: todo.content, status: input.status }, i);
+				}
+				return formatTodoItem(todo, i);
+			});
+		}
+		// For list or update without changes, just show current state
+		return currentTodos.map((todo: TodoItem, idx: number) => formatTodoItem(todo, idx));
+	}
+
+	return [{ text: "(unknown action)", status: "pending" }];
+}
+
+/**
+ * Type guard for TodoInput
+ */
+export function isTodoInput(input: unknown): input is TodoInput {
+	return (
+		typeof input === "object" &&
+		input !== null &&
+		"action" in input &&
+		typeof (input as TodoInput).action === "string"
+	);
+}
+
+/**
+ * Format token count with K suffix for thousands
+ */
+export function formatTokenCount(count: number): string {
+	// if (count >= 1000) {
+	// 	return `${(count / 1000).toFixed(1)}k`;
+	// }
+	return String(count);
+}
+
+export function formatContextWindowK(contextLength: number): string {
+	if (!Number.isFinite(contextLength) || contextLength <= 0) return "";
+	if (contextLength < 1000) return String(Math.floor(contextLength));
+
+	const asK = contextLength % 1024 === 0 ? contextLength / 1024 : Math.round(contextLength / 1000);
+
+	return `${asK}K`;
+}
+
+/**
+ * Format price per 1M tokens for display.
+ */
+export function formatPrice(price: number): string {
+	if (price === 0) {
+		return "FREE";
+	}
+	if (price < 0.01) {
+		return `$${price.toFixed(4)}`;
+	}
+	return `$${price.toFixed(2)}`;
+}

package/src/utils/js-rendering.ts

@@ -0,0 +1,77 @@
+import { execSync } from "node:child_process";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+
+export type JsRenderingUnavailableReason = "package-not-installed" | "binaries-missing";
+
+export interface JsRenderingCapability {
+	available: boolean;
+	reason: string;
+	hint?: string;
+	unavailableReason?: JsRenderingUnavailableReason;
+}
+
+function getGlobalNodeModulesPath(): string | null {
+	try {
+		return execSync("npm root -g", { encoding: "utf-8" }).trim();
+	} catch {
+		return null;
+	}
+}
+
+export async function tryImportPlaywright(): Promise<any | null> {
+	try {
+		return await import("playwright");
+	} catch {}
+
+	const globalPath = getGlobalNodeModulesPath();
+	if (!globalPath) return null;
+
+	const playwrightPath = path.join(globalPath, "playwright");
+	if (!fs.existsSync(playwrightPath)) return null;
+
+	try {
+		const require = createRequire(import.meta.url);
+		return require(playwrightPath);
+	} catch {
+		return null;
+	}
+}
+
+export async function detectLocalPlaywrightChromium(): Promise<JsRenderingCapability> {
+	const playwright = await tryImportPlaywright();
+
+	if (!playwright) {
+		return {
+			available: false,
+			reason: "Playwright is not installed.",
+			hint: "Run: npm i -g playwright && npx playwright install chromium",
+			unavailableReason: "package-not-installed",
+		};
+	}
+
+	try {
+		const executablePath = playwright.chromium.executablePath();
+		if (!executablePath || !fs.existsSync(executablePath)) {
+			return {
+				available: false,
+				reason: "Playwright Chromium binaries are not installed.",
+				hint: "Run: npx playwright install chromium",
+				unavailableReason: "binaries-missing",
+			};
+		}
+
+		return {
+			available: true,
+			reason: "Playwright Chromium is installed.",
+		};
+	} catch {
+		return {
+			available: false,
+			reason: "Playwright Chromium binaries are not installed.",
+			hint: "Run: npx playwright install chromium",
+			unavailableReason: "binaries-missing",
+		};
+	}
+}

package/src/utils/markdown-tables.ts

@@ -0,0 +1,234 @@
+/**
+ * Markdown table formatter based on OpenCode's table alignment fix.
+ * Ensures cell widths match what the terminal actually renders with concealment.
+ */
+
+const widthCache = new Map<string, number>();
+let cacheOperationCount = 0;
+
+export interface MarkdownTableFormatOptions {
+	maxWidth?: number;
+}
+
+export function formatMarkdownTables(text: string, options: MarkdownTableFormatOptions = {}): string {
+	const lines = text.split("\n");
+	const result: string[] = [];
+	let i = 0;
+
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line === undefined) break;
+
+		if (isTableRow(line)) {
+			const tableLines: string[] = [line];
+			i++;
+
+			while (i < lines.length) {
+				const nextLine = lines[i];
+				if (nextLine === undefined || !isTableRow(nextLine)) break;
+				tableLines.push(nextLine);
+				i++;
+			}
+
+			if (isValidTable(tableLines)) {
+				result.push(...formatTable(tableLines, options));
+			} else {
+				result.push(...tableLines);
+			}
+		} else {
+			result.push(line);
+			i++;
+		}
+	}
+
+	incrementOperationCount();
+	return result.join("\n");
+}
+
+function isTableRow(line: string): boolean {
+	const trimmed = line.trim();
+	return trimmed.startsWith("|") && trimmed.endsWith("|") && trimmed.split("|").length > 2;
+}
+
+function isSeparatorRow(line: string): boolean {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) return false;
+	const cells = trimmed.split("|").slice(1, -1);
+	return cells.length > 0 && cells.every((cell) => /^\s*:?-+:?\s*$/.test(cell));
+}
+
+function isValidTable(lines: string[]): boolean {
+	if (lines.length < 2) return false;
+
+	const rows = lines.map((line) =>
+		line
+			.split("|")
+			.slice(1, -1)
+			.map((cell) => cell.trim())
+	);
+
+	const firstRow = rows[0];
+	if (!firstRow || firstRow.length === 0) return false;
+
+	const firstRowCellCount = firstRow.length;
+	const allSameColumnCount = rows.every((row) => row.length === firstRowCellCount);
+	if (!allSameColumnCount) return false;
+
+	const hasSeparator = lines.some((line) => isSeparatorRow(line));
+	return hasSeparator;
+}
+
+function formatTable(lines: string[], options: MarkdownTableFormatOptions): string[] {
+	const separatorIndices = new Set<number>();
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line && isSeparatorRow(line)) separatorIndices.add(i);
+	}
+
+	const rows = lines.map((line) =>
+		line
+			.split("|")
+			.slice(1, -1)
+			.map((cell) => cell.trim())
+	);
+
+	if (rows.length === 0) return lines;
+
+	const colCount = Math.max(...rows.map((row) => row.length));
+
+	const colAlignments: Array<"left" | "center" | "right"> = Array(colCount).fill("left");
+	for (const rowIndex of separatorIndices) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		for (let col = 0; col < row.length; col++) {
+			const cell = row[col] ?? "";
+			colAlignments[col] = getAlignment(cell);
+		}
+	}
+
+	const colWidths: number[] = Array(colCount).fill(3);
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		if (separatorIndices.has(rowIndex)) continue;
+		const row = rows[rowIndex];
+		if (!row) continue;
+		for (let col = 0; col < row.length; col++) {
+			const displayWidth = calculateDisplayWidth(row[col] ?? "");
+			const currentWidth = colWidths[col] ?? 0;
+			colWidths[col] = Math.max(currentWidth, displayWidth);
+		}
+	}
+
+	const totalWidth =
+		2 + colWidths.reduce((sum, width) => sum + width, 0) + (colCount > 1 ? 3 * (colCount - 1) : 0) + 2;
+
+	if (options.maxWidth && totalWidth > options.maxWidth) {
+		return lines;
+	}
+
+	return rows.map((row, rowIndex) => {
+		const cells: string[] = [];
+		for (let col = 0; col < colCount; col++) {
+			const cell = row[col] ?? "";
+			const align = colAlignments[col] ?? "left";
+
+			if (separatorIndices.has(rowIndex)) {
+				cells.push(formatSeparatorCell(colWidths[col] ?? 3));
+			} else {
+				cells.push(padCell(cell, colWidths[col] ?? 3, align));
+			}
+		}
+		if (separatorIndices.has(rowIndex)) {
+			return "╞═" + cells.join("═╪═") + "═╡";
+		}
+		return "│ " + cells.join(" │ ") + " │";
+	});
+}
+
+function getAlignment(delimiterCell: string): "left" | "center" | "right" {
+	const trimmed = delimiterCell.trim();
+	const hasLeftColon = trimmed.startsWith(":");
+	const hasRightColon = trimmed.endsWith(":");
+
+	if (hasLeftColon && hasRightColon) return "center";
+	if (hasRightColon) return "right";
+	return "left";
+}
+
+function calculateDisplayWidth(text: string): number {
+	if (widthCache.has(text)) {
+		return widthCache.get(text)!;
+	}
+
+	const width = getStringWidth(text);
+	widthCache.set(text, width);
+	return width;
+}
+
+function getStringWidth(text: string): number {
+	// Strip markdown symbols for concealment mode.
+	// Content inside backticks should preserve its inner markdown symbols.
+
+	const codeBlocks: string[] = [];
+	const textWithPlaceholders = text.replace(/`(.+?)`/g, (_match, content) => {
+		codeBlocks.push(content);
+		return `__DAEMON_CODE_BLOCK_${codeBlocks.length - 1}__`;
+	});
+
+	let visualText = textWithPlaceholders;
+	let previousText = "";
+
+	while (visualText !== previousText) {
+		previousText = visualText;
+		visualText = visualText
+			.replace(/\*\*\*(.+?)\*\*\*/g, "$1")
+			.replace(/\*\*(.+?)\*\*/g, "$1")
+			.replace(/\*(.+?)\*/g, "$1")
+			.replace(/~~(.+?)~~/g, "$1")
+			.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, "$1")
+			.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)")
+			.replace(/\[([^\]]+)\]\s*\[([^\]]*)\]/g, "$1")
+			.replace(/\[(g\d+|\d+)\]/g, "$1");
+	}
+
+	visualText = visualText.replace(/__DAEMON_CODE_BLOCK_(\d+)__/g, (_match, index) => {
+		return codeBlocks[Number(index)] ?? "";
+	});
+
+	const bun = (globalThis as { Bun?: { stringWidth: (value: string) => number } }).Bun;
+	if (bun?.stringWidth) {
+		return bun.stringWidth(visualText);
+	}
+	return Array.from(visualText).length;
+}
+
+function padCell(text: string, width: number, align: "left" | "center" | "right"): string {
+	const displayWidth = calculateDisplayWidth(text);
+	const totalPadding = Math.max(0, width - displayWidth);
+
+	if (align === "center") {
+		const leftPad = Math.floor(totalPadding / 2);
+		const rightPad = totalPadding - leftPad;
+		return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+	}
+	if (align === "right") {
+		return " ".repeat(totalPadding) + text;
+	}
+	return text + " ".repeat(totalPadding);
+}
+
+function formatSeparatorCell(width: number): string {
+	return "═".repeat(width);
+}
+
+function incrementOperationCount() {
+	cacheOperationCount++;
+
+	if (cacheOperationCount > 100 || widthCache.size > 1000) {
+		cleanupCache();
+	}
+}
+
+function cleanupCache() {
+	widthCache.clear();
+	cacheOperationCount = 0;
+}