@makefinks/daemon 0.1.4 → 0.3.0

package/src/types/index.ts

@@ -42,6 +42,10 @@ export interface TokenUsage {
 	subagentTotalTokens?: number;
 	subagentPromptTokens?: number;
 	subagentCompletionTokens?: number;
+	/** Latest turn's prompt tokens (for context window % calculation) */
+	latestTurnPromptTokens?: number;
+	/** Latest turn's completion tokens (for context window % calculation) */
+	latestTurnCompletionTokens?: number;
 }
 
 /**
@@ -255,6 +259,29 @@ export type OnboardingStep =
 
 export type VoiceInteractionType = "direct" | "review";
 
+export type ToolToggleId =
+	| "readFile"
+	| "runBash"
+	| "webSearch"
+	| "fetchUrls"
+	| "renderUrl"
+	| "todoManager"
+	| "groundingManager"
+	| "subagent";
+
+export type ToolToggles = Record<ToolToggleId, boolean>;
+
+export const DEFAULT_TOOL_TOGGLES: ToolToggles = {
+	readFile: true,
+	runBash: true,
+	webSearch: true,
+	fetchUrls: true,
+	renderUrl: true,
+	todoManager: true,
+	groundingManager: true,
+	subagent: true,
+};
+
 /**
  * Persisted user preferences.
  */
@@ -287,6 +314,8 @@ export interface AppPreferences {
 	showToolOutput?: boolean;
 	/** Bash command approval level */
 	bashApprovalLevel?: BashApprovalLevel;
+	/** Tool toggles (on/off) */
+	toolToggles?: ToolToggles;
 	/** Recent user inputs for up/down history navigation (max 20) */
 	inputHistory?: string[];
 }
@@ -403,3 +432,13 @@ export interface GroundingMap {
 	createdAt: string;
 	items: GroundedStatement[];
 }
+
+export interface UrlMenuItem {
+	url: string;
+	groundedCount: number;
+	readPercent?: number;
+	highlightsCount?: number;
+	status: "ok" | "error";
+	error?: string;
+	lastSeenIndex: number;
+}

package/src/utils/derive-url-menu-items.ts

@@ -0,0 +1,155 @@
+import type { ContentBlock, ConversationMessage, GroundingMap, UrlMenuItem } from "../types";
+
+function normalizeUrlKey(rawUrl: string): string {
+	try {
+		const parsed = new URL(rawUrl);
+		parsed.hash = "";
+		return parsed.toString();
+	} catch {
+		return rawUrl;
+	}
+}
+
+function computeCoveragePercent(intervals: Array<[number, number]>, totalLines: number): number | undefined {
+	if (!Number.isFinite(totalLines) || totalLines <= 0) return undefined;
+	if (intervals.length === 0) return undefined;
+
+	const sorted = [...intervals].sort((a, b) => a[0] - b[0]);
+	let covered = 0;
+	let curStart = sorted[0]?.[0] ?? 0;
+	let curEnd = sorted[0]?.[1] ?? 0;
+
+	for (const [start, end] of sorted.slice(1)) {
+		if (start <= curEnd) {
+			curEnd = Math.max(curEnd, end);
+			continue;
+		}
+		covered += Math.max(0, curEnd - curStart);
+		curStart = start;
+		curEnd = end;
+	}
+	covered += Math.max(0, curEnd - curStart);
+
+	const percent = Math.round((covered / totalLines) * 100);
+	return Math.max(0, Math.min(100, percent));
+}
+
+export function deriveUrlMenuItems(params: {
+	conversationHistory: ConversationMessage[];
+	currentContentBlocks: ContentBlock[];
+	latestGroundingMap: GroundingMap | null;
+}): UrlMenuItem[] {
+	const { conversationHistory, currentContentBlocks, latestGroundingMap } = params;
+
+	const intervalsByUrl = new Map<string, Array<[number, number]>>();
+	const totalLinesByUrl = new Map<string, number>();
+	const highlightsCountByUrl = new Map<string, number>();
+	const lastSeenIndexByUrl = new Map<string, number>();
+	const statusByUrl = new Map<string, "ok" | "error">();
+	const errorByUrl = new Map<string, string>();
+
+	const allBlocks = [
+		...conversationHistory.flatMap((msg) => msg.contentBlocks ?? []),
+		...currentContentBlocks,
+	];
+
+	for (const [blockIndex, block] of allBlocks.entries()) {
+		if (block.type !== "tool") continue;
+		if (block.call.name !== "fetchUrls" && block.call.name !== "renderUrl") continue;
+
+		const input = block.call.input as { url?: string } | undefined;
+		const url = input?.url;
+		if (!url) continue;
+
+		lastSeenIndexByUrl.set(url, blockIndex);
+
+		const result = block.result as
+			| {
+					lineOffset?: number;
+					lineLimit?: number;
+					totalLines?: number;
+					highlights?: unknown[];
+					success?: boolean;
+					error?: string;
+			  }
+			| undefined;
+
+		if (!result || typeof result !== "object") continue;
+
+		if (result.success === false && typeof result.error === "string" && result.error.trim().length > 0) {
+			statusByUrl.set(url, "error");
+			errorByUrl.set(url, result.error.trim());
+		} else if (result.success === true) {
+			statusByUrl.set(url, "ok");
+		}
+
+		if (Array.isArray(result.highlights)) {
+			highlightsCountByUrl.set(url, result.highlights.length);
+		}
+
+		if (
+			typeof result.totalLines === "number" &&
+			Number.isFinite(result.totalLines) &&
+			result.totalLines > 0
+		) {
+			const prev = totalLinesByUrl.get(url) ?? 0;
+			totalLinesByUrl.set(url, Math.max(prev, result.totalLines));
+		}
+
+		if (
+			typeof result.lineOffset === "number" &&
+			typeof result.lineLimit === "number" &&
+			Number.isFinite(result.lineOffset) &&
+			Number.isFinite(result.lineLimit) &&
+			result.lineLimit > 0 &&
+			result.lineOffset >= 0
+		) {
+			const start = result.lineOffset;
+			const end = result.lineOffset + result.lineLimit;
+			const list = intervalsByUrl.get(url) ?? [];
+			list.push([start, end]);
+			intervalsByUrl.set(url, list);
+		}
+	}
+
+	const groundedCountByUrl = new Map<string, number>();
+	for (const groundedItem of latestGroundingMap?.items ?? []) {
+		const groundedUrl = groundedItem.source?.url;
+		if (!groundedUrl) continue;
+		const next = (groundedCountByUrl.get(groundedUrl) ?? 0) + 1;
+		groundedCountByUrl.set(groundedUrl, next);
+	}
+
+	function lookupGroundedCount(url: string): number {
+		const direct = groundedCountByUrl.get(url);
+		if (direct !== undefined) return direct;
+
+		const key = normalizeUrlKey(url);
+		for (const [gUrl, count] of groundedCountByUrl.entries()) {
+			if (normalizeUrlKey(gUrl) === key) return count;
+		}
+		return 0;
+	}
+
+	const urls = [...lastSeenIndexByUrl.keys()];
+	return urls.map((url) => {
+		const groundedCount = lookupGroundedCount(url);
+		const highlightsCount = highlightsCountByUrl.get(url);
+		const totalLines = totalLinesByUrl.get(url);
+		const intervals = intervalsByUrl.get(url) ?? [];
+		const readPercent = totalLines !== undefined ? computeCoveragePercent(intervals, totalLines) : undefined;
+		const error = errorByUrl.get(url);
+		const status = statusByUrl.get(url) ?? (error ? "error" : "ok");
+		const lastSeenIndex = lastSeenIndexByUrl.get(url) ?? 0;
+
+		return {
+			url,
+			groundedCount,
+			readPercent,
+			highlightsCount,
+			status,
+			error,
+			lastSeenIndex,
+		};
+	});
+}

package/src/utils/formatters.ts

@@ -209,14 +209,8 @@ export function isTodoInput(input: unknown): input is TodoInput {
 	);
 }
 
-/**
- * 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);
+	return count.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
 }
 
 export function formatContextWindowK(contextLength: number): string {

package/src/utils/preferences.ts

@@ -109,6 +109,16 @@ export function parsePreferences(raw: unknown): AppPreferences | null {
 	if (typeof raw.showToolOutput === "boolean") {
 		prefs.showToolOutput = raw.showToolOutput;
 	}
+	if (isRecord(raw.toolToggles)) {
+		const record = raw.toolToggles;
+		const next: Record<string, boolean> = {};
+		for (const [k, v] of Object.entries(record)) {
+			if (typeof v === "boolean") {
+				next[k] = v;
+			}
+		}
+		prefs.toolToggles = next as AppPreferences["toolToggles"];
+	}
 	if (
 		raw.bashApprovalLevel === "none" ||
 		raw.bashApprovalLevel === "dangerous" ||