@cyber-dash-tech/revela 0.1.0

package/lib/qa/measure.ts

@@ -0,0 +1,287 @@
+/**
+ * lib/qa/measure.ts
+ *
+ * Puppeteer-based slide layout measurement.
+ * Opens the HTML file with a headless Chrome, navigates to each slide,
+ * and records the bounding boxes of all visible elements inside the
+ * slide canvas (1920×1080).
+ *
+ * Returns raw per-slide geometry data consumed by checks.ts.
+ */
+
+import puppeteer from "puppeteer-core"
+import { pathToFileURL } from "url"
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+/** The canonical slide canvas size (matches the design system). */
+export const CANVAS_W = 1920
+export const CANVAS_H = 1080
+
+/** Path to system Chrome on macOS. Falls back to common Linux paths. */
+const CHROME_PATHS = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/Applications/Chromium.app/Contents/MacOS/Chromium",
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/google-chrome",
+  "/usr/bin/chromium-browser",
+  "/usr/bin/chromium",
+]
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface Rect {
+  left: number
+  top: number
+  right: number
+  bottom: number
+  width: number
+  height: number
+}
+
+export interface ElementInfo {
+  /** CSS selector path (tag + nth-child chain), for human-readable reports */
+  selector: string
+  rect: Rect
+  /** true if element is considered "visible" (non-zero size, not hidden) */
+  visible: boolean
+  /** direct children that are also visible */
+  children: ElementInfo[]
+}
+
+export interface SlideMetrics {
+  /** 0-based slide index */
+  index: number
+  /** slide title extracted from the first h1/h2 inside the slide */
+  title: string
+  /**
+   * Structural role from the slide's `data-slide-type` attribute.
+   * Valid values: "cover", "toc", "content", "closing", "divider", "summary".
+   * Undefined when the attribute is absent (old/third-party HTML).
+   */
+  slideType?: string
+  /** bounding box of the slide-canvas element itself (post-scale) */
+  canvasRect: Rect
+  /** top-level visible children of .slide-canvas */
+  elements: ElementInfo[]
+  /** union bounding box of all visible leaf elements */
+  contentRect: Rect
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function findChromePath(): string {
+  const { existsSync } = require("fs") as typeof import("fs")
+  for (const p of CHROME_PATHS) {
+    if (existsSync(p)) return p
+  }
+  throw new Error(
+    "Could not find a Chrome/Chromium installation. " +
+    "Tried: " + CHROME_PATHS.join(", ")
+  )
+}
+
+// ── Main export ──────────────────────────────────────────────────────────────
+
+/**
+ * Open `htmlFilePath` in a headless Chrome at 1920×1080, measure each slide,
+ * and return an array of SlideMetrics (one per .slide element).
+ */
+export async function measureSlides(htmlFilePath: string): Promise<SlideMetrics[]> {
+  const executablePath = findChromePath()
+  const fileUrl = pathToFileURL(htmlFilePath).href
+
+  const browser = await puppeteer.launch({
+    executablePath,
+    headless: true,
+    args: [
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-dev-shm-usage",
+      "--window-size=1920,1080",
+    ],
+  })
+
+  try {
+    const page = await browser.newPage()
+
+    // Set viewport to exact canvas size so scale === 1 (no CSS transform needed).
+    await page.setViewport({ width: CANVAS_W, height: CANVAS_H })
+    await page.goto(fileUrl, { waitUntil: "networkidle0", timeout: 30000 })
+
+    // Wait for any entrance animations / intersection observers to fire.
+    await new Promise((r) => setTimeout(r, 600))
+
+    // Measure slides one-by-one: scroll each into view, wait for animations,
+    // then collect geometry relative to the canvas coordinate system.
+    const slideCount: number = await page.evaluate(
+      () => document.querySelectorAll(".slide").length
+    )
+
+    const metrics: SlideMetrics[] = []
+
+    for (let idx = 0; idx < slideCount; idx++) {
+      // Scroll the slide into view and wait for intersection observers / animations
+      await page.evaluate((i: number) => {
+        const slides = document.querySelectorAll(".slide")
+        const slide = slides[i] as HTMLElement
+        if (slide) {
+          slide.scrollIntoView({ behavior: "instant" })
+          // Force all .reveal elements visible (in case IO didn't fire)
+          slide.querySelectorAll(".reveal").forEach((el) => el.classList.add("visible"))
+        }
+      }, idx)
+
+      // Wait for CSS transitions + any JS rendering (ECharts, bar animations, etc.)
+      await new Promise((r) => setTimeout(r, 800))
+
+      const slideData = await page.evaluate(
+        (slideIdx: number) => {
+          // ── In-browser helpers ───────────────────────────────────────────
+
+          function isVisible(el: Element): boolean {
+            const r = el.getBoundingClientRect()
+            if (r.width === 0 || r.height === 0) return false
+            const style = window.getComputedStyle(el)
+            if (style.visibility === "hidden") return false
+            if (style.display === "none") return false
+            if (parseFloat(style.opacity) < 0.01) return false
+            return true
+          }
+
+          function toRectRelative(r: DOMRect, offsetTop: number, offsetLeft: number) {
+            return {
+              left: r.left - offsetLeft,
+              top: r.top - offsetTop,
+              right: r.right - offsetLeft,
+              bottom: r.bottom - offsetTop,
+              width: r.width,
+              height: r.height,
+            }
+          }
+
+          function selectorOf(el: Element): string {
+            const parts: string[] = []
+            let cur: Element | null = el
+            while (cur && cur !== document.body) {
+              const tag = cur.tagName.toLowerCase()
+              const cls = Array.from(cur.classList)
+                .slice(0, 2)
+                .map((c) => "." + c)
+                .join("")
+              parts.unshift(tag + cls)
+              cur = cur.parentElement
+            }
+            return parts.slice(-3).join(" > ")
+          }
+
+          type EI = {
+            selector: string
+            rect: ReturnType<typeof toRectRelative>
+            visible: boolean
+            children: EI[]
+          }
+
+          function collectChildren(
+            el: Element,
+            offsetTop: number,
+            offsetLeft: number,
+            depth = 0
+          ): EI[] {
+            if (depth > 4) return []
+            const result: EI[] = []
+            for (const child of Array.from(el.children)) {
+              if (!isVisible(child)) continue
+              const rawR = child.getBoundingClientRect()
+              const cls = child.className || ""
+              if (
+                typeof cls === "string" &&
+                (cls.includes("aurora") ||
+                  cls.includes("stars") ||
+                  cls.includes("progress") ||
+                  cls.includes("nav-dot") ||
+                  cls.includes("deco-blob"))
+              ) continue
+              const relR = toRectRelative(rawR, offsetTop, offsetLeft)
+              result.push({
+                selector: selectorOf(child),
+                rect: relR,
+                visible: true,
+                children: collectChildren(child, offsetTop, offsetLeft, depth + 1),
+              })
+            }
+            return result
+          }
+
+          function unionRect(els: EI[]): ReturnType<typeof toRectRelative> {
+            let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity
+            function walk(list: EI[]) {
+              for (const e of list) {
+                if (!e.visible) continue
+                if (e.children.length > 0) {
+                  walk(e.children)
+                } else {
+                  left = Math.min(left, e.rect.left)
+                  top = Math.min(top, e.rect.top)
+                  right = Math.max(right, e.rect.right)
+                  bottom = Math.max(bottom, e.rect.bottom)
+                }
+              }
+            }
+            walk(els)
+            if (left === Infinity) return { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 }
+            return { left, top, right, bottom, width: right - left, height: bottom - top }
+          }
+
+          // ── Per-slide measurement ────────────────────────────────────────
+
+          const slide = document.querySelectorAll(".slide")[slideIdx]
+          if (!slide) return null
+
+          // Read the semantic slide type if the author provided it
+          const slideType = (slide as HTMLElement).dataset.slideType || slide.getAttribute("data-slide-type") || undefined
+
+          const canvas = slide.querySelector(".slide-canvas") as HTMLElement | null
+          if (!canvas) return null
+
+          const canvasRaw = canvas.getBoundingClientRect()
+          // Use canvas top-left as the coordinate origin
+          const offsetTop = canvasRaw.top
+          const offsetLeft = canvasRaw.left
+
+          const canvasRect = {
+            left: 0,
+            top: 0,
+            right: canvasRaw.width,
+            bottom: canvasRaw.height,
+            width: canvasRaw.width,
+            height: canvasRaw.height,
+          }
+
+          const elements = collectChildren(canvas, offsetTop, offsetLeft)
+
+          const titleEl = canvas.querySelector("h1, h2")
+          const title = titleEl
+            ? (titleEl.textContent || "").replace(/\s+/g, " ").trim().slice(0, 80)
+            : `Slide ${slideIdx + 1}`
+
+          return {
+            index: slideIdx,
+            title,
+            slideType,
+            canvasRect,
+            elements,
+            contentRect: unionRect(elements),
+          }
+        },
+        idx
+      )
+
+      if (slideData) metrics.push(slideData as SlideMetrics)
+    }
+
+    return metrics
+  } finally {
+    await browser.close()
+  }
+}

package/lib/read-hooks/extractors/docx.ts

@@ -0,0 +1,16 @@
+/**
+ * lib/read-hooks/extractors/docx.ts
+ *
+ * DOCX text extraction using mammoth.js (pure JS, 6k+ stars).
+ * Extracts raw text without formatting — suitable for LLM context.
+ */
+
+import mammoth from "mammoth"
+
+/**
+ * Extract plain text from a DOCX buffer.
+ */
+export async function extractDocx(buf: Buffer): Promise<string> {
+  const result = await mammoth.extractRawText({ buffer: buf })
+  return result.value
+}

package/lib/read-hooks/extractors/pdf.ts

@@ -0,0 +1,19 @@
+/**
+ * lib/read-hooks/extractors/pdf.ts
+ *
+ * PDF text extraction using unpdf (zero-dependency, pure JS, serverless PDF.js).
+ * Only extracts text — image extraction from PDFs requires native deps (@napi-rs/canvas)
+ * and is intentionally excluded.
+ */
+
+import { getDocumentProxy, extractText } from "unpdf"
+
+/**
+ * Extract all text from a PDF buffer.
+ * Pages are merged into a single string with double newlines between them.
+ */
+export async function extractPdfText(buf: Buffer): Promise<string> {
+  const pdf = await getDocumentProxy(new Uint8Array(buf))
+  const { text } = await extractText(pdf, { mergePages: true })
+  return text
+}

package/lib/read-hooks/extractors/pptx.ts

@@ -0,0 +1,53 @@
+/**
+ * lib/read-hooks/extractors/pptx.ts
+ *
+ * PPTX text extraction using fflate (ZIP decompression) + @xmldom/xmldom (XML parsing).
+ * Pure JS, zero native dependencies.
+ *
+ * PPTX is a ZIP archive containing slide XML files at ppt/slides/slideN.xml.
+ * Text content is stored in <a:t> elements under the DrawingML namespace.
+ */
+
+import { unzipSync } from "fflate"
+import { DOMParser } from "@xmldom/xmldom"
+
+const DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
+
+/**
+ * Extract text from all slides in a PPTX buffer.
+ * Returns slides in order, each prefixed with "--- Slide N ---".
+ */
+export async function extractPptx(buf: Buffer): Promise<string> {
+  const files = unzipSync(new Uint8Array(buf))
+  const parser = new DOMParser()
+  const slides: string[] = []
+
+  // Collect and sort slide files by slide number
+  const slideFiles = Object.keys(files)
+    .filter((f) => /^ppt\/slides\/slide\d+\.xml$/.test(f))
+    .sort((a, b) => {
+      const na = parseInt(a.match(/\d+/)![0], 10)
+      const nb = parseInt(b.match(/\d+/)![0], 10)
+      return na - nb
+    })
+
+  for (const path of slideFiles) {
+    const xml = new TextDecoder().decode(files[path])
+    const doc = parser.parseFromString(xml, "text/xml")
+
+    // Extract all <a:t> text nodes
+    const textNodes = doc.getElementsByTagNameNS(DRAWINGML_NS, "t")
+    const texts: string[] = []
+    for (let i = 0; i < textNodes.length; i++) {
+      const t = textNodes[i].textContent?.trim()
+      if (t) texts.push(t)
+    }
+
+    if (texts.length) {
+      const slideNum = path.match(/\d+/)![0]
+      slides.push(`--- Slide ${slideNum} ---\n${texts.join("\n")}`)
+    }
+  }
+
+  return slides.join("\n\n")
+}

package/lib/read-hooks/extractors/xlsx.ts

@@ -0,0 +1,81 @@
+/**
+ * lib/read-hooks/extractors/xlsx.ts
+ *
+ * XLSX text extraction using fflate (ZIP decompression) + @xmldom/xmldom (XML parsing).
+ * Pure JS, zero native dependencies.
+ *
+ * XLSX is a ZIP archive. Text values are stored in xl/sharedStrings.xml;
+ * cell references index into that shared table. Sheet data lives in
+ * xl/worksheets/sheetN.xml.
+ */
+
+import { unzipSync } from "fflate"
+import { DOMParser } from "@xmldom/xmldom"
+
+/**
+ * Extract tabular text from all sheets in an XLSX buffer.
+ * Returns sheets in order, each prefixed with "--- Sheet N ---".
+ * Cells are tab-separated, rows are newline-separated.
+ */
+export async function extractXlsx(buf: Buffer): Promise<string> {
+  const files = unzipSync(new Uint8Array(buf))
+  const parser = new DOMParser()
+
+  // 1. Parse sharedStrings.xml — all string values are stored here by index
+  const sharedStrings: string[] = []
+  const ssFile = files["xl/sharedStrings.xml"]
+  if (ssFile) {
+    const doc = parser.parseFromString(new TextDecoder().decode(ssFile), "text/xml")
+    const siNodes = doc.getElementsByTagName("si")
+    for (let i = 0; i < siNodes.length; i++) {
+      const tNodes = siNodes[i].getElementsByTagName("t")
+      const parts: string[] = []
+      for (let j = 0; j < tNodes.length; j++) {
+        parts.push(tNodes[j].textContent ?? "")
+      }
+      sharedStrings.push(parts.join(""))
+    }
+  }
+
+  // 2. Parse each worksheet
+  const sheets: string[] = []
+  const sheetFiles = Object.keys(files)
+    .filter((f) => /^xl\/worksheets\/sheet\d+\.xml$/.test(f))
+    .sort((a, b) => {
+      const na = parseInt(a.match(/\d+/)![0], 10)
+      const nb = parseInt(b.match(/\d+/)![0], 10)
+      return na - nb
+    })
+
+  for (const path of sheetFiles) {
+    const xml = new TextDecoder().decode(files[path])
+    const doc = parser.parseFromString(xml, "text/xml")
+    const rows = doc.getElementsByTagName("row")
+    const rowTexts: string[] = []
+
+    for (let r = 0; r < rows.length; r++) {
+      const cells = rows[r].getElementsByTagName("c")
+      const cellValues: string[] = []
+
+      for (let c = 0; c < cells.length; c++) {
+        const cell = cells[c]
+        const type = cell.getAttribute("t")
+        const vNode = cell.getElementsByTagName("v")[0]
+        const v = vNode?.textContent ?? ""
+        // type="s" → shared string index; otherwise use raw value
+        cellValues.push(type === "s" ? (sharedStrings[parseInt(v, 10)] ?? v) : v)
+      }
+
+      if (cellValues.some(Boolean)) {
+        rowTexts.push(cellValues.join("\t"))
+      }
+    }
+
+    if (rowTexts.length) {
+      const sheetNum = path.match(/\d+/)![0]
+      sheets.push(`--- Sheet ${sheetNum} ---\n${rowTexts.join("\n")}`)
+    }
+  }
+
+  return sheets.join("\n\n")
+}

package/lib/read-hooks/image/compress.ts

@@ -0,0 +1,36 @@
+/**
+ * lib/read-hooks/image/compress.ts
+ *
+ * Image compression using jimp (pure JS, zero native dependencies, 14k+ stars).
+ * Goal: reduce base64 attachment size to save LLM context tokens.
+ *
+ * Strategy:
+ * - Resize to max 1024px on longest side (preserving aspect ratio)
+ * - Convert to JPEG at 60% quality
+ * - This typically achieves 60-80% size reduction
+ */
+
+import { Jimp } from "jimp"
+
+const MAX_DIMENSION = 1024
+const JPEG_QUALITY = 60
+
+/**
+ * Compress an image buffer.
+ * Returns a JPEG buffer regardless of input format.
+ */
+export async function compressImage(buf: Buffer): Promise<Buffer> {
+  const image = await Jimp.read(buf)
+  const { width, height } = image.bitmap
+
+  // Proportional resize if either dimension exceeds MAX_DIMENSION
+  if (width > MAX_DIMENSION || height > MAX_DIMENSION) {
+    if (width >= height) {
+      image.resize({ w: MAX_DIMENSION })
+    } else {
+      image.resize({ h: MAX_DIMENSION })
+    }
+  }
+
+  return await image.getBuffer("image/jpeg", { quality: JPEG_QUALITY })
+}

package/lib/read-hooks/index.ts

@@ -0,0 +1,12 @@
+/**
+ * lib/read-hooks/index.ts
+ *
+ * Entry point for the read-hooks module.
+ * Exports preRead and postRead for use in plugins/revela.ts hook handlers.
+ *
+ * preRead  → tool.execute.before: redirect binary files (DOCX/PPTX/XLSX) to temp txt
+ * postRead → tool.execute.after:  transform PDF/image attachments before LLM sees them
+ */
+
+export { preRead } from "./pre-read"
+export { postRead } from "./post-read"

package/lib/read-hooks/post-read.ts

@@ -0,0 +1,74 @@
+/**
+ * lib/read-hooks/post-read.ts
+ *
+ * After-hook handler for the OpenCode `read` tool.
+ * Called from `tool.execute.after` in plugin.ts.
+ *
+ * Handles PDF and images — formats where read tool succeeds and returns
+ * a base64 attachment. The after-hook fires after execution but before
+ * the result reaches the LLM, so we can replace the output here.
+ *
+ * PDF strategy:    extract text from base64 → replace output string → remove attachment
+ * Image strategy:  decompress base64 → jimp compress → re-encode → replace attachment
+ *
+ * Note: `output.attachments` is present at runtime despite not being in the
+ * TypeScript type definition for tool.execute.after. Confirmed via source inspection
+ * of packages/opencode/src/session/prompt.ts.
+ */
+
+import { extname, basename } from "path"
+import { extractPdfText } from "./extractors/pdf"
+import { compressImage } from "./image/compress"
+
+const IMAGE_EXTS = new Set([".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif", ".webp", ".gif"])
+
+interface ReadOutput {
+  title: string
+  output: string
+  metadata: any
+  attachments?: Array<{ url: string; mime: string; [k: string]: any }>
+}
+
+/**
+ * Post-process read tool output for PDF and image files.
+ *
+ * @param args   - Read tool args (input.args in after-hook)
+ * @param output - Mutable read tool output (output in after-hook)
+ */
+export async function postRead(
+  args: { filePath: string; [k: string]: any },
+  output: ReadOutput,
+): Promise<void> {
+  if (!output.attachments?.length) return
+
+  const ext = extname(args.filePath).toLowerCase()
+
+  // ── PDF: extract text, drop base64 attachment ───────────────────────────
+  if (ext === ".pdf") {
+    const attachment = output.attachments[0]
+    const base64 = attachment.url.split(",")[1]
+    if (!base64) return
+
+    const buf = Buffer.from(base64, "base64")
+    const text = await extractPdfText(buf)
+
+    output.output = `[Extracted from: ${basename(args.filePath)}]\n\n${text}`
+    output.title = `Extracted text from ${basename(args.filePath)}`
+    output.attachments.length = 0 // Remove base64 — saves significant tokens
+    return
+  }
+
+  // ── Images: compress attachment to reduce token cost ────────────────────
+  if (IMAGE_EXTS.has(ext)) {
+    const attachment = output.attachments[0]
+    const base64 = attachment.url.split(",")[1]
+    if (!base64) return
+
+    const buf = Buffer.from(base64, "base64")
+    const compressed = await compressImage(buf)
+
+    // Replace with compressed JPEG
+    attachment.url = `data:image/jpeg;base64,${compressed.toString("base64")}`
+    attachment.mime = "image/jpeg"
+  }
+}

package/lib/read-hooks/pre-read.ts

@@ -0,0 +1,51 @@
+/**
+ * lib/read-hooks/pre-read.ts
+ *
+ * Before-hook handler for the OpenCode `read` tool.
+ * Called from `tool.execute.before` in plugin.ts.
+ *
+ * Handles DOCX, PPTX, XLSX — formats that cause read tool to throw
+ * Effect.fail("Cannot read binary file"), so the after-hook never fires.
+ *
+ * Strategy: extract text → write temp .txt file → redirect args.filePath.
+ * The read tool then reads the temp file normally. LLM is unaware of the redirect.
+ */
+
+import { readFileSync, writeFileSync } from "fs"
+import { extname, basename, join } from "path"
+import { tmpdir } from "os"
+import { randomUUID } from "crypto"
+import { extractDocx } from "./extractors/docx"
+import { extractPptx } from "./extractors/pptx"
+import { extractXlsx } from "./extractors/xlsx"
+
+// Extension → extractor function mapping
+const HANDLERS: Record<string, (buf: Buffer) => Promise<string>> = {
+  ".docx": extractDocx,
+  ".pptx": extractPptx,
+  ".xlsx": extractXlsx,
+}
+
+/**
+ * Intercept read tool args before execution.
+ * If the file is a supported binary format, extract its text and redirect
+ * args.filePath to a temp .txt file containing the extracted content.
+ *
+ * @param args - Mutable read tool args object (from output.args in before-hook)
+ */
+export async function preRead(args: { filePath: string; [k: string]: any }): Promise<void> {
+  const ext = extname(args.filePath).toLowerCase()
+  const handler = HANDLERS[ext]
+  if (!handler) return // Not a handled format — let read tool proceed normally
+
+  const buf = readFileSync(args.filePath)
+  const text = await handler(buf)
+
+  // Write extracted text to a temp file, prefixed with source info
+  const header = `[Extracted from: ${basename(args.filePath)}]\n\n`
+  const tmpPath = join(tmpdir(), `revela-${randomUUID()}.txt`)
+  writeFileSync(tmpPath, header + text, "utf-8")
+
+  // Redirect read tool to the temp file
+  args.filePath = tmpPath
+}