@makefinks/daemon 0.1.0

package/src/components/tool-layouts/layouts/index.ts

@@ -0,0 +1,8 @@
+import "./bash";
+import "./web-search";
+import "./url-tools";
+import "./read-file";
+import "./subagent";
+import "./todo";
+import "./system-info";
+import "./grounding";

package/src/components/tool-layouts/layouts/read-file.ts

@@ -0,0 +1,59 @@
+import type { ToolLayoutConfig, ToolHeader } from "../types";
+import { registerToolLayout } from "../registry";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function extractPath(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("path" in input && typeof input.path === "string") {
+		return input.path;
+	}
+	return null;
+}
+
+function formatReadFileResult(result: unknown): string[] | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return [`error: ${result.error}`];
+	}
+	if (result.success !== true) return null;
+	const path = typeof result.path === "string" ? result.path : "";
+	const startLine = typeof result.startLine === "number" ? result.startLine : undefined;
+	const endLine = typeof result.endLine === "number" ? result.endLine : undefined;
+	const hasMore = typeof result.hasMore === "boolean" ? result.hasMore : undefined;
+	const content = typeof result.content === "string" ? result.content : "";
+
+	const range =
+		startLine !== undefined && endLine !== undefined && startLine > 0 && endLine > 0
+			? ` (${startLine}-${endLine}${hasMore ? "+" : ""})`
+			: "";
+
+	if (!content.trim()) return path ? [`${path}${range}`] : null;
+
+	const MAX_LINES = 4;
+	const MAX_CHARS = 160;
+	const lines = content
+		.split("\n")
+		.slice(0, MAX_LINES)
+		.map((l) => (l.length > MAX_CHARS ? `${l.slice(0, MAX_CHARS - 1)}…` : l));
+
+	return [`${path}${range}:`, ...lines];
+}
+
+export const readFileLayout: ToolLayoutConfig = {
+	abbreviation: "read",
+
+	getHeader: (input): ToolHeader | null => {
+		const path = extractPath(input);
+		if (!path) return null;
+		return { primary: path };
+	},
+
+	formatResult: formatReadFileResult,
+};
+
+registerToolLayout("readFile", readFileLayout);

package/src/components/tool-layouts/layouts/subagent.tsx

@@ -0,0 +1,118 @@
+import type { ToolLayoutConfig, ToolHeader, ToolLayoutRenderProps } from "../types";
+import type { ToolCallStatus } from "../../../types";
+import { registerToolLayout } from "../registry";
+import { COLORS } from "../../../ui/constants";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function extractSubagentSummary(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("summary" in input && typeof input.summary === "string") {
+		return input.summary;
+	}
+	if ("topic" in input && typeof input.topic === "string") {
+		return input.topic;
+	}
+	return null;
+}
+
+function extractSearchQuery(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("query" in input && typeof input.query === "string") {
+		return input.query;
+	}
+	return null;
+}
+
+function abbreviateToolName(name: string): string {
+	const abbreviations: Record<string, string> = {
+		webSearch: "search",
+		fetchUrls: "fetch",
+		renderUrl: "render",
+		getSystemInfo: "sys",
+		runBash: "bash",
+		todoManager: "todo",
+		readFile: "read",
+		groundingManager: "grounding",
+	};
+	return abbreviations[name] ?? name.slice(0, 8);
+}
+
+function getStepStatusIcon(status: ToolCallStatus): string {
+	switch (status) {
+		case "running":
+			return "~";
+		case "completed":
+			return "✓";
+		case "failed":
+			return "x";
+		default:
+			return " ";
+	}
+}
+
+function getStepStatusColor(status: ToolCallStatus): string {
+	switch (status) {
+		case "running":
+			return COLORS.STATUS_RUNNING;
+		case "completed":
+			return COLORS.STATUS_COMPLETED;
+		case "failed":
+			return COLORS.STATUS_FAILED;
+		default:
+			return COLORS.STATUS_PENDING;
+	}
+}
+
+function SubagentBody({ call }: ToolLayoutRenderProps) {
+	if (!call.subagentSteps || call.subagentSteps.length === 0) {
+		return null;
+	}
+
+	return (
+		<box flexDirection="column" paddingLeft={2} marginTop={0}>
+			{call.subagentSteps.map((step, idx) => {
+				const toolLabel = abbreviateToolName(step.toolName);
+				let stepLabel = toolLabel;
+				if (step.toolName === "webSearch") {
+					const query = extractSearchQuery(step.input);
+					if (query) {
+						stepLabel = `${toolLabel}: "${query}"`;
+					}
+				}
+
+				return (
+					<box key={`${step.toolName}-${idx}`} flexDirection="row" alignItems="center">
+						{step.status === "running" ? (
+							<spinner name="dots" color={getStepStatusColor(step.status)} />
+						) : (
+							<text>
+								<span fg={getStepStatusColor(step.status)}>{getStepStatusIcon(step.status)}</span>
+							</text>
+						)}
+						<text marginLeft={1}>
+							<span fg={COLORS.TOOL_INPUT_TEXT}>{stepLabel}</span>
+						</text>
+					</box>
+				);
+			})}
+		</box>
+	);
+}
+
+export const subagentLayout: ToolLayoutConfig = {
+	abbreviation: "agent",
+
+	getHeader: (input): ToolHeader | null => {
+		const summary = extractSubagentSummary(input);
+		return summary ? { primary: summary } : null;
+	},
+
+	renderBody: SubagentBody,
+};
+
+registerToolLayout("subagent", subagentLayout);

package/src/components/tool-layouts/layouts/system-info.ts

@@ -0,0 +1,8 @@
+import type { ToolLayoutConfig } from "../types";
+import { registerToolLayout } from "../registry";
+
+export const systemInfoLayout: ToolLayoutConfig = {
+	abbreviation: "sys",
+};
+
+registerToolLayout("getSystemInfo", systemInfoLayout);

package/src/components/tool-layouts/layouts/todo.tsx

@@ -0,0 +1,139 @@
+import { TextAttributes } from "@opentui/core";
+import type { ToolLayoutConfig, ToolHeader, ToolLayoutRenderProps } from "../types";
+import { registerToolLayout } from "../registry";
+import { COLORS } from "../../../ui/constants";
+import type { TodoItem } from "../../../types";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+interface TodoInput {
+	action: "write" | "update" | "list";
+	todos?: Array<{ content: string; status?: string }>;
+	index?: number;
+	status?: string;
+}
+
+function isTodoInput(input: unknown): input is TodoInput {
+	return isRecord(input) && "action" in input && typeof input.action === "string";
+}
+
+function extractTodoAction(input: unknown): string | null {
+	if (!isRecord(input)) return null;
+	if ("action" in input && typeof input.action === "string") {
+		return input.action;
+	}
+	return null;
+}
+
+const STATUS_ICON: Record<string, string> = {
+	pending: "○",
+	in_progress: "◐",
+	completed: "●",
+	cancelled: "✕",
+};
+
+interface FormattedTodoItem {
+	text: string;
+	status: string;
+}
+
+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,
+	};
+}
+
+function formatTodoDisplayLines(
+	input: TodoInput,
+	snapshot?: Array<{ content: string; status: string }>,
+	currentTodos: TodoItem[] = []
+): FormattedTodoItem[] {
+	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") {
+		if (currentTodos.length === 0) {
+			return [{ text: "(no todos)", status: "pending" }];
+		}
+		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);
+			});
+		}
+		return currentTodos.map((todo: TodoItem, idx: number) => formatTodoItem(todo, idx));
+	}
+
+	return [{ text: "(unknown action)", status: "pending" }];
+}
+
+function getTodoColor(status: string): string {
+	switch (status) {
+		case "in_progress":
+			return COLORS.STATUS_RUNNING;
+		case "completed":
+		case "cancelled":
+			return COLORS.STATUS_DONE_DIM;
+		default:
+			return COLORS.STATUS_PENDING;
+	}
+}
+
+function getTodoAttributes(status: string): number {
+	if (status === "completed" || status === "cancelled") {
+		return TextAttributes.STRIKETHROUGH;
+	}
+	return TextAttributes.NONE;
+}
+
+function TodoBody({ call }: ToolLayoutRenderProps) {
+	if (!isTodoInput(call.input)) {
+		return null;
+	}
+
+	const lines = formatTodoDisplayLines(call.input, call.todoSnapshot);
+
+	if (lines.length === 0) {
+		return null;
+	}
+
+	return (
+		<box flexDirection="column" paddingLeft={2}>
+			{lines.map((item: FormattedTodoItem, idx: number) => (
+				<text key={idx}>
+					<span fg={getTodoColor(item.status)} attributes={getTodoAttributes(item.status)}>
+						{item.text}
+					</span>
+				</text>
+			))}
+		</box>
+	);
+}
+
+export const todoLayout: ToolLayoutConfig = {
+	abbreviation: "todo",
+
+	getHeader: (input): ToolHeader | null => {
+		const action = extractTodoAction(input);
+		return action ? { secondary: action } : null;
+	},
+
+	renderBody: TodoBody,
+};
+
+registerToolLayout("todoManager", todoLayout);

package/src/components/tool-layouts/layouts/url-tools.ts

@@ -0,0 +1,220 @@
+import type { ToolLayoutConfig, ToolHeader } from "../types";
+import { registerToolLayout } from "../registry";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+interface FetchUrlsInput {
+	url: string;
+	lineOffset?: number;
+	lineLimit?: number;
+	highlightQuery?: string;
+}
+
+function extractFetchUrlsInput(input: unknown): FetchUrlsInput | null {
+	if (!isRecord(input)) return null;
+	if (!("url" in input) || typeof input.url !== "string") return null;
+
+	const lineOffset =
+		"lineOffset" in input && typeof input.lineOffset === "number" ? input.lineOffset : undefined;
+	const lineLimit = "lineLimit" in input && typeof input.lineLimit === "number" ? input.lineLimit : undefined;
+	const highlightQuery =
+		"highlightQuery" in input && typeof input.highlightQuery === "string" ? input.highlightQuery : undefined;
+	return { url: input.url, lineOffset, lineLimit, highlightQuery };
+}
+
+function mergeFetchUrlsDefaults(input: FetchUrlsInput | null, result?: unknown): FetchUrlsInput | null {
+	if (!input) return null;
+	if (!result || typeof result !== "object") return input;
+
+	const resultRecord = result as Record<string, unknown>;
+	const lineOffset =
+		input.lineOffset ?? (typeof resultRecord.lineOffset === "number" ? resultRecord.lineOffset : undefined);
+	const lineLimit =
+		input.lineLimit ?? (typeof resultRecord.lineLimit === "number" ? resultRecord.lineLimit : undefined);
+
+	return { ...input, lineOffset, lineLimit };
+}
+
+function formatFetchUrlsHeader(input: FetchUrlsInput): string {
+	if (input.highlightQuery) {
+		return `highlight: "${input.highlightQuery}"`;
+	}
+	const parts: string[] = [];
+	if (input.lineOffset !== undefined) {
+		parts.push(`lineOffset=${input.lineOffset}`);
+	}
+	if (input.lineLimit !== undefined) {
+		parts.push(`lineLimit=${input.lineLimit}`);
+	}
+	return parts.length > 0 ? `(${parts.join(", ")})` : "";
+}
+
+function normalizeWhitespace(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\t/g, "  ");
+}
+
+type ExaLikeItem = {
+	title?: unknown;
+	url?: unknown;
+	text?: unknown;
+	lineOffset?: unknown;
+	lineLimit?: unknown;
+	remainingLines?: unknown;
+};
+
+function formatExaItemLabel(item: ExaLikeItem): string {
+	const title = typeof item.title === "string" ? item.title : "";
+	const url = typeof item.url === "string" ? item.url : "";
+	return title || url || "(untitled)";
+}
+
+function extractToolDataContainer(result: UnknownRecord): unknown {
+	if ("data" in result) return result.data;
+	return result;
+}
+
+function formatFetchUrlsResult(result: unknown): string[] | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return [`error: ${result.error}`];
+	}
+	if (result.success !== true) return null;
+
+	if (Array.isArray(result.highlights)) {
+		return formatHighlightsResult(result);
+	}
+
+	const data = extractToolDataContainer(result);
+	const candidate = isRecord(data) ? (data as ExaLikeItem) : {};
+	const label = formatExaItemLabel(candidate);
+	const url = typeof candidate.url === "string" ? candidate.url : "";
+	const title = typeof candidate.title === "string" ? candidate.title : "";
+	const lineOffset = typeof candidate.lineOffset === "number" ? candidate.lineOffset : undefined;
+	const lineLimit = typeof candidate.lineLimit === "number" ? candidate.lineLimit : undefined;
+	const remainingLines =
+		typeof candidate.remainingLines === "number" || candidate.remainingLines === null
+			? candidate.remainingLines
+			: undefined;
+	const rangeParts: string[] = [];
+	if (lineOffset !== undefined) rangeParts.push(`lineOffset=${lineOffset}`);
+	if (lineLimit !== undefined) rangeParts.push(`lineLimit=${lineLimit}`);
+	if (remainingLines !== undefined) {
+		rangeParts.push(remainingLines === null ? "remainingLines=unknown" : `remainingLines=${remainingLines}`);
+	}
+	const remainingSuffix = rangeParts.length > 0 ? ` (${rangeParts.join(", ")})` : "";
+
+	const headerBase = url && title ? `${label} — ${url}` : label;
+	const header = `${headerBase}${remainingSuffix}`;
+
+	const text = typeof candidate.text === "string" ? candidate.text : "";
+	if (!text.trim()) return [header];
+
+	const MAX_LINES = 4;
+	const MAX_CHARS = 160;
+	const snippet = normalizeWhitespace(text)
+		.replace(/\n{3,}/g, "\n\n")
+		.trim()
+		.split("\n")
+		.slice(0, MAX_LINES)
+		.map((l) => (l.length > MAX_CHARS ? `${l.slice(0, MAX_CHARS - 1)}…` : l));
+
+	return [header, ...snippet];
+}
+
+function formatHighlightsResult(result: UnknownRecord): string[] {
+	const highlights = result.highlights as unknown[];
+	const highlightQuery = typeof result.highlightQuery === "string" ? result.highlightQuery : "";
+	const count = highlights.length;
+
+	const lines: string[] = [`${count} highlight${count !== 1 ? "s" : ""} for "${highlightQuery}"`];
+
+	const MAX_HIGHLIGHTS = 3;
+	const MAX_CHARS = 120;
+
+	highlights.slice(0, MAX_HIGHLIGHTS).forEach((h, idx) => {
+		if (typeof h === "string") {
+			const clean = h.replace(/\n+/g, " ").trim();
+			const truncated = clean.length > MAX_CHARS ? `${clean.slice(0, MAX_CHARS - 1)}…` : clean;
+			lines.push(`  ${idx + 1}. "${truncated}"`);
+		}
+	});
+
+	if (highlights.length > MAX_HIGHLIGHTS) {
+		lines.push(`  ...and ${highlights.length - MAX_HIGHLIGHTS} more`);
+	}
+
+	return lines;
+}
+
+function formatRenderUrlResult(result: unknown): string[] | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return [`error: ${result.error}`];
+	}
+	if (result.success !== true) return null;
+
+	const url = typeof result.url === "string" ? result.url : "(unknown url)";
+	const lineOffset = typeof result.lineOffset === "number" ? result.lineOffset : undefined;
+	const lineLimit = typeof result.lineLimit === "number" ? result.lineLimit : undefined;
+	const remainingLines = typeof result.remainingLines === "number" ? result.remainingLines : null;
+	const rangeParts: string[] = [];
+	if (lineOffset !== undefined) rangeParts.push(`lineOffset=${lineOffset}`);
+	if (lineLimit !== undefined) rangeParts.push(`lineLimit=${lineLimit}`);
+	rangeParts.push(remainingLines === null ? "remainingLines=unknown" : `remainingLines=${remainingLines}`);
+	const remainingSuffix = rangeParts.length > 0 ? ` (${rangeParts.join(", ")})` : "";
+
+	const header = `${url}${remainingSuffix}`;
+
+	const text = typeof result.text === "string" ? result.text : "";
+	if (!text.trim()) return [header];
+
+	const MAX_LINES = 4;
+	const MAX_CHARS = 160;
+	const snippet = normalizeWhitespace(text)
+		.replace(/\n{3,}/g, "\n\n")
+		.trim()
+		.split("\n")
+		.slice(0, MAX_LINES)
+		.map((l) => (l.length > MAX_CHARS ? `${l.slice(0, MAX_CHARS - 1)}…` : l));
+
+	return [header, ...snippet];
+}
+
+export const fetchUrlsLayout: ToolLayoutConfig = {
+	abbreviation: "fetch",
+
+	getHeader: (input, result): ToolHeader | null => {
+		const urlInput = mergeFetchUrlsDefaults(extractFetchUrlsInput(input), result);
+		if (!urlInput) return null;
+		const headerSuffix = formatFetchUrlsHeader(urlInput);
+		return {
+			primary: urlInput.url,
+			secondary: headerSuffix || undefined,
+		};
+	},
+
+	formatResult: formatFetchUrlsResult,
+};
+
+export const renderUrlLayout: ToolLayoutConfig = {
+	abbreviation: "render",
+
+	getHeader: (input, result): ToolHeader | null => {
+		const urlInput = mergeFetchUrlsDefaults(extractFetchUrlsInput(input), result);
+		if (!urlInput) return null;
+		const headerSuffix = formatFetchUrlsHeader(urlInput);
+		return {
+			primary: urlInput.url,
+			secondary: headerSuffix || undefined,
+		};
+	},
+
+	formatResult: formatRenderUrlResult,
+};
+
+registerToolLayout("fetchUrls", fetchUrlsLayout);
+registerToolLayout("renderUrl", renderUrlLayout);

package/src/components/tool-layouts/layouts/web-search.ts

@@ -0,0 +1,110 @@
+import type { ToolLayoutConfig, ToolHeader } from "../types";
+import { registerToolLayout } from "../registry";
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+interface SearchInput {
+	query: string;
+	recency?: string;
+	includeDomains?: string[];
+}
+
+function extractSearchInput(input: unknown): SearchInput | null {
+	if (!isRecord(input)) return null;
+	if (!("query" in input) || typeof input.query !== "string") return null;
+
+	const recency = "recency" in input && typeof input.recency === "string" ? input.recency : undefined;
+	const includeDomains =
+		"includeDomains" in input && Array.isArray(input.includeDomains)
+			? (input.includeDomains.filter((d) => typeof d === "string") as string[])
+			: undefined;
+
+	return { query: input.query, recency, includeDomains };
+}
+
+type ExaLikeItem = {
+	title?: unknown;
+	url?: unknown;
+	text?: unknown;
+};
+
+function extractExaItems(data: unknown): ExaLikeItem[] | null {
+	if (!isRecord(data)) return null;
+	const direct = data.results;
+	if (Array.isArray(direct)) return direct as ExaLikeItem[];
+	const contents = data.contents;
+	if (Array.isArray(contents)) return contents as ExaLikeItem[];
+	return null;
+}
+
+function extractToolDataContainer(result: UnknownRecord): unknown {
+	if ("data" in result) return result.data;
+	return result;
+}
+
+function formatExaItemLabel(item: ExaLikeItem): string {
+	const title = typeof item.title === "string" ? item.title : "";
+	const url = typeof item.url === "string" ? item.url : "";
+	return title || url || "(untitled)";
+}
+
+function formatWebSearchResult(result: unknown): string[] | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return [`error: ${result.error}`];
+	}
+	if (result.success !== true) return null;
+	const data = extractToolDataContainer(result);
+	const items = extractExaItems(data);
+	if (!items) return null;
+
+	const top = items.slice(0, 4).map((item, idx) => {
+		const url = typeof item.url === "string" ? item.url : "";
+		const title = typeof item.title === "string" ? item.title : "";
+		const label = formatExaItemLabel(item);
+		const urlSuffix = url && title ? ` — ${url}` : "";
+		return `${idx + 1}) ${label}${urlSuffix}`;
+	});
+
+	return top.length > 0 ? top : null;
+}
+
+function formatSearchParams(input: SearchInput): string | undefined {
+	const parts: string[] = [];
+	if (input.recency) {
+		parts.push(`recency: ${input.recency}`);
+	}
+	if (input.includeDomains && input.includeDomains.length > 0) {
+		const domains = input.includeDomains.slice(0, 2).join(", ");
+		const suffix = input.includeDomains.length > 2 ? ` +${input.includeDomains.length - 2}` : "";
+		parts.push(`domains: ${domains}${suffix}`);
+	}
+	return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+
+const MAX_INLINE_CHARS = 60;
+
+export const webSearchLayout: ToolLayoutConfig = {
+	abbreviation: "search",
+
+	getHeader: (input): ToolHeader | null => {
+		const searchInput = extractSearchInput(input);
+		if (!searchInput) return null;
+		const truncated =
+			searchInput.query.length > MAX_INLINE_CHARS
+				? `${searchInput.query.slice(0, MAX_INLINE_CHARS - 1)}…`
+				: searchInput.query;
+		return {
+			primary: `"${truncated}"`,
+			secondary: formatSearchParams(searchInput),
+		};
+	},
+
+	formatResult: formatWebSearchResult,
+};
+
+registerToolLayout("webSearch", webSearchLayout);

package/src/components/tool-layouts/registry.ts

@@ -0,0 +1,17 @@
+import type { ToolLayoutConfig, ToolLayoutRegistry } from "./types";
+
+const registry: ToolLayoutRegistry = new Map();
+
+export function registerToolLayout(toolName: string, config: ToolLayoutConfig): void {
+	registry.set(toolName, config);
+}
+
+export function getToolLayout(toolName: string): ToolLayoutConfig | undefined {
+	return registry.get(toolName);
+}
+
+export function hasToolLayout(toolName: string): boolean {
+	return registry.has(toolName);
+}
+
+export { registry };