@asterxsk/kiln 0.1.0 → 0.3.0

package/agent.bak.20260905-190020/extensions/pi-web-access/render-search-error.ts

@@ -0,0 +1,170 @@
+/**
+ * Pure, dependency-free renderer for web_search error / cancel results.
+ *
+ * WHY THIS EXISTS: the upstream web_search `renderResult` (index.ts) early-returns
+ * a SINGLE line on the error/cancel path, before the collapsed/expanded branch.
+ * That makes Ctrl+O (app.tools.expand) flip `expanded` with zero visible effect —
+ * a dead-end with no diagnostics. It also discards the partial search results
+ * gathered before the cancel, so even an expandable view would have nothing to show.
+ *
+ * This module is the single source of truth for the error/cancel render PLAN
+ * (plain strings, no theme/ANSI), so it is unit-testable without pi's runtime
+ * (@mariozechner/pi-tui Text/Box). index.ts.renderResult delegates to it and only
+ * applies theme colors + creates Text/Box components.
+ *
+ * Contract for callers:
+ *   const plan = buildSearchErrorPlan(details);
+ *   if (plan === null) ... // not an error/cancel result; use the normal renderer
+ *   // collapsed: [statusLine, ...plan.collapsed, plan.expandHint].filter(Boolean)
+ *   // expanded:  plan.expanded
+ */
+
+export interface CancelledQueryDetail {
+	query: string;
+	provider: string | null;
+	error: string | null; // null = completed ok; string = per-query error
+	resultCount: number;
+}
+
+export interface SearchErrorDetails {
+	/** The headline error/cancel message, e.g. "Search cancelled (stale)." */
+	error?: string;
+	cancelled?: boolean;
+	cancelReason?: string;
+	/** Did the search ever establish a connection / make progress? */
+	browserConnected?: boolean;
+	/** Age (ms) of the last progress heartbeat at cancel time, if known. */
+	lastHeartbeatAgeMs?: number | null;
+	/** Total queries the user requested. */
+	queryCount?: number;
+	/** Partial per-query results gathered before the cancel/error. */
+	cancelledQueries?: CancelledQueryDetail[];
+	/** Arbitrary extra diagnostic lines (e.g. URLs, response id) for non-cancel errors
+	 * like fetch_content / get_search_content. Shown in the expanded view. */
+	extraLines?: string[];
+}
+
+export interface SearchErrorPlan {
+	/** Full diagnostic block, shown when expanded (Ctrl+O). */
+	expanded: string[];
+	/** Short preview lines, shown under the headline when collapsed. */
+	collapsed: string[];
+	/** The "... (N more lines, ctrl+o to expand)" hint, or null if nothing is hidden. */
+	expandHint: string | null;
+}
+
+function truncate(text: string, max: number): string {
+	return text.length > max ? text.slice(0, max - 1) + "\u2026" : text;
+}
+
+/**
+ * Build the error/cancel render plan. Returns null when `details` carries no
+ * error/cancel signal (so the caller falls through to the normal success renderer).
+ */
+export function buildSearchErrorPlan(details: SearchErrorDetails | undefined | null): SearchErrorPlan | null {
+	if (!details || (!details.error && !details.cancelled)) {
+		return null;
+	}
+
+	const headline = details.error ?? "Search cancelled.";
+	const queries = details.cancelledQueries ?? [];
+	const queryCount = typeof details.queryCount === "number" && details.queryCount > 0
+		? details.queryCount
+		: queries.length;
+	const done = queries.length;
+	const errored = queries.filter(q => q.error).length;
+
+	// Rich diagnostics only make sense when there is something to diagnose: a
+	// cancelled result with partial data, OR a non-cancel error that carries
+	// extra detail (urls/response-id for fetch_content, the failed query for
+	// get_search_content). A bare argument error (e.g. "No URL
+	// provided") stays a clean single line -- no noise.
+	const extras = details.extraLines ?? [];
+	const rich = details.cancelled === true || queries.length > 0 || extras.length > 0;
+	if (!rich) {
+		return { expanded: [headline], collapsed: [], expandHint: null };
+	}
+
+	// --- diagnostics block (expanded): cancel-specific only. For non-cancel
+	// errors (fetch_content/get_search_content) there is no browser or
+	// query state to report beyond the queries themselves, so we skip this block and show only Details. ---
+	const expanded: string[] = [headline, ""];
+
+	if (details.cancelled === true || queries.length > 0) {
+		const diag: string[] = [];
+		if (details.cancelled) {
+			diag.push(`cancel reason   : ${details.cancelReason ?? "unknown"}`);
+		}
+		// Browser connection state — the most common stale cause (page never opened).
+		const browserLabel = details.browserConnected === undefined
+			? "unknown"
+			: details.browserConnected
+				? "connected"
+				: "never connected";
+		diag.push(`browser         : ${browserLabel}`);
+		if (typeof details.lastHeartbeatAgeMs === "number" && Number.isFinite(details.lastHeartbeatAgeMs)) {
+			diag.push(`last heartbeat  : ${Math.round(details.lastHeartbeatAgeMs / 1000)}s ago`);
+		}
+		if (queryCount > 0) {
+			diag.push(`queries started : ${queryCount}`);
+			diag.push(`queries done    : ${done}`);
+			if (errored > 0) diag.push(`queries errored : ${errored}`);
+		}
+		expanded.push("Diagnostics:");
+		for (const line of diag) expanded.push(`  ${line}`);
+	}
+
+	// --- per-query results gathered before cancel ---
+	if (queries.length > 0) {
+		expanded.push("");
+		expanded.push("Per-query results (gathered before cancel):");
+		for (const q of queries) {
+			const dq = truncate(q.query, 52);
+			const tag = q.error ? "[err] " : "[ok]  ";
+			const provider = q.provider ? ` (${q.provider})` : "";
+			const tail = q.error
+				? `\u2014 ${truncate(q.error, 60)}`
+				: `\u2014 ${q.resultCount} source${q.resultCount === 1 ? "" : "s"}`;
+			expanded.push(`  ${tag}"${dq}"${provider} ${tail}`);
+		}
+	}
+
+	// --- arbitrary extra detail (non-cancel errors) ---
+	if (extras.length > 0) {
+		expanded.push("");
+		expanded.push("Details:");
+		for (const e of extras) expanded.push(`  ${e}`);
+	}
+
+	// --- collapsed preview ---
+	const collapsed: string[] = [];
+	const parts: string[] = [];
+	if (queryCount > 0) {
+		parts.push(`${done}/${queryCount} queries completed`);
+	}
+	if (errored > 0) {
+		parts.push(`${errored} errored`);
+	}
+	if (details.browserConnected === false) {
+		parts.push("browser never connected");
+	} else if (details.cancelReason) {
+		parts.push(`reason: ${details.cancelReason}`);
+	}
+	if (parts.length > 0) {
+		collapsed.push(parts.join("; ") + ".");
+	}
+	// For non-cancel errors with extra detail, preview the first detail line.
+	if (collapsed.length === 0 && extras.length > 0) {
+		for (const e of extras.slice(0, 2)) {
+			collapsed.push(truncate(e, 100));
+		}
+	}
+
+	// --- expand hint ---
+	const hiddenLines = Math.max(0, expanded.length - (1 + collapsed.length)); // headline + preview shown when collapsed
+	const expandHint = hiddenLines > 0
+		? `... (${hiddenLines} more lines, ${expanded.length} total, ctrl+o to expand)`
+		: null;
+
+	return { expanded, collapsed, expandHint };
+}

package/agent.bak.20260905-190020/extensions/pi-web-access/rsc-extract.ts

@@ -0,0 +1,338 @@
+/**
+ * RSC Content Extractor
+ * 
+ * Extracts readable content from Next.js React Server Components (RSC) flight payloads.
+ * RSC pages embed content as JSON in <script>self.__next_f.push([...])</script> tags.
+ */
+
+export interface RSCExtractResult {
+  title: string;
+  content: string;
+}
+
+export function extractRSCContent(html: string): RSCExtractResult | null {
+  if (!html.includes("self.__next_f.push")) {
+    return null;
+  }
+
+  // Parse all RSC chunks into a map
+  const chunkMap = new Map<string, string>();
+  const scriptRegex = /<script>self\.__next_f\.push\(\[1,"([\s\S]*?)"\]\)<\/script>/g;
+
+  for (const match of html.matchAll(scriptRegex)) {
+    let content: string;
+    try {
+      content = JSON.parse('"' + match[1] + '"');
+    } catch {
+      continue;
+    }
+
+    // Parse each line as "id:payload"
+    // Lines are separated by \n, each line is one chunk
+    // Chunk IDs are hex strings, typically 1-4 chars (supports up to 65535 chunks)
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      
+      const colonIdx = line.indexOf(":");
+      if (colonIdx <= 0 || colonIdx > 4) continue;
+      
+      const id = line.slice(0, colonIdx);
+      if (!/^[0-9a-f]+$/i.test(id)) continue;
+      
+      const payload = line.slice(colonIdx + 1);
+      if (!payload) continue;
+      
+      const existing = chunkMap.get(id);
+      if (!existing || payload.length > existing.length) {
+        chunkMap.set(id, payload);
+      }
+    }
+  }
+
+  if (chunkMap.size === 0) return null;
+
+  // Extract title
+  const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/);
+  const title = titleMatch?.[1]?.split("|")[0]?.trim() || "";
+
+  // Parse and cache parsed chunks
+  const parsedCache = new Map<string, unknown>();
+  
+  function getParsedChunk(id: string): unknown | null {
+    if (parsedCache.has(id)) return parsedCache.get(id);
+    
+    const chunk = chunkMap.get(id);
+    if (!chunk || !chunk.startsWith("[")) {
+      parsedCache.set(id, null);
+      return null;
+    }
+    
+    try {
+      const parsed = JSON.parse(chunk);
+      parsedCache.set(id, parsed);
+      return parsed;
+    } catch {
+      parsedCache.set(id, null);
+      return null;
+    }
+  }
+
+  // Extract markdown from nodes, resolving refs on the fly
+  type Node = unknown;
+  const visitedRefs = new Set<string>();
+
+  function extractNode(node: Node, ctx = { inTable: false, inCode: false }): string {
+    if (node === null || node === undefined) return "";
+    
+    if (typeof node === "string") {
+      // Check if it's a reference like "$L30"
+      const refMatch = node.match(/^\$L([0-9a-f]+)$/i);
+      if (refMatch) {
+        const refId = refMatch[1];
+        if (visitedRefs.has(refId)) return ""; // Prevent cycles
+        visitedRefs.add(refId);
+        const refNode = getParsedChunk(refId);
+        const result = refNode ? extractNode(refNode, ctx) : "";
+        visitedRefs.delete(refId);
+        return result;
+      }
+      // Filter out RSC-specific artifacts, but preserve content inside code blocks
+      if (!ctx.inCode && (node === "$undefined" || node === "$" || /^\$[A-Z]/.test(node))) return "";
+      return node.trim() ? node : "";
+    }
+    
+    if (typeof node === "number") return String(node);
+    if (typeof node === "boolean") return "";
+    if (!Array.isArray(node)) return "";
+
+    // RSC element: ["$", "tag", key, props]
+    if (node[0] === "$" && typeof node[1] === "string") {
+      const tag = node[1] as string;
+      const props = (node[3] || {}) as Record<string, unknown>;
+
+      // Skip non-content
+      const skipTags = ["script", "style", "svg", "path", "circle", "link", "meta", 
+                        "template", "button", "input", "nav", "footer", "aside"];
+      if (skipTags.includes(tag)) return "";
+
+      // Component ref like $L25
+      if (tag.startsWith("$L")) {
+        const refId = tag.slice(2);
+        if (visitedRefs.has(refId)) return "";
+        
+        // Check for heading components with baseId
+        if (props.baseId && props.children) {
+          return `## ${String(props.children)}\n\n`;
+        }
+        
+        visitedRefs.add(refId);
+        const refNode = getParsedChunk(refId);
+        let result = "";
+        if (refNode) {
+          result = extractNode(refNode, ctx);
+        } else if (props.children) {
+          result = extractNode(props.children as Node, ctx);
+        }
+        visitedRefs.delete(refId);
+        return result;
+      }
+
+      const children = props.children;
+      const content = children ? extractNode(children as Node, ctx) : "";
+
+      switch (tag) {
+        case "h1": return `# ${content.trim()}\n\n`;
+        case "h2": return `## ${content.trim()}\n\n`;
+        case "h3": return `### ${content.trim()}\n\n`;
+        case "h4": return `#### ${content.trim()}\n\n`;
+        case "h5": return `##### ${content.trim()}\n\n`;
+        case "h6": return `###### ${content.trim()}\n\n`;
+        case "p": return ctx.inTable ? content : `${content.trim()}\n\n`;
+        case "code": {
+          const codeContent = children ? extractNode(children as Node, { ...ctx, inCode: true }) : "";
+          return ctx.inCode ? codeContent : `\`${codeContent}\``;
+        }
+        case "pre": {
+          const preContent = children ? extractNode(children as Node, { ...ctx, inCode: true }) : "";
+          return "```\n" + preContent + "\n```\n\n";
+        }
+        case "strong": case "b": return `**${content}**`;
+        case "em": case "i": return `*${content}*`;
+        case "li": return `- ${content.trim()}\n`;
+        case "ul": case "ol": return content + "\n";
+        case "blockquote": return `> ${content.trim()}\n\n`;
+        case "table": return extractTable(node as unknown[]) + "\n";
+        case "thead": case "tbody": case "tr": case "th": case "td":
+          return content;
+        case "div":
+          if (props.role === "alert" || props["data-slot"] === "alert") {
+            return `> ${content.trim()}\n\n`;
+          }
+          return content;
+        case "a": {
+          const href = props.href as string | undefined;
+          return href && !href.startsWith("#") ? `[${content}](${href})` : content;
+        }
+        default: return content;
+      }
+    }
+
+    // Array of child nodes
+    return (node as Node[]).map(n => extractNode(n, ctx)).join("");
+  }
+
+  function extractTable(tableNode: unknown[]): string {
+    const props = (tableNode[3] || {}) as Record<string, unknown>;
+    const rows: string[][] = [];
+    let headerRowCount = 0;
+
+    function walkTable(node: unknown, isHeader = false): void {
+      if (node === null || node === undefined) return;
+      
+      // Handle string refs
+      if (typeof node === "string") {
+        const refMatch = node.match(/^\$L([0-9a-f]+)$/i);
+        if (refMatch && !visitedRefs.has(refMatch[1])) {
+          visitedRefs.add(refMatch[1]);
+          const refNode = getParsedChunk(refMatch[1]);
+          if (refNode) walkTable(refNode, isHeader);
+          visitedRefs.delete(refMatch[1]);
+        }
+        return;
+      }
+      
+      if (!Array.isArray(node)) return;
+      
+      if (node[0] === "$") {
+        const tag = node[1] as string;
+        const nodeProps = (node[3] || {}) as Record<string, unknown>;
+        
+        // Handle component refs
+        if (tag.startsWith("$L")) {
+          const refId = tag.slice(2);
+          if (!visitedRefs.has(refId)) {
+            visitedRefs.add(refId);
+            const refNode = getParsedChunk(refId);
+            if (refNode) walkTable(refNode, isHeader);
+            visitedRefs.delete(refId);
+          }
+          return;
+        }
+        
+        if (tag === "thead") walkTable(nodeProps.children, true);
+        else if (tag === "tbody") walkTable(nodeProps.children, false);
+        else if (tag === "tr") {
+          const cells: string[] = [];
+          walkCells(nodeProps.children, cells);
+          if (cells.length > 0) {
+            rows.push(cells);
+            if (isHeader) headerRowCount++;
+          }
+        } else walkTable(nodeProps.children, isHeader);
+      } else {
+        for (const child of node) walkTable(child, isHeader);
+      }
+    }
+
+    function walkCells(node: unknown, cells: string[]): void {
+      if (node === null || node === undefined) return;
+      
+      // Handle string refs
+      if (typeof node === "string") {
+        const refMatch = node.match(/^\$L([0-9a-f]+)$/i);
+        if (refMatch && !visitedRefs.has(refMatch[1])) {
+          visitedRefs.add(refMatch[1]);
+          const refNode = getParsedChunk(refMatch[1]);
+          if (refNode) walkCells(refNode, cells);
+          visitedRefs.delete(refMatch[1]);
+        }
+        return;
+      }
+      
+      if (!Array.isArray(node)) return;
+      
+      if (node[0] === "$" && (node[1] === "td" || node[1] === "th")) {
+        const cellProps = (node[3] || {}) as Record<string, unknown>;
+        const text = extractNode(cellProps.children, { inTable: true, inCode: false })
+          .trim()
+          .replace(/\n/g, " ")
+          .replace(/\\/g, "\\\\")  // Escape backslashes first
+          .replace(/\|/g, "\\|");  // Then escape pipes
+        cells.push(text);
+      } else if (node[0] === "$" && typeof node[1] === "string" && (node[1] as string).startsWith("$L")) {
+        // Component ref for a cell
+        const refId = (node[1] as string).slice(2);
+        if (!visitedRefs.has(refId)) {
+          visitedRefs.add(refId);
+          const refNode = getParsedChunk(refId);
+          if (refNode) walkCells(refNode, cells);
+          visitedRefs.delete(refId);
+        }
+      } else {
+        for (const child of node) walkCells(child, cells);
+      }
+    }
+
+    walkTable(props.children);
+    if (rows.length === 0) return "";
+
+    const colCount = Math.max(...rows.map(r => r.length));
+    let md = "";
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i].concat(Array(colCount - rows[i].length).fill(""));
+      md += "| " + row.join(" | ") + " |\n";
+      if (i === headerRowCount - 1 || (headerRowCount === 0 && i === 0)) {
+        md += "| " + Array(colCount).fill("---").join(" | ") + " |\n";
+      }
+    }
+    return md;
+  }
+
+  // Process main content chunk (usually "23")
+  const mainChunk = getParsedChunk("23");
+  
+  if (mainChunk) {
+    const content = extractNode(mainChunk);
+    if (content.trim().length > 100) {
+      const cleaned = content
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+      return { title, content: cleaned };
+    }
+  }
+
+  // Fallback: try other chunks
+  const contentParts: { order: number; text: string }[] = [];
+
+  for (const [id] of chunkMap) {
+    if (id === "23") continue;
+    const parsed = getParsedChunk(id);
+    if (!parsed) continue;
+
+    visitedRefs.clear();
+    const text = extractNode(parsed);
+
+    if (text.trim().length > 50 && 
+        !text.includes("page was not found") && 
+        !text.includes("404")) {
+      contentParts.push({ order: parseInt(id, 16), text: text.trim() });
+    }
+  }
+
+  if (contentParts.length === 0) return null;
+
+  contentParts.sort((a, b) => a.order - b.order);
+  
+  const seen = new Set<string>();
+  const uniqueParts: string[] = [];
+  for (const part of contentParts) {
+    const key = part.text.slice(0, 150);
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueParts.push(part.text);
+    }
+  }
+
+  const content = uniqueParts.join("\n\n").replace(/\n{3,}/g, "\n\n").trim();
+  return content.length > 100 ? { title, content } : null;
+}

package/agent.bak.20260905-190020/extensions/pi-web-access/search-types.ts

@@ -0,0 +1,20 @@
+import type { ExtractedContent } from "./extract.ts";
+
+export interface SearchResult {
+	title: string;
+	url: string;
+	snippet: string;
+}
+
+export interface SearchResponse {
+	answer: string;
+	results: SearchResult[];
+	inlineContent?: ExtractedContent[];
+}
+
+export interface SearchOptions {
+	numResults?: number;
+	recencyFilter?: "day" | "week" | "month" | "year";
+	domainFilter?: string[];
+	signal?: AbortSignal;
+}