binary-collections 2.0.12 → 2.0.14

package/lib/{chunk-FB2WKVJD.mjs → chunk-KRCPFWIF.mjs}

@@ -1,26 +1,32 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-PAZH45HS.mjs";
 import {
   require_findEnvFiles
 } from "./chunk-H44UWUFY.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
 import {
   __commonJS,
   __require,
   init_esm_shims
 } from "./chunk-QQ4A6DLD.mjs";
 
-// src/clean-github-actions-caches.cjs
+// src/github-workflows/clean-github-actions-caches.cjs
 var require_clean_github_actions_caches = __commonJS({
-  "src/clean-github-actions-caches.cjs"(exports, module) {
+  "src/github-workflows/clean-github-actions-caches.cjs"(exports, module) {
     init_esm_shims();
     var axios = __require("axios");
-    var minimist = __require("minimist");
+    var { getArgs } = require_utils();
+    var { GITHUB_ACCESS_TOKEN: ACCESS_TOKEN } = require_config();
     var { findEnvWithToken } = require_findEnvFiles();
     __require("dotenv").config({
       path: findEnvWithToken(),
       quiet: true,
       overwrite: true
     });
-    var ACCESS_TOKEN = process.env.GITHUB_TOKEN || process.env.ACCESS_TOKEN;
     if (!ACCESS_TOKEN) {
       throw new Error(
         "Access token is not provided. Please set ACCESS_TOKEN or GITHUB_TOKEN in your environment variables."
@@ -43,6 +49,9 @@ Options:
   -r, --repo <repo>    GitHub repository (owner/repo). If omitted, the tool will
                        attempt to infer the repository from the current working
                        directory's git remotes.
+    -p, --prefix-depth <n>
+                         Number of leading cache key segments to use as the
+                         grouping prefix when splitting on /[-_]/. Default: 3.
 
 Environment Variables:
   ACCESS_TOKEN         GitHub access token (preferred)
@@ -59,22 +68,23 @@ Examples:
   clean-github-actions-caches --repo octocat/hello-world
 
   # Run via npx without installing
-  npx -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo owner/repo
+    npx --legacy-peer-deps -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo owner/repo --prefix-depth 3
 
   # Run via yarn dlx
-  yarn dlx binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches
+    yarn dlx binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --prefix-depth 3
 
 Notes:
   - Ensure ACCESS_TOKEN or GITHUB_TOKEN is set and has permissions to manage Actions caches.
   - Intended for repository maintainers with appropriate permissions.
 `);
     }
-    var argv = minimist(process.argv.slice(2), {
+    var argv = getArgs({
       alias: {
         h: "help",
+        p: "prefix-depth",
         r: "repo"
       },
-      string: ["repo"],
+      string: ["prefix-depth", "repo"],
       boolean: ["help"]
     });
     if (argv.help) {
@@ -103,7 +113,53 @@ Notes:
         });
       });
     }
-    function get_caches(GH_REPO) {
+    function normalizePrefixDepth(prefixDepth) {
+      const parsed = Number(prefixDepth);
+      if (!Number.isFinite(parsed) || parsed < 1) {
+        return 3;
+      }
+      return Math.floor(parsed);
+    }
+    function isChecksumSegment(segment) {
+      return /^[a-f0-9]{32,}$/i.test(segment);
+    }
+    function getMeaningfulCacheKeyParts(key) {
+      return String(key).split(/[-_]/).filter(Boolean).filter((segment) => !isChecksumSegment(segment));
+    }
+    function getCachePrefix(key, prefixDepth = 3) {
+      const normalizedDepth = normalizePrefixDepth(prefixDepth);
+      const parts = String(key).split(/[-_]/).filter(Boolean);
+      const meaningfulParts = getMeaningfulCacheKeyParts(key);
+      if (meaningfulParts.length !== parts.length) {
+        if (meaningfulParts.length < normalizedDepth) {
+          return `${meaningfulParts.join("-")}-`;
+        }
+        return meaningfulParts.join("-");
+      }
+      if (parts.length <= normalizedDepth) {
+        return parts.join("-");
+      }
+      return parts.slice(0, normalizedDepth).join("-");
+    }
+    function groupCachesByPrefix(caches, prefixDepth = 3) {
+      return caches.reduce(
+        /**
+         * @param {Record<string, Record<string, any>[]>} acc
+         * @param {Record<string, any>} item
+         * @returns {Record<string, Record<string, any>[]>}
+         */
+        (acc, item) => {
+          const prefix = getCachePrefix(item.key, prefixDepth);
+          if (!acc[prefix]) {
+            acc[prefix] = [];
+          }
+          acc[prefix].push(item);
+          return acc;
+        },
+        {}
+      );
+    }
+    function get_caches(GH_REPO, prefixDepth = 3) {
       const url = `https://api.github.com/repos/${GH_REPO}/actions/caches`;
       return new Promise((resolve, reject) => {
         axios.get(url, {
@@ -113,42 +169,21 @@ Notes:
           }
         }).then((response) => {
           const data = response.data.actions_caches;
-          const getPrefix = (key) => {
-            const split = key.split(/[-_]/);
-            if (split.length === 3) {
-              return `${split[0]}-${split[1]}`;
-            }
-            if (split.length > 3) {
-              return `${split[0]}-${split[1]}-${split[2]}`;
-            }
-            return split[0];
-          };
-          const grouped = data.reduce(
-            /**
-             * @param {Record<string, Record<string, any>[]>} acc
-             * @param {Record<string, any>} item
-             * @returns {Record<string, Record<string, any>[]>}
-             */
-            (acc, item) => {
-              const prefix = getPrefix(item.key);
-              if (!acc[prefix]) {
-                acc[prefix] = [];
-              }
-              acc[prefix].push(item);
-              return acc;
-            },
-            {}
-          );
+          const grouped = groupCachesByPrefix(data, prefixDepth);
           resolve(grouped);
         }).catch((error) => {
-          console.error("Error fetching data:", error);
           reject(error);
         });
       });
     }
     module.exports = {
       deleteGitHubActionsCache,
-      get_caches
+      getCachePrefix,
+      getMeaningfulCacheKeyParts,
+      get_caches,
+      groupCachesByPrefix,
+      isChecksumSegment,
+      normalizePrefixDepth
     };
   }
 });

package/lib/chunk-LACQTD5V.mjs

@@ -0,0 +1,225 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  SQLite
+} from "./chunk-56BVU63B.mjs";
+import {
+  DATABASE_PATH
+} from "./chunk-XW5NZAKI.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/database.ts
+init_esm_shims();
+import fs from "fs-extra";
+import { execSync } from "child_process";
+async function checkDatabase() {
+  if (!fs.existsSync(DATABASE_PATH)) {
+    console.error("No OpenCode database found. Run opencode (v1.2.0+) at least once to create the database.");
+    return false;
+  }
+  try {
+    const db = new SQLite(DATABASE_PATH);
+    try {
+      const rows = db.all("SELECT name FROM sqlite_master WHERE type='table' AND name='session'");
+      if (rows.length === 0) {
+        console.error(
+          "OpenCode database exists but is missing expected tables. Try running opencode to complete the migration."
+        );
+        return false;
+      }
+      return true;
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Could not open OpenCode database: ${error.message}`);
+    } else {
+      console.error("Could not open OpenCode database.");
+    }
+    return false;
+  }
+}
+function toProject(row) {
+  let sandboxes = [];
+  try {
+    sandboxes = JSON.parse(row.sandboxes);
+  } catch {
+  }
+  return {
+    id: row.id,
+    worktree: row.worktree,
+    vcs: row.vcs,
+    name: row.name,
+    sandboxes,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated
+    }
+  };
+}
+function toSession(row) {
+  const session = {
+    id: row.id,
+    slug: row.slug,
+    version: row.version,
+    projectID: row.project_id,
+    directory: row.directory,
+    parentID: row.parent_id ?? void 0,
+    title: row.title,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      compacting: row.time_compacting ?? void 0,
+      archived: row.time_archived ?? void 0
+    }
+  };
+  if (row.summary_files != null) {
+    session.summary = {
+      additions: row.summary_additions ?? 0,
+      deletions: row.summary_deletions ?? 0,
+      files: row.summary_files
+    };
+  }
+  if (row.share_url) {
+    session.share = { url: row.share_url };
+  }
+  return session;
+}
+function toMessage(id, sessionID, dataJson) {
+  const data = JSON.parse(dataJson);
+  return {
+    id,
+    sessionID,
+    role: data.role,
+    time: data.time,
+    parentID: data.parentID,
+    modelID: data.modelID,
+    providerID: data.providerID,
+    agent: data.agent,
+    mode: data.mode,
+    cost: data.cost,
+    tokens: data.tokens,
+    finish: data.finish
+  };
+}
+function toPart(id, messageID, sessionID, dataJson) {
+  const data = JSON.parse(dataJson);
+  return {
+    id,
+    messageID,
+    sessionID,
+    type: data.type,
+    text: data.text,
+    tool: data.tool,
+    state: data.state
+  };
+}
+async function loadProjects() {
+  const rows = query("SELECT id, worktree, vcs, name, time_created, time_updated, sandboxes FROM project");
+  return rows.map(toProject);
+}
+async function loadSessions() {
+  const rows = query(
+    `SELECT id, project_id, parent_id, slug, directory, title, version,
+            share_url, summary_additions, summary_deletions, summary_files,
+            time_created, time_updated, time_compacting, time_archived
+     FROM session
+     WHERE parent_id IS NULL
+     ORDER BY time_updated DESC`
+  );
+  return rows.map(toSession);
+}
+async function loadMessages(sessionID) {
+  const rows = query(
+    `SELECT id, session_id, data FROM message WHERE session_id = '${escapeSql(sessionID)}' ORDER BY id ASC`
+  );
+  return rows.map((row) => toMessage(row.id, row.session_id, row.data));
+}
+async function loadParts(messageID) {
+  const rows = query(
+    `SELECT id, message_id, session_id, data FROM part WHERE message_id = '${escapeSql(messageID)}' ORDER BY id ASC`
+  );
+  return rows.map((row) => toPart(row.id, row.message_id, row.session_id, row.data));
+}
+async function loadTranscript(sessionID) {
+  const sid = escapeSql(sessionID);
+  const rows = query(
+    `SELECT m.id AS message_id, m.data AS message_data,
+            p.id AS part_id, p.message_id AS part_message_id,
+            p.session_id AS part_session_id, p.data AS part_data
+     FROM message m
+     LEFT JOIN part p ON p.message_id = m.id
+     WHERE m.session_id = '${sid}'
+     ORDER BY m.id ASC, p.id ASC`
+  );
+  const entriesMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    let entry = entriesMap.get(row.message_id);
+    if (!entry) {
+      entry = {
+        message: toMessage(row.message_id, sessionID, row.message_data),
+        parts: []
+      };
+      entriesMap.set(row.message_id, entry);
+    }
+    if (row.part_id && row.part_data && row.part_message_id && row.part_session_id) {
+      const part = toPart(row.part_id, row.part_message_id, row.part_session_id, row.part_data);
+      if (part.type === "text" && part.text || part.type === "tool") {
+        entry.parts.push(part);
+      }
+    }
+  }
+  return Array.from(entriesMap.values()).filter((entry) => entry.parts.length > 0);
+}
+function runSql(query2) {
+  const dbPath = DATABASE_PATH;
+  execSync(`sqlite3 "${dbPath}"`, {
+    input: query2,
+    timeout: 1e4
+  });
+}
+async function deleteSession(session) {
+  const sid = escapeSql(session.id);
+  runSql(
+    `WITH RECURSIVE descendants(id) AS (SELECT id FROM session WHERE id = '${sid}' UNION ALL SELECT s.id FROM session s JOIN descendants d ON s.parent_id = d.id) DELETE FROM session WHERE id IN (SELECT id FROM descendants);`
+  );
+}
+async function deleteSessionById(id) {
+  const sid = escapeSql(id);
+  runSql(
+    `WITH RECURSIVE descendants(id) AS (SELECT id FROM session WHERE id = '${sid}' UNION ALL SELECT s.id FROM session s JOIN descendants d ON s.parent_id = d.id) DELETE FROM session WHERE id IN (SELECT id FROM descendants);`
+  );
+}
+async function deleteAllSessions() {
+  runSql(`DELETE FROM part; DELETE FROM message; DELETE FROM session;`);
+}
+async function deleteAllProjectSessions(projectID) {
+  const pid = escapeSql(projectID);
+  runSql(`DELETE FROM session WHERE project_id = '${pid}'; DELETE FROM project WHERE id = '${pid}';`);
+}
+function query(sql) {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    return db.all(sql);
+  } finally {
+    db.close();
+  }
+}
+function escapeSql(value) {
+  return value.replace(/'/g, "''");
+}
+
+export {
+  checkDatabase,
+  loadProjects,
+  loadSessions,
+  loadMessages,
+  loadParts,
+  loadTranscript,
+  deleteSession,
+  deleteSessionById,
+  deleteAllSessions,
+  deleteAllProjectSessions
+};

package/lib/chunk-LVSPEFU2.mjs

@@ -0,0 +1,86 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  getCacheFile,
+  loadCache,
+  saveCache
+} from "./chunk-QD4T255Z.mjs";
+import {
+  buildChecksum,
+  getAllFiles
+} from "./chunk-WSHVPGNM.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/run.js
+init_esm_shims();
+import { spawn } from "child_process";
+async function runChecksum({
+  patterns = [],
+  ignore = [],
+  exec,
+  cwd = process.env.INIT_CWD || process.cwd(),
+  dryRun = false
+}) {
+  if (!patterns.length && !exec) {
+    console.log("No patterns or command provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  if (!exec) {
+    console.log("No command provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  if (!patterns.length) {
+    console.log("No patterns provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  const files = getAllFiles({ patterns, ignore, cwd });
+  const checksum = buildChecksum(files);
+  const cacheFile = getCacheFile({ patterns, ignore, cwd });
+  const cache = loadCache(cacheFile);
+  if ((cache == null ? void 0 : cache.checksum) === checksum) {
+    return {
+      changed: false,
+      cacheFile,
+      files
+    };
+  }
+  if (dryRun) {
+    return {
+      changed: true,
+      cacheFile,
+      files,
+      skipped: true
+    };
+  }
+  await runCommand(exec, cwd);
+  saveCache(cacheFile, {
+    checksum,
+    files,
+    patterns,
+    ignore,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    changed: true,
+    cacheFile,
+    files
+  };
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, {
+      shell: true,
+      stdio: "inherit",
+      cwd
+    });
+    child.on("exit", (code) => {
+      if (code === 0 || code === null) resolve();
+      else reject(new Error(`Command failed: ${code}`));
+    });
+  });
+}
+
+export {
+  runChecksum
+};

package/lib/chunk-MCCMMZSM.mjs

@@ -0,0 +1,60 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/hash.js
+init_esm_shims();
+import fs from "fs-extra";
+import * as glob from "glob";
+import upath from "upath";
+import path from "upath";
+import crypto from "crypto";
+function getAllFiles({ patterns, ignore, cwd }) {
+  const files = /* @__PURE__ */ new Set();
+  const root = cwd || process.cwd();
+  for (const pattern of patterns) {
+    const matched = glob.sync(pattern, {
+      cwd: root,
+      nodir: true,
+      ignore
+    });
+    for (const f of matched) {
+      files.add(upath.normalize(path.resolve(root, f)));
+    }
+  }
+  return [...files].sort();
+}
+function isBinaryFile(filePath, bytesToCheck = 8e3) {
+  const buffer = fs.readFileSync(filePath, { length: bytesToCheck });
+  for (let i = 0; i < buffer.length; i++) {
+    if (buffer[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function hashFile(file) {
+  const isBin = isBinaryFile(file);
+  if (!isBin) {
+    const content = fs.readFileSync(file, { encoding: "utf-8" });
+    const normalized = content.toString().replace(/\s+/g, " ").trim();
+    return crypto.createHash("sha256").update(normalized).digest("hex");
+  } else {
+    const stats = fs.statSync(file);
+    return crypto.createHash("sha256").update(file).update(String(stats.size)).digest("hex");
+  }
+}
+function buildChecksum(files) {
+  const hash = crypto.createHash("sha256");
+  for (const file of files) {
+    hash.update(file);
+    hash.update(hashFile(file));
+  }
+  return hash.digest("hex");
+}
+
+export {
+  getAllFiles,
+  buildChecksum
+};

package/lib/{chunk-2LSRSEXF.mjs → chunk-MGPYPKIE.mjs}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-A3VUZEJK.mjs";
 import {
   require_utils
-} from "./chunk-5RTXZVCW.mjs";
+} from "./chunk-6RK5UCTP.mjs";
 import {
   __commonJS,
   __require,
@@ -18,7 +18,7 @@ var require_user_config = __commonJS({
     var gch = __require("git-command-helper");
     var { runGitCommand, runGitCommandOutput } = require_utils2();
     var { getArgs } = require_utils();
-    __require("dotenv").config({ path: __require("path").join(process.cwd(), ".env"), quiet: true });
+    __require("dotenv").config({ path: __require("upath").join(process.cwd(), ".env"), quiet: true });
     function configureGitUser(cliUser = null, cliEmail = null, options = {}) {
       console.log("\n=== Configuring Git User ===");
       let username, email;