@ridit/lens 0.2.4 → 0.2.6

package/src/tools/pdf.ts

@@ -1,12 +1,13 @@
+// Generates PDFs from markdown content — useful for exporting codebase reports and documentation.
+
 import path from "path";
-import os from "os";
 import { existsSync, mkdirSync, writeFileSync } from "fs";
 
-export function generatePdf(
+export async function generatePdf(
   filePath: string,
   content: string,
   repoPath: string,
-): string {
+): Promise<string> {
   const fullPath = path.isAbsolute(filePath)
     ? filePath
     : path.join(repoPath, filePath);
@@ -15,91 +16,148 @@ export function generatePdf(
     const dir = path.dirname(fullPath);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
-    const escaped = content
-      .replace(/\\/g, "\\\\")
-      .replace(/"""/g, '\\"\\"\\"')
-      .replace(/\r/g, "");
+    const PDFDocument = require("pdfkit");
+    const doc = new PDFDocument({ margin: 72 });
+    const chunks: Buffer[] = [];
 
-    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.on("data", (chunk: Buffer) => chunks.push(chunk));
 
-doc = SimpleDocTemplate(
-    r"""${fullPath}""",
-    pagesize=letter,
-    rightMargin=inch,
-    leftMargin=inch,
-    topMargin=inch,
-    bottomMargin=inch,
-)
+    return new Promise((resolve) => {
+      doc.on("end", () => {
+        try {
+          writeFileSync(fullPath, Buffer.concat(chunks));
+          resolve(`PDF generated: ${fullPath}`);
+        } catch (err) {
+          resolve(
+            `Error writing PDF: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      });
 
-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))
+      doc.on("error", (err: Error) => {
+        resolve(`Error generating PDF: ${err.message}`);
+      });
 
-raw = """${escaped}"""
+      const lines = content.split("\n");
+      let firstElement = true;
 
-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"]))
+      const addSpacingBefore = () => {
+        if (!firstElement) doc.moveDown(0.5);
+        firstElement = false;
+      };
 
-doc.build(story)
-print("OK")
-`
-      .replace("${fullPath}", fullPath.replace(/\\/g, "/"))
-      .replace("${escaped}", escaped);
+      const bullets: string[] = [];
 
-    const tmpFile = path.join(os.tmpdir(), `lens_pdf_${Date.now()}.py`);
-    writeFileSync(tmpFile, script, "utf-8");
+      const flushBullets = () => {
+        if (bullets.length === 0) return;
+        addSpacingBefore();
+        for (const bullet of bullets) {
+          doc
+            .fontSize(11)
+            .fillColor("#333333")
+            .text(`• ${bullet}`, { indent: 20, lineGap: 3 });
+        }
+        bullets.length = 0;
+      };
 
-    const { execSync } =
-      require("child_process") as typeof import("child_process");
-    execSync(`python "${tmpFile}"`, { stdio: "pipe" });
+      for (const raw of lines) {
+        const line = raw.trimEnd();
 
-    try {
-      require("fs").unlinkSync(tmpFile);
-    } catch {
-      /* ignore */
-    }
+        if (line.startsWith("# ")) {
+          flushBullets();
+          addSpacingBefore();
+          doc
+            .fontSize(22)
+            .fillColor("#000000")
+            .font("Helvetica-Bold")
+            .text(line.slice(2));
+          doc.moveDown(0.2);
+          doc
+            .moveTo(72, doc.y)
+            .lineTo(doc.page.width - 72, doc.y)
+            .strokeColor("#000000")
+            .lineWidth(1)
+            .stroke();
+          doc.moveDown(0.4);
+          doc.font("Helvetica");
+        } else if (line.startsWith("## ")) {
+          flushBullets();
+          addSpacingBefore();
+          doc
+            .fontSize(16)
+            .fillColor("#111111")
+            .font("Helvetica-Bold")
+            .text(line.slice(3));
+          doc.moveDown(0.2);
+          doc
+            .moveTo(72, doc.y)
+            .lineTo(doc.page.width - 72, doc.y)
+            .strokeColor("#999999")
+            .lineWidth(0.5)
+            .stroke();
+          doc.moveDown(0.3);
+          doc.font("Helvetica");
+        } else if (line.startsWith("### ")) {
+          flushBullets();
+          addSpacingBefore();
+          doc
+            .fontSize(13)
+            .fillColor("#222222")
+            .font("Helvetica-Bold")
+            .text(line.slice(4));
+          doc.font("Helvetica");
+        } else if (line.startsWith("- ") || line.startsWith("* ")) {
+          bullets.push(line.slice(2));
+        } else if (line.startsWith("---")) {
+          flushBullets();
+          doc.moveDown(0.5);
+          doc
+            .moveTo(72, doc.y)
+            .lineTo(doc.page.width - 72, doc.y)
+            .strokeColor("#cccccc")
+            .lineWidth(0.5)
+            .stroke();
+          doc.moveDown(0.5);
+        } else if (line === "") {
+          flushBullets();
+        } else {
+          flushBullets();
+          addSpacingBefore();
+          // handle inline bold (**text**) and inline code (`text`)
+          const segments = line.split(/(\*\*[^*]+\*\*|`[^`]+`)/g);
+          let isFirst = true;
+          for (const seg of segments) {
+            if (seg.startsWith("**") && seg.endsWith("**")) {
+              doc
+                .fontSize(11)
+                .fillColor("#333333")
+                .font("Helvetica-Bold")
+                .text(seg.slice(2, -2), { continued: true, lineGap: 3 });
+              doc.font("Helvetica");
+            } else if (seg.startsWith("`") && seg.endsWith("`")) {
+              doc
+                .fontSize(10)
+                .fillColor("#c0392b")
+                .font("Courier")
+                .text(seg.slice(1, -1), { continued: true, lineGap: 3 });
+              doc.font("Helvetica").fontSize(11).fillColor("#333333");
+            } else if (seg.length > 0) {
+              doc
+                .fontSize(11)
+                .fillColor("#333333")
+                .font("Helvetica")
+                .text(seg, { continued: true, lineGap: 3 });
+            }
+            isFirst = false;
+          }
+          // end the continued text
+          doc.text("", { continued: false });
+        }
+      }
 
-    return `PDF generated: ${fullPath}`;
+      flushBullets();
+      doc.end();
+    });
   } catch (err) {
     return `Error generating PDF: ${err instanceof Error ? err.message : String(err)}`;
   }

package/src/tools/view-image.ts

@@ -0,0 +1,335 @@
+// ── tools/view-image.ts ───────────────────────────────────────────────────────
+//
+// Display images in the terminal using the best available protocol:
+//
+//   1. iTerm2 inline image protocol (OSC 1337)
+//      Supported by: iTerm2, WezTerm, VSCode integrated terminal,
+//                    Windows Terminal (via some builds), Tabby, Hyper
+//
+//   2. Kitty graphics protocol
+//      Supported by: Kitty, WezTerm
+//
+//   3. Sixel
+//      Supported by: Windows Terminal 1.22+, xterm, mlterm, WezTerm
+//      Requires: chafa or img2sixel on PATH (auto-detected)
+//
+//   4. Half-block fallback via terminal-image
+//      Works everywhere that supports 256 colors.
+//      Quality is limited to block characters (▄▀) — better than nothing.
+//
+// Protocol is auto-detected from environment variables and terminal responses.
+// Can be overridden by passing "protocol" in the JSON input.
+
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+import type { Tool } from "@ridit/lens-sdk";
+import { execSync } from "child_process";
+
+// ── input ─────────────────────────────────────────────────────────────────────
+
+type Protocol = "iterm2" | "kitty" | "sixel" | "halfblock" | "auto";
+
+interface ViewImageInput {
+  /** File path (repo-relative or absolute) or URL */
+  src: string;
+  /** Width: percentage "50%" or column count 40. Default "80%" */
+  width?: string | number;
+  /** Force a specific protocol instead of auto-detecting */
+  protocol?: Protocol;
+}
+
+function parseViewImageInput(body: string): ViewImageInput | null {
+  const trimmed = body.trim();
+  if (!trimmed) return null;
+
+  if (trimmed.startsWith("{")) {
+    try {
+      const p = JSON.parse(trimmed) as {
+        src?: string;
+        path?: string;
+        url?: string;
+        width?: string | number;
+        protocol?: Protocol;
+      };
+      const src = p.src ?? p.path ?? p.url ?? "";
+      if (!src) return null;
+      return { src, width: p.width ?? "80%", protocol: p.protocol ?? "auto" };
+    } catch {
+      return null;
+    }
+  }
+
+  return { src: trimmed, width: "80%", protocol: "auto" };
+}
+
+// ── fetch image bytes ─────────────────────────────────────────────────────────
+
+async function fetchBytes(src: string, repoPath: string): Promise<Buffer> {
+  if (src.startsWith("http://") || src.startsWith("https://")) {
+    const res = await fetch(src, { signal: AbortSignal.timeout(20_000) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+    return Buffer.from(await res.arrayBuffer());
+  }
+  const resolved = path.isAbsolute(src) ? src : path.join(repoPath, src);
+  if (!existsSync(resolved)) throw new Error(`File not found: ${resolved}`);
+  return readFileSync(resolved);
+}
+
+// ── protocol detection ────────────────────────────────────────────────────────
+
+function detectProtocol(): Exclude<Protocol, "auto"> {
+  const term = (process.env["TERM"] ?? "").toLowerCase();
+  const termProgram = (process.env["TERM_PROGRAM"] ?? "").toLowerCase();
+  const termEmulator = (process.env["TERM_EMULATOR"] ?? "").toLowerCase();
+
+  // Kitty
+  if (term === "xterm-kitty" || process.env["KITTY_WINDOW_ID"]) {
+    return "kitty";
+  }
+
+  // iTerm2
+  if (
+    termProgram === "iterm.app" ||
+    termProgram === "iterm2" ||
+    process.env["ITERM_SESSION_ID"]
+  ) {
+    return "iterm2";
+  }
+
+  // WezTerm — supports both kitty and iterm2; prefer kitty
+  if (termProgram === "wezterm" || process.env["WEZTERM_EXECUTABLE"]) {
+    return "kitty";
+  }
+
+  // VSCode integrated terminal — supports iTerm2 protocol
+  if (
+    process.env["TERM_PROGRAM"] === "vscode" ||
+    process.env["VSCODE_INJECTION"] ||
+    process.env["VSCODE_GIT_ASKPASS_NODE"]
+  ) {
+    return "iterm2";
+  }
+
+  // Windows Terminal 1.22+ supports Sixel
+  // WT_SESSION is set in Windows Terminal
+  if (process.env["WT_SESSION"]) {
+    // Check if chafa or img2sixel is available for sixel encoding
+    if (commandExists("chafa") || commandExists("img2sixel")) {
+      return "sixel";
+    }
+    // Fall through to halfblock — Windows Terminal also does colors fine
+  }
+
+  // Tabby / Hyper typically support iTerm2
+  if (termEmulator.includes("tabby") || termEmulator.includes("hyper")) {
+    return "iterm2";
+  }
+
+  // xterm with sixel support
+  if (term.includes("xterm") && commandExists("img2sixel")) {
+    return "sixel";
+  }
+
+  return "halfblock";
+}
+
+function commandExists(cmd: string): boolean {
+  try {
+    execSync(process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`, {
+      stdio: "pipe",
+      timeout: 2000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ── renderers ─────────────────────────────────────────────────────────────────
+
+// iTerm2 inline image protocol (OSC 1337)
+function renderITerm2(buf: Buffer, width: string | number): string {
+  const b64 = buf.toString("base64");
+  const widthParam =
+    typeof width === "number" ? `width=${width}` : `width=${width}`;
+  // ESC ] 1337 ; File=inline=1;width=...: <base64> BEL
+  return `\x1b]1337;File=inline=1;${widthParam};preserveAspectRatio=1:${b64}\x07\n`;
+}
+
+// Kitty graphics protocol (APC, chunked base64)
+function renderKitty(buf: Buffer, width: string | number): string {
+  const b64 = buf.toString("base64");
+  const chunkSize = 4096;
+  const chunks: string[] = [];
+  for (let i = 0; i < b64.length; i += chunkSize) {
+    chunks.push(b64.slice(i, i + chunkSize));
+  }
+
+  const cols =
+    typeof width === "number"
+      ? width
+      : width.endsWith("%")
+        ? Math.floor((process.stdout.columns ?? 80) * (parseInt(width) / 100))
+        : parseInt(width);
+
+  let result = "";
+  chunks.forEach((chunk, idx) => {
+    const isLast = idx === chunks.length - 1;
+    const more = isLast ? 0 : 1;
+    if (idx === 0) {
+      // First chunk: f=100 (PNG), a=T (transmit+display), c=columns
+      result += `\x1b_Ga=T,f=100,m=${more},c=${cols};${chunk}\x1b\\`;
+    } else {
+      result += `\x1b_Gm=${more};${chunk}\x1b\\`;
+    }
+  });
+  return result + "\n";
+}
+
+// Sixel via chafa (preferred, auto-detects format) or img2sixel
+function renderSixel(
+  buf: Buffer,
+  src: string,
+  repoPath: string,
+  width: string | number,
+): string {
+  const widthCols =
+    typeof width === "number"
+      ? width
+      : width.endsWith("%")
+        ? Math.floor((process.stdout.columns ?? 80) * (parseInt(width) / 100))
+        : parseInt(width);
+
+  // Write buf to a temp file so we can pass it to CLI tools
+  const tmpPath = path.join(
+    process.env["TEMP"] ?? process.env["TMPDIR"] ?? "/tmp",
+    `lens_img_${Date.now()}.bin`,
+  );
+  const { writeFileSync, unlinkSync } = require("fs") as typeof import("fs");
+  writeFileSync(tmpPath, buf);
+
+  try {
+    if (commandExists("chafa")) {
+      const result = execSync(
+        `chafa --format sixel --size ${widthCols}x40 "${tmpPath}"`,
+        { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 15_000 },
+      );
+      return result + "\n";
+    }
+    if (commandExists("img2sixel")) {
+      const result = execSync(`img2sixel -w ${widthCols * 8} "${tmpPath}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 15_000,
+      });
+      return result + "\n";
+    }
+    throw new Error("no sixel encoder found");
+  } finally {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+// Half-block fallback via terminal-image
+async function renderHalfBlock(
+  buf: Buffer,
+  width: string | number,
+): Promise<string> {
+  let terminalImage: any;
+  try {
+    terminalImage = await import("terminal-image");
+    terminalImage = terminalImage.default ?? terminalImage;
+  } catch {
+    return (
+      "Error: terminal-image not installed (npm install terminal-image).\n" +
+      "For better image display, install chafa: https://hpjansson.org/chafa/\n" +
+      "  Windows: winget install hpjansson.chafa\n" +
+      "  macOS:   brew install chafa\n" +
+      "  Linux:   sudo apt install chafa"
+    );
+  }
+  return await terminalImage.buffer(buf, {
+    width,
+    preserveAspectRatio: true,
+  });
+}
+
+// ── main render ───────────────────────────────────────────────────────────────
+
+async function renderImage(
+  input: ViewImageInput,
+  repoPath: string,
+): Promise<string> {
+  const buf = await fetchBytes(input.src, repoPath);
+  const width = input.width ?? "80%";
+  const protocol =
+    input.protocol === "auto" || !input.protocol
+      ? detectProtocol()
+      : input.protocol;
+
+  switch (protocol) {
+    case "iterm2":
+      return renderITerm2(buf, width);
+
+    case "kitty":
+      return renderKitty(buf, width);
+
+    case "sixel":
+      try {
+        return renderSixel(buf, input.src, repoPath, width);
+      } catch (e: any) {
+        // Sixel encoder missing — fall through to halfblock
+        return (
+          `(sixel encoder not found — install chafa for better quality)\n` +
+          (await renderHalfBlock(buf, width))
+        );
+      }
+
+    case "halfblock":
+    default:
+      return await renderHalfBlock(buf, width);
+  }
+}
+
+// ── tool ──────────────────────────────────────────────────────────────────────
+
+export const viewImageTool: Tool<ViewImageInput> = {
+  name: "view-image",
+  description:
+    "display an image in the terminal (auto-detects iTerm2/Kitty/Sixel/half-block)",
+  safe: true,
+  permissionLabel: "view image",
+
+  systemPromptEntry: (i) =>
+    [
+      `### ${i}. view-image — display an image in the terminal`,
+      `<view-image>screenshot.png</view-image>`,
+      `<view-image>https://example.com/banner.jpg</view-image>`,
+      `<view-image>{"src": "assets/logo.png", "width": "60%"}</view-image>`,
+      `<view-image>{"src": "photo.jpg", "width": "80%", "protocol": "iterm2"}</view-image>`,
+      `Protocols: auto (default), iterm2, kitty, sixel, halfblock`,
+      `Width: percentage "50%" or column count 40. Default "80%"`,
+      `Supported formats: PNG, JPG, GIF, WebP, BMP, TIFF`,
+    ].join("\n"),
+
+  parseInput: parseViewImageInput,
+
+  summariseInput: ({ src, width }) =>
+    `${path.basename(src)} (${width ?? "80%"})`,
+
+  execute: async (input, ctx) => {
+    try {
+      const ansi = await renderImage(input, ctx.repoPath);
+      return { kind: "image" as any, value: ansi };
+    } catch (err) {
+      return {
+        kind: "text",
+        value: `Error: ${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  },
+};

package/src/tools/web.ts

@@ -1,5 +1,3 @@
-// ── HTML helpers ──────────────────────────────────────────────────────────────
-
 function stripTags(html: string): string {
   return html
     .replace(/<[^>]+>/g, " ")
@@ -73,8 +71,6 @@ function extractLists(html: string): string {
     : "";
 }
 
-// ── Fetch ─────────────────────────────────────────────────────────────────────
-
 export async function fetchUrl(url: string): Promise<string> {
   const res = await fetch(url, {
     headers: {

package/src/utils/addons/loadAddons.ts

@@ -6,7 +6,6 @@ const ADDONS_DIR = path.join(os.homedir(), ".lens", "addons");
 
 export async function loadAddons(): Promise<void> {
   if (!existsSync(ADDONS_DIR)) {
-    // Silently skip — no addons directory yet
     return;
   }
 
@@ -14,11 +13,15 @@ export async function loadAddons(): Promise<void> {
     (f) => f.endsWith(".js") && !f.startsWith("_"),
   );
 
-  for (const file of files) {
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (!file) return;
+
     const fullPath = path.join(ADDONS_DIR, file);
+    const isLast = i === files.length - 1;
     try {
       await import(fullPath);
-      console.log(`[addons] loaded: ${file}\n`);
+      console.log(`[addons] loaded: ${file}${isLast ? "\n" : ""}`);
     } catch (err) {
       console.error(
         `[addons] failed to load ${file}:`,