token-goat 2.9.13 → 2.9.15

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

@@ -0,0 +1,331 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  Database
+} from "./token-goat-chunk-OSUFN2FV.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/sqlite_query.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+var SQLITE_QUERY_ROW_CAP = 5e3;
+var SQLITE_MAGIC = Buffer.from([83, 81, 76, 105, 116, 101, 32, 102, 111, 114, 109, 97, 116, 32, 51, 0]);
+function readMagicBytes(filePath) {
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const buf = Buffer.alloc(SQLITE_MAGIC.length);
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    return bytesRead === buf.length ? buf : null;
+  } catch {
+    return null;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function isSqliteFile(filePath) {
+  const magic = readMagicBytes(filePath);
+  return magic !== null && magic.equals(SQLITE_MAGIC);
+}
+function openReadonlySqlite(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`file not found: ${displaySafeText(filePath)}`);
+  }
+  if (!isSqliteFile(filePath)) {
+    throw new Error(`not a valid SQLite database (bad file header): ${displaySafeText(filePath)}`);
+  }
+  try {
+    return new Database(filePath, { readonly: true, fileMustExist: true });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`failed to open SQLite database: ${msg}`, { cause: e });
+  }
+}
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function getSqliteSchema(filePath) {
+  const db = openReadonlySqlite(filePath);
+  try {
+    const objects = db.prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table','view') AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' ORDER BY name").all();
+    const tables = objects.map((o) => {
+      const columns = db.prepare(`PRAGMA table_info(${quoteIdent(o.name)})`).all().map(
+        (c) => ({
+          name: c.name,
+          type: c.type || "",
+          notNull: c.notnull === 1,
+          primaryKey: c.pk > 0,
+          defaultValue: c.dflt_value === null || c.dflt_value === void 0 ? null : String(c.dflt_value)
+        })
+      );
+      const indexes = db.prepare(`PRAGMA index_list(${quoteIdent(o.name)})`).all().map(
+        (idx) => {
+          const idxColumns = db.prepare(`PRAGMA index_info(${quoteIdent(idx.name)})`).all().map((c) => c.name);
+          return { name: idx.name, unique: idx.unique === 1, columns: idxColumns };
+        }
+      );
+      const foreignKeys = db.prepare(`PRAGMA foreign_key_list(${quoteIdent(o.name)})`).all().map((fk) => ({ table: fk.table, from: fk.from, to: fk.to }));
+      let rowCount;
+      try {
+        const row = db.prepare(`SELECT COUNT(*) AS c FROM ${quoteIdent(o.name)}`).get();
+        rowCount = row.c;
+      } catch {
+        rowCount = null;
+      }
+      return { name: o.name, kind: o.type === "view" ? "view" : "table", columns, indexes, foreignKeys, rowCount };
+    });
+    return { tables };
+  } finally {
+    db.close();
+  }
+}
+function formatSqliteSchema(result) {
+  if (result.tables.length === 0) return "(no tables or views found)";
+  return result.tables.map((t) => {
+    const lines = [`${t.name}  (${t.kind}${t.rowCount !== null ? `, ${t.rowCount} row${t.rowCount === 1 ? "" : "s"}` : ""})`];
+    for (const c of t.columns) {
+      const flags = [c.primaryKey ? "PK" : null, c.notNull ? "NOT NULL" : null, c.defaultValue !== null ? `DEFAULT ${c.defaultValue}` : null].filter((f) => f !== null).join(" ");
+      lines.push(`  ${displaySafeText(c.name)} ${displaySafeText(c.type || "(untyped)")}${flags ? `  ${flags}` : ""}`);
+    }
+    if (t.indexes.length > 0) {
+      lines.push("  indexes:");
+      for (const idx of t.indexes) {
+        lines.push(`    ${displaySafeText(idx.name)}${idx.unique ? " (unique)" : ""}: ${displaySafeText(idx.columns.join(", "))}`);
+      }
+    }
+    if (t.foreignKeys.length > 0) {
+      lines.push("  foreign keys:");
+      for (const fk of t.foreignKeys) {
+        lines.push(`    ${fk.from} -> ${fk.table}.${fk.to}`);
+      }
+    }
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function getSqliteTables(filePath) {
+  const db = openReadonlySqlite(filePath);
+  try {
+    const objects = db.prepare(
+      // ESCAPE makes every `_` literal; see getSqliteSchema above. Here it costs three tables rather than one, since `%_fts_%` and `%_vec0_%` exist to hide the shadow tables FTS5 and sqlite-vec create beside a virtual table, and unescaped they also hide anything of the shape `my_ftsx_cache`.
+      "SELECT name, type FROM sqlite_master WHERE type IN ('table','view') AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name NOT LIKE '%\\_fts\\_%' ESCAPE '\\' AND name NOT LIKE '%\\_vec0\\_%' ESCAPE '\\' ORDER BY name"
+    ).all();
+    return objects.map((o) => {
+      let columnCount;
+      try {
+        const cols = db.prepare(`PRAGMA table_info(${quoteIdent(o.name)})`).all();
+        columnCount = cols.length;
+      } catch {
+        columnCount = 0;
+      }
+      let rowCount;
+      try {
+        const row = db.prepare(`SELECT COUNT(*) AS c FROM ${quoteIdent(o.name)}`).get();
+        rowCount = row.c;
+      } catch {
+        rowCount = null;
+      }
+      return {
+        name: o.name,
+        kind: o.type === "view" ? "view" : "table",
+        rowCount,
+        columnCount
+      };
+    });
+  } finally {
+    db.close();
+  }
+}
+function formatSqliteTables(tables) {
+  if (tables.length === 0) return "(no tables or views found)";
+  return tables.map((t) => {
+    const parts = [t.kind];
+    if (t.rowCount !== null) {
+      parts.push(`${t.rowCount.toLocaleString()} row${t.rowCount === 1 ? "" : "s"}`);
+    }
+    parts.push(`${t.columnCount} col${t.columnCount === 1 ? "" : "s"}`);
+    return `${displaySafeText(t.name)}  (${parts.join(", ")})`;
+  }).join("\n");
+}
+var FORBIDDEN_KEYWORDS = [
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "DROP",
+  "ALTER",
+  "CREATE",
+  "ATTACH",
+  "DETACH",
+  "TRUNCATE",
+  "VACUUM",
+  "REINDEX",
+  "PRAGMA",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "SAVEPOINT",
+  "RELEASE",
+  "GRANT",
+  "REVOKE"
+];
+function stripSqlLiteralsAndComments(sql) {
+  let out = "";
+  let i = 0;
+  const n = sql.length;
+  while (i < n) {
+    const c = sql[i];
+    if (c === "'" || c === '"' || c === "`") {
+      const quote = c;
+      out += " ";
+      i++;
+      while (i < n) {
+        if (sql[i] === quote) {
+          if (sql[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (c === "[") {
+      out += " ";
+      i++;
+      while (i < n && sql[i] !== "]") i++;
+      if (i < n) i++;
+      continue;
+    }
+    if (c === "-" && sql[i + 1] === "-") {
+      while (i < n && sql[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "/" && sql[i + 1] === "*") {
+      i += 2;
+      while (i < n && !(sql[i] === "*" && sql[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function validateReadOnlySelect(sql) {
+  const stripped = stripSqlLiteralsAndComments(sql);
+  const trimmed = stripped.trim();
+  if (trimmed === "") {
+    throw new Error("empty query");
+  }
+  const withoutTrailingSemicolons = trimmed.replace(/;+\s*$/, "");
+  if (withoutTrailingSemicolons.includes(";")) {
+    throw new Error("multiple statements are not allowed (sqlite-query accepts exactly one read-only SELECT statement)");
+  }
+  const upper = withoutTrailingSemicolons.toUpperCase();
+  if (!/^(SELECT|WITH)\b/.test(upper.trimStart())) {
+    throw new Error("only SELECT statements are allowed (sqlite-query is read-only)");
+  }
+  for (const kw of FORBIDDEN_KEYWORDS) {
+    if (new RegExp(`\\b${kw}\\b`).test(upper)) {
+      throw new Error(`statement contains forbidden keyword '${kw}' (sqlite-query only allows read-only SELECT queries)`);
+    }
+  }
+  if (/\bREPLACE\b(?!\s*\()/.test(upper)) {
+    throw new Error("statement contains forbidden keyword 'REPLACE' (sqlite-query only allows read-only SELECT queries)");
+  }
+}
+function normalizeSqliteScalar(value) {
+  if (typeof value === "bigint") {
+    return Number.isSafeInteger(Number(value)) ? Number(value) : value.toString();
+  }
+  return value;
+}
+function normalizeSqliteRow(row) {
+  const out = {};
+  for (const [k, v] of Object.entries(row)) out[k] = normalizeSqliteScalar(v);
+  return out;
+}
+function runReadOnlySqliteQuery(filePath, sql, opts = {}) {
+  validateReadOnlySelect(sql);
+  const rowCap = opts.rowCap ?? SQLITE_QUERY_ROW_CAP;
+  const db = openReadonlySqlite(filePath);
+  try {
+    let stmt;
+    try {
+      stmt = db.prepare(sql);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`invalid SQL: ${msg}`, { cause: e });
+    }
+    if (!stmt.reader) {
+      throw new Error("only read-only SELECT statements are allowed (sqlite-query is read-only)");
+    }
+    stmt.safeIntegers(true);
+    let columns = [];
+    try {
+      columns = stmt.columns().map((c) => c.name);
+    } catch {
+      columns = [];
+    }
+    const rows = [];
+    let rowCapped = false;
+    for (const row of stmt.iterate()) {
+      if (rows.length >= rowCap) {
+        rowCapped = true;
+        break;
+      }
+      rows.push(normalizeSqliteRow(row));
+    }
+    return { columns, rows, rowCapped };
+  } finally {
+    db.close();
+  }
+}
+function formatSqliteCell(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Uint8Array) return `<blob ${value.length} bytes>`;
+  return String(value);
+}
+function formatSqliteQueryTable(result, opts = {}) {
+  if (result.columns.length === 0 && result.rows.length === 0) return "(no rows)";
+  const lines = [
+    result.columns.map(quoteCsvCellLocal).join(","),
+    ...result.rows.map((r) => result.columns.map((c) => quoteCsvCellLocal(formatSqliteCell(r[c]))).join(","))
+  ];
+  if (opts.headTruncated === true) {
+    lines.push("...(more rows elided; use --head to see more)");
+  }
+  if (result.rowCapped) {
+    lines.push(`...(result truncated at the ${SQLITE_QUERY_ROW_CAP}-row safety cap; narrow the query with WHERE/LIMIT for a complete result)`);
+  }
+  return lines.join("\n");
+}
+function quoteCsvCellLocal(cell) {
+  if (cell.includes(",") || cell.includes('"') || cell.includes("\n") || cell.includes("\r")) {
+    return `"${cell.replace(/"/g, '""')}"`;
+  }
+  return cell;
+}
+
+export {
+  SQLITE_QUERY_ROW_CAP,
+  isSqliteFile,
+  openReadonlySqlite,
+  getSqliteSchema,
+  formatSqliteSchema,
+  getSqliteTables,
+  formatSqliteTables,
+  validateReadOnlySelect,
+  runReadOnlySqliteQuery,
+  formatSqliteQueryTable
+};

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

@@ -0,0 +1,22 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  docxOutline,
+  docxTables,
+  docxText,
+  formatDocxTables
+} from "./token-goat-chunk-5V7DAC7V.mjs";
+import "./token-goat-chunk-MZDIJJ3R.mjs";
+import "./token-goat-chunk-XTQAOTSO.mjs";
+import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  docxOutline,
+  docxTables,
+  docxText,
+  formatDocxTables
+};