token-goat 2.9.13 → 2.9.14

package/dist/{token-goat-chunk-2WC4ZUXN.mjs → token-goat-chunk-3XQPEJMV.mjs}

@@ -2,7 +2,7 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   detectHarness
-} from "./token-goat-chunk-UMXJN7DI.mjs";
+} from "./token-goat-chunk-SAQ5PG4L.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";

package/dist/token-goat-chunk-4SDX3QP3.mjs

@@ -0,0 +1,122 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  NotAnOfficeDocumentError,
+  collectElements,
+  collectTextRuns,
+  decodeZipEntry,
+  ooxmlPartBudget,
+  parseOoxmlPart,
+  readOoxmlZip
+} from "./token-goat-chunk-YHGTGG6K.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-AMYCQJX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/docx_extract.ts
+init_define_import_meta_env();
+function paragraphStyleVal(p) {
+  return p["w:pPr"]?.["w:pStyle"]?.["@_w:val"];
+}
+function headingLevel(styleVal) {
+  if (styleVal === void 0) return null;
+  if (/^title$/i.test(styleVal)) return 1;
+  const m = /^heading\s*(\d)$/i.exec(styleVal);
+  return m?.[1] !== void 0 ? parseInt(m[1], 10) : null;
+}
+async function loadDocumentBody(filePath) {
+  const entries = await readOoxmlZip(filePath, ".docx");
+  const xml = decodeZipEntry(entries, "word/document.xml", ooxmlPartBudget());
+  if (xml === null) throw new NotAnOfficeDocumentError(`no word/document.xml found in ${filePath} (not a valid .docx?)`);
+  return parseOoxmlPart(xml);
+}
+async function docxOutline(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const paragraphs = collectElements(parsed, "w:p");
+  const out = [];
+  for (const p of paragraphs) {
+    const level = headingLevel(paragraphStyleVal(p));
+    if (level === null) continue;
+    const text = collectTextRuns(p, "w:t").join("").trim();
+    if (text.length > 0) out.push({ level, text });
+  }
+  return out;
+}
+async function docxText(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const paragraphs = collectElements(parsed, "w:p");
+  const lines = paragraphs.map((p) => collectTextRuns(p, "w:t").join("")).filter((t) => t.trim().length > 0);
+  return lines.join("\n\n");
+}
+async function docxTables(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const tbls = collectElements(parsed, "w:tbl");
+  const out = [];
+  for (let i = 0; i < tbls.length; i++) {
+    const tbl = tbls[i];
+    const trElements = collectElements(tbl, "w:tr");
+    const rows = [];
+    let maxCols = 0;
+    for (const tr of trElements) {
+      const tcElements = collectElements(tr, "w:tc");
+      const rowCells = [];
+      for (const tc of tcElements) {
+        const cellText = collectTextRuns(tc, "w:t").join("").replace(/\r?\n/g, " ").trim();
+        rowCells.push(cellText);
+      }
+      if (rowCells.length > maxCols) maxCols = rowCells.length;
+      rows.push(rowCells);
+    }
+    if (rows.length > 0) {
+      out.push({
+        tableIndex: i + 1,
+        rowCount: rows.length,
+        colCount: maxCols,
+        rows
+      });
+    }
+  }
+  return out;
+}
+function formatDocxTables(tables, opts) {
+  if (tables.length === 0) return "no tables found in document";
+  const selected = opts?.tableIndex !== void 0 ? tables.filter((t) => t.tableIndex === opts.tableIndex) : tables;
+  if (selected.length === 0) {
+    return `table ${opts?.tableIndex} not found (document has ${tables.length} table${tables.length === 1 ? "" : "s"})`;
+  }
+  const sections = [];
+  for (const table of selected) {
+    const lines = [
+      `Table ${table.tableIndex} (${table.rowCount} row${table.rowCount === 1 ? "" : "s"} x ${table.colCount} col${table.colCount === 1 ? "" : "s"}):`
+    ];
+    if (table.rows.length === 0) {
+      lines.push("  (empty)");
+      sections.push(lines.join("\n"));
+      continue;
+    }
+    const header = table.rows[0];
+    const padCols = Math.max(table.colCount, 1);
+    const paddedHeader = [...header];
+    while (paddedHeader.length < padCols) paddedHeader.push("");
+    lines.push("| " + paddedHeader.map((c) => displaySafeText(c.replace(/\|/g, "\\|"))).join(" | ") + " |");
+    lines.push("| " + Array.from({ length: padCols }, () => "---").join(" | ") + " |");
+    for (let r = 1; r < table.rows.length; r++) {
+      const row = table.rows[r];
+      const paddedRow = [...row];
+      while (paddedRow.length < padCols) paddedRow.push("");
+      lines.push("| " + paddedRow.map((c) => displaySafeText(c.replace(/\|/g, "\\|"))).join(" | ") + " |");
+    }
+    sections.push(lines.join("\n"));
+  }
+  return sections.join("\n\n");
+}
+
+export {
+  docxOutline,
+  docxText,
+  docxTables,
+  formatDocxTables
+};

package/dist/token-goat-chunk-7OGKZ7AP.mjs

@@ -0,0 +1,142 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  loadConfig
+} from "./token-goat-chunk-SAQ5PG4L.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  VERSION,
+  displaySafeJson
+} from "./token-goat-chunk-AMYCQJX4.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_upgrade.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+async function fetchLatestVersion(timeoutMs = 3500) {
+  if (loadConfig().network.offline) {
+    return null;
+  }
+  return new Promise((resolve) => {
+    const req = https.get(
+      "https://registry.npmjs.org/token-goat/latest",
+      {
+        headers: { "User-Agent": `token-goat/${VERSION} (node/${process.version})` },
+        timeout: timeoutMs
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          data += chunk;
+          if (data.length > 32768) {
+            req.destroy();
+            resolve(null);
+          }
+        });
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            resolve(typeof parsed.version === "string" ? parsed.version : null);
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+function compareSemver(a, b) {
+  const pa = a.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  const pb = b.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na > nb) return 1;
+    if (na < nb) return -1;
+  }
+  return 0;
+}
+async function checkUpdateStatus(timeoutMs = 3500) {
+  const latest = await fetchLatestVersion(timeoutMs);
+  if (!latest) {
+    return {
+      current: VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: "Could not reach npm registry (offline or request timed out)"
+    };
+  }
+  const updateAvailable = compareSemver(latest, VERSION) > 0;
+  return {
+    current: VERSION,
+    latest,
+    updateAvailable
+  };
+}
+async function cmdUpgrade(opts = {}, onSyncHooks) {
+  const status = await checkUpdateStatus();
+  if (opts.check) {
+    if (opts.json) {
+      console.log(displaySafeJson(status, 2));
+      return;
+    }
+    if (status.error) {
+      console.log(`Current version: v${status.current}`);
+      console.log(`[!] ${status.error}`);
+      return;
+    }
+    if (status.updateAvailable && status.latest) {
+      console.log(`Update available: v${status.current} -> v${status.latest}`);
+      console.log(`Run 'token-goat upgrade' to update.`);
+    } else {
+      console.log(`token-goat is up to date (v${status.current})`);
+    }
+    return;
+  }
+  const isLocalGitRepo = fs.existsSync(path.join(process.cwd(), ".git")) && fs.existsSync(path.join(process.cwd(), "esbuild.config.mjs"));
+  if (isLocalGitRepo) {
+    console.log(`Detected local token-goat development repository.`);
+    console.log(`To update your local build, run:`);
+    console.log(`  git pull && npm run build && token-goat install`);
+    return;
+  }
+  console.log(`Upgrading token-goat to latest...`);
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  const npmRes = spawnSync(npmCmd, ["install", "-g", "token-goat@latest"], {
+    stdio: "inherit"
+  });
+  if (npmRes.status !== 0) {
+    console.error(`npm install failed with exit code ${npmRes.status ?? 1}.`);
+    process.exit(npmRes.status ?? 1);
+  }
+  console.log(`Syncing token-goat hooks and integration manifests...`);
+  if (onSyncHooks) {
+    await onSyncHooks();
+  }
+  console.log(`[\u2713] token-goat successfully updated.`);
+}
+export {
+  checkUpdateStatus,
+  cmdUpgrade,
+  compareSemver,
+  fetchLatestVersion
+};

package/dist/token-goat-chunk-AH6QILZM.mjs

@@ -0,0 +1,26 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/lazy_module.ts
+init_define_import_meta_env();
+function createLazyModuleLoader(load, errorLabel) {
+  let cache;
+  return async () => {
+    if (cache !== void 0) return cache;
+    try {
+      cache = await load();
+    } catch (err) {
+      process.stderr.write(`token-goat: ${errorLabel}: ${String(err)}
+`);
+      cache = null;
+    }
+    return cache;
+  };
+}
+
+export {
+  createLazyModuleLoader
+};