@locode2/harness 0.1.0-preview.1

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,13 @@
+# Third-party notices
+
+Harness Studio is an independent TypeScript implementation. The following fixed upstream revisions were studied for architecture and interoperability; their source code was not translated into this repository.
+
+| Project | Revision | License | Use in Harness Studio |
+|---|---|---|---|
+| [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness/tree/b150a551b8d465e31e418e1b2eaf5e79bbb7d28e) | `b150a55` | MIT, copyright DeepSeek | Plugin lifecycle, capability and effect-cleanup concepts |
+| [Pi](https://github.com/earendil-works/pi/tree/c49906ec77788625aacbdc53ebca6fbe65bd20f5) | `c49906e` | MIT, copyright Mario Zechner | Provider abstraction and prompt-cache concepts; `@earendil-works/pi-ai` is used as a package dependency |
+| [OpenAI Codex](https://github.com/openai/codex/tree/343074d4207d572809bd8cea15f4be1d09d98e0b) | `343074d` | Apache-2.0, copyright OpenAI | Thread/Turn/Item, approval and event-protocol concepts |
+
+The referenced Codex revision's upstream `NOTICE` identifies OpenAI Codex and also attributes Ratatui (MIT) to Florian Dehau and the Ratatui Developers. Harness Studio does not incorporate the referenced Rust/Ratatui source, but retains this upstream attribution here for clarity.
+
+Redistributions must also retain the licenses and notices of packages resolved by `pnpm-lock.yaml`. This document is informational and does not replace any dependency's license text.

package/apps/host/dist/document-parser-worker.js

@@ -0,0 +1,215 @@
+// apps/host/src/document-parser-worker.ts
+import { parentPort } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import { createCanvas } from "@napi-rs/canvas";
+import ExcelJS from "exceljs";
+import mammoth from "mammoth";
+import { getDocument, OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
+var MAX_TEXT_BYTES = 5 * 1024 * 1024;
+var MAX_PDF_PAGES = 100;
+var MAX_EXCEL_SHEETS = 32;
+var MAX_EXCEL_CELLS = 1e5;
+var MAX_VISUALS = 4;
+var SAFE_EMBEDDED_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+var PDF_STANDARD_FONT_DATA_URL = `${fileURLToPath(new URL(
+  "../../standard_fonts/",
+  import.meta.resolve("pdfjs-dist/legacy/build/pdf.mjs")
+)).replaceAll("\\", "/").replace(/\/+$/u, "")}/`;
+function truncateUtf8(value) {
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.byteLength <= MAX_TEXT_BYTES) return { text: value, truncated: false };
+  let end = MAX_TEXT_BYTES;
+  while (end > 0 && (bytes[end] & 192) === 128) end -= 1;
+  return { text: bytes.subarray(0, end).toString("utf8"), truncated: true };
+}
+function mediaTypeForExtension(extension) {
+  return {
+    png: "image/png",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif"
+  }[extension.toLowerCase()];
+}
+async function parseDocx(data) {
+  const visuals = [];
+  let discoveredVisuals = 0;
+  const options = {
+    externalFileAccess: false,
+    convertImage: mammoth.images.imgElement(async (image) => {
+      discoveredVisuals += 1;
+      if (visuals.length < MAX_VISUALS && SAFE_EMBEDDED_IMAGE_TYPES.has(image.contentType.toLowerCase())) {
+        visuals.push({
+          data: await image.readAsBuffer(),
+          mediaType: image.contentType,
+          label: `Word \u5D4C\u5165\u56FE\u7247 ${discoveredVisuals}`
+        });
+      }
+      return { src: "" };
+    })
+  };
+  const [raw] = await Promise.all([
+    mammoth.extractRawText({ buffer: data }),
+    mammoth.convertToHtml({ buffer: data }, options)
+  ]);
+  const text = truncateUtf8(raw.value.trim());
+  return {
+    text: text.text,
+    textTruncated: text.truncated,
+    visuals,
+    visualsTruncated: discoveredVisuals > visuals.length
+  };
+}
+function excelCellText(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "object") {
+    const record = value;
+    if (typeof record.formula === "string") {
+      const result = record.result === void 0 ? "" : excelCellText(record.result);
+      return `=${record.formula}${result ? ` => ${result}` : ""}`;
+    }
+    if (Array.isArray(record.richText)) {
+      return record.richText.map((part) => typeof part === "object" && part !== null && "text" in part ? String(part.text) : "").join("");
+    }
+    if (typeof record.text === "string") return record.text;
+    if (record.hyperlink !== void 0) return String(record.text ?? record.hyperlink);
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+async function parseXlsx(data) {
+  const workbook = new ExcelJS.Workbook();
+  await workbook.xlsx.load(data, {
+    ignoreNodes: ["dataValidations", "extLst", "headerFooter", "pageMargins", "pageSetup", "printOptions"]
+  });
+  const availableSheets = workbook.worksheets.length;
+  const sheets = workbook.worksheets.slice(0, MAX_EXCEL_SHEETS);
+  const lines = [];
+  let textBytes = 0;
+  let cellCount = 0;
+  let textTruncated = availableSheets > sheets.length;
+  const append = (line) => {
+    const bytes = Buffer.byteLength(`${line}
+`, "utf8");
+    if (textBytes + bytes > MAX_TEXT_BYTES) {
+      textTruncated = true;
+      return false;
+    }
+    lines.push(line);
+    textBytes += bytes;
+    return true;
+  };
+  let stopped = false;
+  for (const sheet of sheets) {
+    if (stopped || !append(`## \u5DE5\u4F5C\u8868\uFF1A${sheet.name}`)) break;
+    sheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
+      if (stopped) return;
+      const cells = [];
+      row.eachCell({ includeEmpty: false }, (cell, columnNumber) => {
+        if (cellCount >= MAX_EXCEL_CELLS) return;
+        const value = excelCellText(cell.value);
+        if (!value) return;
+        cellCount += 1;
+        cells.push(`${sheet.getColumn(columnNumber).letter}${rowNumber}=${value}`);
+      });
+      if (cells.length > 0 && !append(cells.join("	"))) stopped = true;
+      if (cellCount >= MAX_EXCEL_CELLS) {
+        textTruncated = true;
+        stopped = true;
+      }
+    });
+  }
+  const media = workbook.model.media.filter((entry) => entry.type === "image" && entry.buffer?.byteLength > 0);
+  const visuals = media.slice(0, MAX_VISUALS).flatMap((entry, index) => {
+    const mediaType = mediaTypeForExtension(entry.extension);
+    return mediaType ? [{ data: new Uint8Array(entry.buffer), mediaType, label: `Excel \u5D4C\u5165\u56FE\u7247 ${index + 1}` }] : [];
+  });
+  return {
+    text: lines.join("\n"),
+    textTruncated,
+    visuals,
+    visualsTruncated: media.length > visuals.length,
+    sheetCount: availableSheets
+  };
+}
+async function parsePdf(data) {
+  const loadingTask = getDocument({
+    data: new Uint8Array(data),
+    disableAutoFetch: true,
+    disableStream: true,
+    useSystemFonts: false,
+    standardFontDataUrl: PDF_STANDARD_FONT_DATA_URL
+  });
+  const document = await loadingTask.promise;
+  try {
+    const pageCount = Math.min(document.numPages, MAX_PDF_PAGES);
+    const pages = [];
+    for (let pageNumber = 1; pageNumber <= pageCount; pageNumber += 1) {
+      const page = await document.getPage(pageNumber);
+      const [content, operators] = await Promise.all([page.getTextContent(), page.getOperatorList()]);
+      const text2 = content.items.map((item) => "str" in item ? item.str : "").join(" ").replace(/\s+/gu, " ").trim();
+      const hasImage = operators.fnArray.some((fn) => fn === OPS.paintImageXObject || fn === OPS.paintInlineImageXObject || fn === OPS.paintImageMaskXObject);
+      pages.push({ page: pageNumber, text: text2, hasImage });
+      page.cleanup();
+    }
+    const fullText = pages.map((page) => `## \u7B2C ${page.page} \u9875
+${page.text}`).join("\n\n");
+    const text = truncateUtf8(fullText);
+    const selected = [...pages].sort((left, right) => {
+      if (left.page === 1) return -1;
+      if (right.page === 1) return 1;
+      if (left.hasImage !== right.hasImage) return left.hasImage ? -1 : 1;
+      return left.text.length - right.text.length;
+    }).slice(0, MAX_VISUALS).sort((left, right) => left.page - right.page);
+    const visuals = [];
+    for (const selectedPage of selected) {
+      const page = await document.getPage(selectedPage.page);
+      const unscaled = page.getViewport({ scale: 1 });
+      const scale = Math.min(2, 1600 / Math.max(unscaled.width, unscaled.height));
+      const viewport = page.getViewport({ scale });
+      const canvas = createCanvas(Math.ceil(viewport.width), Math.ceil(viewport.height));
+      await page.render({ canvas, viewport }).promise;
+      visuals.push({
+        data: canvas.toBuffer("image/png"),
+        mediaType: "image/png",
+        label: `PDF \u7B2C ${selectedPage.page} \u9875`,
+        page: selectedPage.page
+      });
+      page.cleanup();
+    }
+    return {
+      text: text.text,
+      textTruncated: text.truncated || document.numPages > MAX_PDF_PAGES,
+      visuals,
+      visualsTruncated: pages.length > visuals.length,
+      pageCount: document.numPages
+    };
+  } finally {
+    await loadingTask.destroy();
+  }
+}
+async function parseDocument(input) {
+  const data = Buffer.from(input.data);
+  if (input.format === "docx") return parseDocx(data);
+  if (input.format === "xlsx") return parseXlsx(data);
+  return parsePdf(data);
+}
+if (parentPort) {
+  parentPort.once("message", (input) => {
+    void parseDocument(input).then(
+      (result) => parentPort.postMessage({ ok: true, result }),
+      (error) => parentPort.postMessage({
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      })
+    );
+  });
+}
+export {
+  parseDocument
+};