@ridit/lens 0.1.9 → 0.2.1

package/src/tools/files.ts

@@ -0,0 +1,261 @@
+import path from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "fs";
+import type { FilePatch } from "../components/repo/DiffViewer";
+
+// ── Walk ──────────────────────────────────────────────────────────────────────
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+]);
+
+export function walkDir(
+  dir: string,
+  base = dir,
+  results: string[] = [],
+): string[] {
+  let entries: string[];
+  try {
+    entries = readdirSync(dir, { encoding: "utf-8" });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (results.length >= 100) return results;
+    if (SKIP_DIRS.has(entry)) continue;
+    const full = path.join(dir, entry);
+    const rel = path.relative(base, full).replace(/\\/g, "/");
+    let isDir = false;
+    try {
+      isDir = statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir) walkDir(full, base, results);
+    else results.push(rel);
+  }
+  return results;
+}
+
+export function applyPatches(repoPath: string, patches: FilePatch[]): void {
+  for (const patch of patches) {
+    const fullPath = path.join(repoPath, patch.path);
+    const dir = path.dirname(fullPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(fullPath, patch.content, "utf-8");
+  }
+}
+
+// ── Read ──────────────────────────────────────────────────────────────────────
+
+export function readFile(filePath: string, repoPath: string): string {
+  const candidates = path.isAbsolute(filePath)
+    ? [filePath]
+    : [filePath, path.join(repoPath, filePath)];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      try {
+        const content = readFileSync(candidate, "utf-8");
+        const lines = content.split("\n").length;
+        return `File: ${candidate} (${lines} lines)\n\n${content.slice(0, 8000)}${
+          content.length > 8000 ? "\n\n… (truncated)" : ""
+        }`;
+      } catch (err) {
+        return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+      }
+    }
+  }
+  return `File not found: ${filePath}. If reading from a cloned repo, use the full absolute path e.g. C:\\Users\\...\\repo\\file.ts`;
+}
+
+export function readFolder(folderPath: string, repoPath: string): string {
+  const sanitized = folderPath
+    .replace(/^(ls|dir|find|tree|cat|read|ls -la?|ls -al?)\s+/i, "")
+    .trim();
+
+  const candidates = path.isAbsolute(sanitized)
+    ? [sanitized]
+    : [sanitized, path.join(repoPath, sanitized)];
+
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    let stat: ReturnType<typeof statSync>;
+    try {
+      stat = statSync(candidate);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) {
+      return `Not a directory: ${candidate}. Use read-file to read a file.`;
+    }
+
+    let entries: string[];
+    try {
+      entries = readdirSync(candidate, { encoding: "utf-8" });
+    } catch (err) {
+      return `Error reading folder: ${err instanceof Error ? err.message : String(err)}`;
+    }
+
+    const files: string[] = [];
+    const subfolders: string[] = [];
+
+    for (const entry of entries) {
+      if (entry.startsWith(".") && entry !== ".env") continue;
+      const full = path.join(candidate, entry);
+      try {
+        if (statSync(full).isDirectory()) subfolders.push(`${entry}/`);
+        else files.push(entry);
+      } catch {
+        // skip
+      }
+    }
+
+    const total = files.length + subfolders.length;
+    const lines: string[] = [`Folder: ${candidate} (${total} entries)`, ""];
+    if (files.length > 0) {
+      lines.push("Files:");
+      files.forEach((f) => lines.push(`  ${f}`));
+    }
+    if (subfolders.length > 0) {
+      if (files.length > 0) lines.push("");
+      lines.push("Subfolders:");
+      subfolders.forEach((d) => lines.push(`  ${d}`));
+    }
+    if (total === 0) lines.push("(empty folder)");
+    return lines.join("\n");
+  }
+
+  return `Folder not found: ${sanitized}`;
+}
+
+export function grepFiles(
+  pattern: string,
+  glob: string,
+  repoPath: string,
+): string {
+  let regex: RegExp;
+  try {
+    regex = new RegExp(pattern, "i");
+  } catch {
+    regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+  }
+
+  const globToFilter = (g: string): ((rel: string) => boolean) => {
+    const cleaned = g.replace(/^\*\*\//, "");
+    const parts = cleaned.split("/");
+    const ext = parts[parts.length - 1];
+    const prefix = parts.slice(0, -1).join("/");
+    return (rel: string) => {
+      if (ext?.startsWith("*.")) {
+        if (!rel.endsWith(ext.slice(1))) return false;
+      } else if (ext && !ext.includes("*")) {
+        if (!rel.endsWith(ext)) return false;
+      }
+      if (prefix && !prefix.includes("*")) {
+        if (!rel.startsWith(prefix)) return false;
+      }
+      return true;
+    };
+  };
+
+  const filter = globToFilter(glob);
+  const allFiles = walkDir(repoPath);
+  const matchedFiles = allFiles.filter(filter);
+  if (matchedFiles.length === 0) return `No files matched glob: ${glob}`;
+
+  const results: string[] = [];
+  let totalMatches = 0;
+
+  for (const relPath of matchedFiles) {
+    const fullPath = path.join(repoPath, relPath);
+    let content: string;
+    try {
+      content = readFileSync(fullPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const fileLines = content.split("\n");
+    const fileMatches: string[] = [];
+    fileLines.forEach((line, i) => {
+      if (regex.test(line)) {
+        fileMatches.push(`  ${i + 1}: ${line.trimEnd()}`);
+        totalMatches++;
+      }
+    });
+    if (fileMatches.length > 0)
+      results.push(`${relPath}\n${fileMatches.join("\n")}`);
+    if (totalMatches >= 200) {
+      results.push("(truncated — too many matches)");
+      break;
+    }
+  }
+
+  if (results.length === 0)
+    return `No matches for /${pattern}/ in ${matchedFiles.length} file(s) matching ${glob}`;
+
+  return `grep /${pattern}/ ${glob} — ${totalMatches} match(es) in ${results.length} file(s)\n\n${results.join("\n\n")}`;
+}
+
+// ── Write / Delete ────────────────────────────────────────────────────────────
+
+export function writeFile(
+  filePath: string,
+  content: string,
+  repoPath: string,
+): string {
+  const fullPath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(repoPath, filePath);
+  try {
+    const dir = path.dirname(fullPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(fullPath, content, "utf-8");
+    const lines = content.split("\n").length;
+    return `Written: ${fullPath} (${lines} lines, ${content.length} bytes)`;
+  } catch (err) {
+    return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+export function deleteFile(filePath: string, repoPath: string): string {
+  const fullPath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(repoPath, filePath);
+  try {
+    if (!existsSync(fullPath)) return `File not found: ${fullPath}`;
+    const { unlinkSync } = require("fs") as typeof import("fs");
+    unlinkSync(fullPath);
+    return `Deleted: ${fullPath}`;
+  } catch (err) {
+    return `Error deleting file: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+export function deleteFolder(folderPath: string, repoPath: string): string {
+  const fullPath = path.isAbsolute(folderPath)
+    ? folderPath
+    : path.join(repoPath, folderPath);
+  try {
+    if (!existsSync(fullPath)) return `Folder not found: ${fullPath}`;
+    const { rmSync } = require("fs") as typeof import("fs");
+    rmSync(fullPath, { recursive: true, force: true });
+    return `Deleted folder: ${fullPath}`;
+  } catch (err) {
+    return `Error deleting folder: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,13 @@
+export { runShell, readClipboard, openUrl } from "./shell";
+export {
+  walkDir,
+  applyPatches,
+  readFile,
+  readFolder,
+  grepFiles,
+  writeFile,
+  deleteFile,
+  deleteFolder,
+} from "./files";
+export { fetchUrl, searchWeb } from "./web";
+export { generatePdf } from "./pdf";

package/src/tools/pdf.ts

@@ -0,0 +1,106 @@
+import path from "path";
+import os from "os";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+
+export function generatePdf(
+  filePath: string,
+  content: string,
+  repoPath: string,
+): string {
+  const fullPath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(repoPath, filePath);
+
+  try {
+    const dir = path.dirname(fullPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    const escaped = content
+      .replace(/\\/g, "\\\\")
+      .replace(/"""/g, '\\"\\"\\"')
+      .replace(/\r/g, "");
+
+    const script = `
+import sys
+try:
+    from reportlab.lib.pagesizes import letter
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, HRFlowable
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.lib import colors
+except ImportError:
+    import subprocess
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "reportlab", "--break-system-packages", "-q"])
+    from reportlab.lib.pagesizes import letter
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, HRFlowable
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+    from reportlab.lib.units import inch
+    from reportlab.lib import colors
+
+doc = SimpleDocTemplate(
+    r"""${fullPath}""",
+    pagesize=letter,
+    rightMargin=inch,
+    leftMargin=inch,
+    topMargin=inch,
+    bottomMargin=inch,
+)
+
+styles = getSampleStyleSheet()
+styles.add(ParagraphStyle(name="H1", parent=styles["Heading1"], fontSize=22, spaceAfter=10))
+styles.add(ParagraphStyle(name="H2", parent=styles["Heading2"], fontSize=16, spaceAfter=8))
+styles.add(ParagraphStyle(name="H3", parent=styles["Heading3"], fontSize=13, spaceAfter=6))
+styles.add(ParagraphStyle(name="Body", parent=styles["Normal"], fontSize=11, leading=16, spaceAfter=8))
+styles.add(ParagraphStyle(name="Bullet", parent=styles["Normal"], fontSize=11, leading=16, leftIndent=20, spaceAfter=4, bulletIndent=10))
+
+raw = """${escaped}"""
+
+story = []
+for line in raw.split("\\n"):
+    s = line.rstrip()
+    if s.startswith("### "):
+        story.append(Paragraph(s[4:], styles["H3"]))
+    elif s.startswith("## "):
+        story.append(Spacer(1, 6))
+        story.append(Paragraph(s[3:], styles["H2"]))
+        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.grey, spaceAfter=4))
+    elif s.startswith("# "):
+        story.append(Paragraph(s[2:], styles["H1"]))
+        story.append(HRFlowable(width="100%", thickness=1, color=colors.black, spaceAfter=6))
+    elif s.startswith("- ") or s.startswith("* "):
+        story.append(Paragraph(u"\\u2022  " + s[2:], styles["Bullet"]))
+    elif s.startswith("---"):
+        story.append(HRFlowable(width="100%", thickness=0.5, color=colors.grey, spaceAfter=4))
+    elif s == "":
+        story.append(Spacer(1, 6))
+    else:
+        import re
+        s = re.sub(r"\\*\\*(.+?)\\*\\*", r"<b>\\1</b>", s)
+        s = re.sub(r"\\*(.+?)\\*", r"<i>\\1</i>", s)
+        s = re.sub(r"\`(.+?)\`", r"<font name='Courier'>\\1</font>", s)
+        story.append(Paragraph(s, styles["Body"]))
+
+doc.build(story)
+print("OK")
+`
+      .replace("${fullPath}", fullPath.replace(/\\/g, "/"))
+      .replace("${escaped}", escaped);
+
+    const tmpFile = path.join(os.tmpdir(), `lens_pdf_${Date.now()}.py`);
+    writeFileSync(tmpFile, script, "utf-8");
+
+    const { execSync } =
+      require("child_process") as typeof import("child_process");
+    execSync(`python "${tmpFile}"`, { stdio: "pipe" });
+
+    try {
+      require("fs").unlinkSync(tmpFile);
+    } catch {
+      /* ignore */
+    }
+
+    return `PDF generated: ${fullPath}`;
+  } catch (err) {
+    return `Error generating PDF: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}

package/src/tools/shell.ts

@@ -0,0 +1,96 @@
+import { execSync } from "child_process";
+
+export async function runShell(command: string, cwd: string): Promise<string> {
+  return new Promise((resolve) => {
+    const { spawn } =
+      require("child_process") as typeof import("child_process");
+    const isWin = process.platform === "win32";
+    const shell = isWin ? "cmd.exe" : "/bin/sh";
+    const shellFlag = isWin ? "/c" : "-c";
+
+    const proc = spawn(shell, [shellFlag, command], {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    const chunks: Buffer[] = [];
+    const errChunks: Buffer[] = [];
+
+    proc.stdout.on("data", (d: Buffer) => chunks.push(d));
+    proc.stderr.on("data", (d: Buffer) => errChunks.push(d));
+
+    const killTimer = setTimeout(
+      () => {
+        proc.kill();
+        resolve("(command timed out after 5 minutes)");
+      },
+      5 * 60 * 1000,
+    );
+
+    proc.on("close", (code: number | null) => {
+      clearTimeout(killTimer);
+      const stdout = Buffer.concat(chunks).toString("utf-8").trim();
+      const stderr = Buffer.concat(errChunks).toString("utf-8").trim();
+      const combined = [stdout, stderr].filter(Boolean).join("\n");
+      resolve(combined || (code === 0 ? "(no output)" : `exit code ${code}`));
+    });
+
+    proc.on("error", (err: Error) => {
+      clearTimeout(killTimer);
+      resolve(`Error: ${err.message}`);
+    });
+  });
+}
+
+export function readClipboard(): string {
+  try {
+    const platform = process.platform;
+    if (platform === "win32") {
+      return execSync("powershell -noprofile -command Get-Clipboard", {
+        encoding: "utf-8",
+        timeout: 2000,
+      })
+        .replace(/\r\n/g, "\n")
+        .trimEnd();
+    }
+    if (platform === "darwin") {
+      return execSync("pbpaste", {
+        encoding: "utf-8",
+        timeout: 2000,
+      }).trimEnd();
+    }
+    for (const cmd of [
+      "xclip -selection clipboard -o",
+      "xsel --clipboard --output",
+      "wl-paste",
+    ]) {
+      try {
+        return execSync(cmd, { encoding: "utf-8", timeout: 2000 }).trimEnd();
+      } catch {
+        continue;
+      }
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+export function openUrl(url: string): string {
+  try {
+    const { execSync: exec } =
+      require("child_process") as typeof import("child_process");
+    const platform = process.platform;
+    if (platform === "win32") {
+      exec(`start "" "${url}"`, { stdio: "ignore" });
+    } else if (platform === "darwin") {
+      exec(`open "${url}"`, { stdio: "ignore" });
+    } else {
+      exec(`xdg-open "${url}"`, { stdio: "ignore" });
+    }
+    return `Opened: ${url}`;
+  } catch (err) {
+    return `Error opening URL: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}

package/src/tools/web.ts

@@ -0,0 +1,216 @@
+// ── HTML helpers ──────────────────────────────────────────────────────────────
+
+function stripTags(html: string): string {
+  return html
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#\d+;/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function extractTables(html: string): string {
+  const tables: string[] = [];
+  const tableRe = /<table[\s\S]*?<\/table>/gi;
+  let tMatch: RegExpExecArray | null;
+
+  while ((tMatch = tableRe.exec(html)) !== null) {
+    const tableHtml = tMatch[0]!;
+    const rows: string[][] = [];
+    const rowRe = /<tr[\s\S]*?<\/tr>/gi;
+    let rMatch: RegExpExecArray | null;
+    while ((rMatch = rowRe.exec(tableHtml)) !== null) {
+      const cells: string[] = [];
+      const cellRe = /<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi;
+      let cMatch: RegExpExecArray | null;
+      while ((cMatch = cellRe.exec(rMatch[0]!)) !== null) {
+        cells.push(stripTags(cMatch[1] ?? ""));
+      }
+      if (cells.length > 0) rows.push(cells);
+    }
+    if (rows.length < 2) continue;
+    const cols = Math.max(...rows.map((r) => r.length));
+    const padded = rows.map((r) => {
+      while (r.length < cols) r.push("");
+      return r;
+    });
+    const widths = Array.from({ length: cols }, (_, ci) =>
+      Math.max(...padded.map((r) => (r[ci] ?? "").length), 3),
+    );
+    const fmt = (r: string[]) =>
+      r.map((c, ci) => c.padEnd(widths[ci] ?? 0)).join(" | ");
+    const header = fmt(padded[0]!);
+    const sep = widths.map((w) => "-".repeat(w)).join("-|-");
+    const body = padded.slice(1).map(fmt).join("\n");
+    tables.push(`${header}\n${sep}\n${body}`);
+  }
+
+  return tables.length > 0
+    ? `=== TABLES (${tables.length}) ===\n\n${tables.join("\n\n---\n\n")}`
+    : "";
+}
+
+function extractLists(html: string): string {
+  const lists: string[] = [];
+  const listRe = /<[ou]l[\s\S]*?<\/[ou]l>/gi;
+  let lMatch: RegExpExecArray | null;
+  while ((lMatch = listRe.exec(html)) !== null) {
+    const items: string[] = [];
+    const itemRe = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+    let iMatch: RegExpExecArray | null;
+    while ((iMatch = itemRe.exec(lMatch[0]!)) !== null) {
+      const text = stripTags(iMatch[1] ?? "");
+      if (text.length > 2) items.push(`• ${text}`);
+    }
+    if (items.length > 1) lists.push(items.join("\n"));
+  }
+  return lists.length > 0
+    ? `=== LISTS ===\n\n${lists.slice(0, 5).join("\n\n")}`
+    : "";
+}
+
+// ── Fetch ─────────────────────────────────────────────────────────────────────
+
+export async function fetchUrl(url: string): Promise<string> {
+  const res = await fetch(url, {
+    headers: {
+      "User-Agent":
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5",
+    },
+    signal: AbortSignal.timeout(15000),
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+
+  const contentType = res.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await res.json();
+    return JSON.stringify(json, null, 2).slice(0, 8000);
+  }
+
+  const html = await res.text();
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? stripTags(titleMatch[1]!) : "No title";
+
+  const tables = extractTables(html);
+  const lists = extractLists(html);
+  const bodyText = stripTags(
+    html
+      .replace(/<script[\s\S]*?<\/script>/gi, "")
+      .replace(/<style[\s\S]*?<\/style>/gi, "")
+      .replace(/<nav[\s\S]*?<\/nav>/gi, "")
+      .replace(/<footer[\s\S]*?<\/footer>/gi, "")
+      .replace(/<header[\s\S]*?<\/header>/gi, ""),
+  )
+    .replace(/\s{3,}/g, "\n\n")
+    .slice(0, 3000);
+
+  const parts = [`PAGE: ${title}`, `URL: ${url}`];
+  if (tables) parts.push(tables);
+  if (lists) parts.push(lists);
+  parts.push(`=== TEXT ===\n${bodyText}`);
+  return parts.join("\n\n");
+}
+
+// ── Search ────────────────────────────────────────────────────────────────────
+
+export async function searchWeb(query: string): Promise<string> {
+  const encoded = encodeURIComponent(query);
+
+  const ddgUrl = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
+  try {
+    const res = await fetch(ddgUrl, {
+      headers: { "User-Agent": "Lens/1.0" },
+      signal: AbortSignal.timeout(8000),
+    });
+    if (res.ok) {
+      const data = (await res.json()) as {
+        AbstractText?: string;
+        AbstractURL?: string;
+        RelatedTopics?: { Text?: string; FirstURL?: string }[];
+        Answer?: string;
+        Infobox?: { content?: { label: string; value: string }[] };
+      };
+
+      const parts: string[] = [`Search: ${query}`];
+      if (data.Answer) parts.push(`Answer: ${data.Answer}`);
+      if (data.AbstractText) {
+        parts.push(`Summary: ${data.AbstractText}`);
+        if (data.AbstractURL) parts.push(`Source: ${data.AbstractURL}`);
+      }
+      if (data.Infobox?.content?.length) {
+        const fields = data.Infobox.content
+          .slice(0, 8)
+          .map((f) => `  ${f.label}: ${f.value}`)
+          .join("\n");
+        parts.push(`Info:\n${fields}`);
+      }
+      if (data.RelatedTopics?.length) {
+        const topics = (data.RelatedTopics as { Text?: string }[])
+          .filter((t) => t.Text)
+          .slice(0, 5)
+          .map((t) => `  - ${t.Text}`)
+          .join("\n");
+        if (topics) parts.push(`Related:\n${topics}`);
+      }
+
+      const result = parts.join("\n\n");
+      if (result.length > 60) return result;
+    }
+  } catch {
+    // fall through to HTML scrape
+  }
+
+  try {
+    const htmlUrl = `https://html.duckduckgo.com/html/?q=${encoded}`;
+    const res = await fetch(htmlUrl, {
+      headers: {
+        "User-Agent":
+          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        Accept: "text/html",
+      },
+      signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const html = await res.text();
+
+    const snippets: string[] = [];
+    const snippetRe = /class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+    let m: RegExpExecArray | null;
+    while ((m = snippetRe.exec(html)) !== null && snippets.length < 6) {
+      const text = m[1]!
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/\s+/g, " ")
+        .trim();
+      if (text.length > 20) snippets.push(`- ${text}`);
+    }
+
+    const links: string[] = [];
+    const linkRe = /class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g;
+    while ((m = linkRe.exec(html)) !== null && links.length < 5) {
+      const title = m[2]!.replace(/<[^>]+>/g, "").trim();
+      const href = m[1]!;
+      if (title && href) links.push(`  ${title} \u2014 ${href}`);
+    }
+
+    if (snippets.length === 0 && links.length === 0)
+      return `No results found for: ${query}`;
+
+    const parts = [`Search results for: ${query}`];
+    if (snippets.length > 0) parts.push(`Snippets:\n${snippets.join("\n")}`);
+    if (links.length > 0) parts.push(`Links:\n${links.join("\n")}`);
+    return parts.join("\n\n");
+  } catch (err) {
+    return `Search failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}