binary-collections 2.0.13 → 2.0.15

package/lib/opencode/cli/list-projects.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleListProjects = handleListProjects;
+const database_js_1 = require("../database.js");
+function handleListProjects() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const projects = yield (0, database_js_1.loadProjects)();
+        console.log(`Projects (${projects.length}):\n`);
+        const rows = projects.map((p) => ({
+            id: p.id.slice(0, 8),
+            name: p.name || '-',
+            worktree: p.worktree
+        }));
+        const idWidth = Math.max(...rows.map((r) => r.id.length), 2);
+        const nameWidth = Math.max(...rows.map((r) => r.name.length), 4);
+        const sep = '─'.repeat(idWidth + nameWidth + 15);
+        console.log(`  ${'ID'.padEnd(idWidth)}  ${'Name'.padEnd(nameWidth)}  Worktree`);
+        console.log(`  ${sep}`);
+        for (const r of rows) {
+            console.log(`  ${r.id.padEnd(idWidth)}  ${r.name.padEnd(nameWidth)}  ${r.worktree}`);
+        }
+    });
+}

package/lib/opencode/cli/list-projects.mjs

@@ -0,0 +1,11 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  handleListProjects
+} from "../../chunk-UEOWRYAN.mjs";
+import "../../chunk-LACQTD5V.mjs";
+import "../../chunk-56BVU63B.mjs";
+import "../../chunk-XW5NZAKI.mjs";
+import "../../chunk-QQ4A6DLD.mjs";
+export {
+  handleListProjects
+};

package/lib/opencode/cli/list-sessions.cjs

@@ -0,0 +1,215 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/opencode/cli/list-sessions.ts
+var list_sessions_exports = {};
+__export(list_sessions_exports, {
+  handleListSessions: () => handleListSessions
+});
+module.exports = __toCommonJS(list_sessions_exports);
+var import_moment = __toESM(require("moment"), 1);
+
+// src/opencode/storage.ts
+var import_upath = __toESM(require("upath"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_jsonc_parser = require("jsonc-parser");
+var OPCODE_DIR = import_upath.default.join(import_os.default.homedir(), ".local/share/opencode");
+var CONFIG_DIR = import_upath.default.join(import_os.default.homedir(), ".config/opencode");
+var CACHE_DIR = import_upath.default.join(import_os.default.homedir(), ".cache/opencode");
+var LOG_DIR = import_upath.default.join(OPCODE_DIR, "log");
+var AUTH_PATH = import_upath.default.join(OPCODE_DIR, "auth.json");
+var PROJECT_DIR = import_upath.default.join(OPCODE_DIR, "project");
+var STORAGE_PATH = import_upath.default.join(OPCODE_DIR, "storage");
+var SESSION_PATH = import_upath.default.join(STORAGE_PATH, "session");
+var SESSION_DIFF_DIR = import_upath.default.join(STORAGE_PATH, "session_diff");
+var DATABASE_PATH = import_upath.default.join(OPCODE_DIR, "opencode.db");
+
+// src/opencode/sqlite.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_upath2 = __toESM(require("upath"), 1);
+var DEFAULT_DB_PATH = import_upath2.default.join(process.cwd(), "data", "database", "db.sqlite");
+var SQLite = class {
+  constructor(dbPath = DEFAULT_DB_PATH) {
+    const dir = import_upath2.default.dirname(dbPath);
+    if (!import_fs_extra2.default.existsSync(dir)) {
+      import_fs_extra2.default.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("temp_store = MEMORY");
+    this.db.pragma("foreign_keys = ON");
+  }
+  // -------------------------
+  // Migration / schema init
+  // -------------------------
+  migrate(schemaFilePath) {
+    const schema = import_fs_extra2.default.readFileSync(schemaFilePath, "utf-8");
+    this.db.exec(schema);
+  }
+  // -------------------------
+  // Core query helpers
+  // -------------------------
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  get(sql, params = {}) {
+    return this.db.prepare(sql).get(params);
+  }
+  all(sql, params = {}) {
+    return this.db.prepare(sql).all(params);
+  }
+  run(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Transactions
+  // -------------------------
+  transaction(fn) {
+    const trx = this.db.transaction(fn);
+    return trx();
+  }
+  // -------------------------
+  // Upsert helper (very useful for build cache)
+  // -------------------------
+  upsert(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Bulk insert helper
+  // -------------------------
+  insertMany(sql, rows) {
+    const stmt = this.db.prepare(sql);
+    const trx = this.db.transaction((rows2) => {
+      for (const row of rows2) {
+        stmt.run(row);
+      }
+    });
+    trx(rows);
+  }
+  // -------------------------
+  // Utility
+  // -------------------------
+  close() {
+    this.db.close();
+  }
+  // Raw access if needed (escape hatch)
+  raw() {
+    return this.db;
+  }
+};
+
+// src/opencode/database.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_node_child_process = require("child_process");
+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;
+}
+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);
+}
+function query(sql) {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    return db.all(sql);
+  } finally {
+    db.close();
+  }
+}
+
+// src/opencode/cli/list-sessions.ts
+async function handleListSessions() {
+  const sessions = await loadSessions();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const dir = s.directory || "(no directory)";
+    if (!grouped.has(dir)) grouped.set(dir, []);
+    grouped.get(dir).push(s);
+  }
+  console.log(`Sessions (${sessions.length} total, ${grouped.size} directories):
+`);
+  for (const [dir, dirSessions] of grouped) {
+    console.log(`  ${dir}`);
+    const slugWidth = Math.max(...dirSessions.map((s) => s.slug.length), 4);
+    const titleWidth = Math.max(...dirSessions.map((s) => (s.title || "-").length), 5);
+    const dateWidth = Math.max(
+      ...dirSessions.map((s) => (0, import_moment.default)(s.time.created).format("YYYY-MM-DDTHH:mm:ssZ").length),
+      25
+    );
+    const sep = "\u2500".repeat(Math.max(dir.length, slugWidth + titleWidth + dateWidth + 15));
+    console.log(`  ${sep}`);
+    console.log(`    ${"Slug".padEnd(slugWidth)}  ${"Title".padEnd(titleWidth)}  ${"Date".padEnd(dateWidth)}  Version`);
+    const rowSep = "\u2500".repeat(slugWidth + titleWidth + dateWidth + 17);
+    console.log(`    ${rowSep}`);
+    for (const s of dirSessions) {
+      console.log(
+        `    ${s.slug.padEnd(slugWidth)}  ${(s.title || "-").padEnd(titleWidth)}  ${(0, import_moment.default)(s.time.created).format("YYYY-MM-DDTHH:mm:ssZ").padEnd(dateWidth)}  ${s.version}`
+      );
+    }
+    console.log();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleListSessions
+});

package/lib/opencode/cli/list-sessions.d.ts

@@ -0,0 +1 @@
+export declare function handleListSessions(): Promise<void>;

package/lib/opencode/cli/list-sessions.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleListSessions = handleListSessions;
+const moment_1 = __importDefault(require("moment"));
+const database_js_1 = require("../database.js");
+function handleListSessions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessions = yield (0, database_js_1.loadSessions)();
+        const grouped = new Map();
+        for (const s of sessions) {
+            const dir = s.directory || '(no directory)';
+            if (!grouped.has(dir))
+                grouped.set(dir, []);
+            grouped.get(dir).push(s);
+        }
+        console.log(`Sessions (${sessions.length} total, ${grouped.size} directories):\n`);
+        for (const [dir, dirSessions] of grouped) {
+            console.log(`  ${dir}`);
+            const slugWidth = Math.max(...dirSessions.map((s) => s.slug.length), 4);
+            const titleWidth = Math.max(...dirSessions.map((s) => (s.title || '-').length), 5);
+            const dateWidth = Math.max(...dirSessions.map((s) => (0, moment_1.default)(s.time.created).format('YYYY-MM-DDTHH:mm:ssZ').length), 25);
+            const sep = '─'.repeat(Math.max(dir.length, slugWidth + titleWidth + dateWidth + 15));
+            console.log(`  ${sep}`);
+            console.log(`    ${'Slug'.padEnd(slugWidth)}  ${'Title'.padEnd(titleWidth)}  ${'Date'.padEnd(dateWidth)}  Version`);
+            const rowSep = '─'.repeat(slugWidth + titleWidth + dateWidth + 17);
+            console.log(`    ${rowSep}`);
+            for (const s of dirSessions) {
+                console.log(`    ${s.slug.padEnd(slugWidth)}  ${(s.title || '-').padEnd(titleWidth)}  ${(0, moment_1.default)(s.time.created).format('YYYY-MM-DDTHH:mm:ssZ').padEnd(dateWidth)}  ${s.version}`);
+            }
+            console.log();
+        }
+    });
+}

package/lib/opencode/cli/list-sessions.mjs

@@ -0,0 +1,11 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  handleListSessions
+} from "../../chunk-ZB4IQ6VJ.mjs";
+import "../../chunk-LACQTD5V.mjs";
+import "../../chunk-56BVU63B.mjs";
+import "../../chunk-XW5NZAKI.mjs";
+import "../../chunk-QQ4A6DLD.mjs";
+export {
+  handleListSessions
+};

package/lib/opencode/database.cjs

@@ -0,0 +1,349 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/opencode/database.ts
+var database_exports = {};
+__export(database_exports, {
+  checkDatabase: () => checkDatabase,
+  deleteAllProjectSessions: () => deleteAllProjectSessions,
+  deleteAllSessions: () => deleteAllSessions,
+  deleteSession: () => deleteSession,
+  deleteSessionById: () => deleteSessionById,
+  loadMessages: () => loadMessages,
+  loadParts: () => loadParts,
+  loadProjects: () => loadProjects,
+  loadSessions: () => loadSessions,
+  loadTranscript: () => loadTranscript
+});
+module.exports = __toCommonJS(database_exports);
+
+// src/opencode/storage.ts
+var import_upath = __toESM(require("upath"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_jsonc_parser = require("jsonc-parser");
+var OPCODE_DIR = import_upath.default.join(import_os.default.homedir(), ".local/share/opencode");
+var CONFIG_DIR = import_upath.default.join(import_os.default.homedir(), ".config/opencode");
+var CACHE_DIR = import_upath.default.join(import_os.default.homedir(), ".cache/opencode");
+var LOG_DIR = import_upath.default.join(OPCODE_DIR, "log");
+var AUTH_PATH = import_upath.default.join(OPCODE_DIR, "auth.json");
+var PROJECT_DIR = import_upath.default.join(OPCODE_DIR, "project");
+var STORAGE_PATH = import_upath.default.join(OPCODE_DIR, "storage");
+var SESSION_PATH = import_upath.default.join(STORAGE_PATH, "session");
+var SESSION_DIFF_DIR = import_upath.default.join(STORAGE_PATH, "session_diff");
+var DATABASE_PATH = import_upath.default.join(OPCODE_DIR, "opencode.db");
+
+// src/opencode/sqlite.ts
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
+var import_upath2 = __toESM(require("upath"), 1);
+var DEFAULT_DB_PATH = import_upath2.default.join(process.cwd(), "data", "database", "db.sqlite");
+var SQLite = class {
+  constructor(dbPath = DEFAULT_DB_PATH) {
+    const dir = import_upath2.default.dirname(dbPath);
+    if (!import_fs_extra2.default.existsSync(dir)) {
+      import_fs_extra2.default.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("temp_store = MEMORY");
+    this.db.pragma("foreign_keys = ON");
+  }
+  // -------------------------
+  // Migration / schema init
+  // -------------------------
+  migrate(schemaFilePath) {
+    const schema = import_fs_extra2.default.readFileSync(schemaFilePath, "utf-8");
+    this.db.exec(schema);
+  }
+  // -------------------------
+  // Core query helpers
+  // -------------------------
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  get(sql, params = {}) {
+    return this.db.prepare(sql).get(params);
+  }
+  all(sql, params = {}) {
+    return this.db.prepare(sql).all(params);
+  }
+  run(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Transactions
+  // -------------------------
+  transaction(fn) {
+    const trx = this.db.transaction(fn);
+    return trx();
+  }
+  // -------------------------
+  // Upsert helper (very useful for build cache)
+  // -------------------------
+  upsert(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Bulk insert helper
+  // -------------------------
+  insertMany(sql, rows) {
+    const stmt = this.db.prepare(sql);
+    const trx = this.db.transaction((rows2) => {
+      for (const row of rows2) {
+        stmt.run(row);
+      }
+    });
+    trx(rows);
+  }
+  // -------------------------
+  // Utility
+  // -------------------------
+  close() {
+    this.db.close();
+  }
+  // Raw access if needed (escape hatch)
+  raw() {
+    return this.db;
+  }
+};
+
+// src/opencode/database.ts
+var import_fs_extra3 = __toESM(require("fs-extra"), 1);
+var import_node_child_process = require("child_process");
+async function checkDatabase() {
+  if (!import_fs_extra3.default.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;
+  (0, import_node_child_process.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, "''");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkDatabase,
+  deleteAllProjectSessions,
+  deleteAllSessions,
+  deleteSession,
+  deleteSessionById,
+  loadMessages,
+  loadParts,
+  loadProjects,
+  loadSessions,
+  loadTranscript
+});