binary-collections 2.0.13 → 2.0.14

package/lib/opencode/database.mjs

@@ -0,0 +1,28 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  checkDatabase,
+  deleteAllProjectSessions,
+  deleteAllSessions,
+  deleteSession,
+  deleteSessionById,
+  loadMessages,
+  loadParts,
+  loadProjects,
+  loadSessions,
+  loadTranscript
+} from "../chunk-LACQTD5V.mjs";
+import "../chunk-56BVU63B.mjs";
+import "../chunk-XW5NZAKI.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  checkDatabase,
+  deleteAllProjectSessions,
+  deleteAllSessions,
+  deleteSession,
+  deleteSessionById,
+  loadMessages,
+  loadParts,
+  loadProjects,
+  loadSessions,
+  loadTranscript
+};

package/lib/opencode/database.runner.cjs

@@ -0,0 +1,145 @@
+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 __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
+));
+
+// 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");
+function getSessionFileById(sessionId) {
+  return import_upath.default.join(SESSION_DIFF_DIR, `${sessionId}.json`);
+}
+
+// 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");
+
+// src/opencode/database.runner.ts
+async function _dumpSessionTable() {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    const rows = db.all(
+      `SELECT *
+       FROM session
+       -- WHERE parent_id IS NULL
+       ORDER BY time_updated DESC
+       `
+    );
+    if (rows.length === 0) {
+      console.error(`No session found.`);
+      return;
+    }
+    for (const row of rows) {
+      console.log(`Session id: ${row.id}, session dir: ${getSessionFileById(row.id)}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+_dumpSessionTable().catch(console.error);

package/lib/opencode/database.runner.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/opencode/database.runner.js

@@ -0,0 +1,56 @@
+"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 });
+const database_js_1 = require("./database.js");
+const sqlite_js_1 = require("./sqlite.js");
+const storage_js_1 = require("./storage.js");
+function _checks() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ok = yield (0, database_js_1.checkDatabase)();
+        console.log(`Database check: ${ok ? 'OK' : 'FAILED'}`);
+        const sessions = yield (0, database_js_1.loadSessions)();
+        console.log(`Loaded ${sessions.length} sessions.`);
+        const projects = yield (0, database_js_1.loadProjects)();
+        console.log(`Loaded ${projects.length} projects.`);
+    });
+}
+function _listSessions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessions = yield (0, database_js_1.loadSessions)();
+        console.log('Sessions:');
+        for (const session of sessions) {
+            console.log(`- ${session.id}: ${session.directory} (created: ${new Date(session.time.created).toISOString()}) ${session.title ? `- ${session.title}` : '<no title>'}`);
+        }
+    });
+}
+function _dumpSessionTable() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const db = new sqlite_js_1.SQLite(storage_js_1.DATABASE_PATH);
+        try {
+            const rows = db.all(`SELECT *
+       FROM session
+       -- WHERE parent_id IS NULL
+       ORDER BY time_updated DESC
+       `);
+            if (rows.length === 0) {
+                console.error(`No session found.`);
+                return;
+            }
+            for (const row of rows) {
+                console.log(`Session id: ${row.id}, session dir: ${(0, storage_js_1.getSessionFileById)(row.id)}`);
+            }
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+_dumpSessionTable().catch(console.error);

package/lib/opencode/database.runner.mjs

@@ -0,0 +1,37 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import "../chunk-LACQTD5V.mjs";
+import {
+  SQLite
+} from "../chunk-56BVU63B.mjs";
+import {
+  DATABASE_PATH,
+  getSessionFileById
+} from "../chunk-XW5NZAKI.mjs";
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/database.runner.ts
+init_esm_shims();
+async function _dumpSessionTable() {
+  const db = new SQLite(DATABASE_PATH);
+  try {
+    const rows = db.all(
+      `SELECT *
+       FROM session
+       -- WHERE parent_id IS NULL
+       ORDER BY time_updated DESC
+       `
+    );
+    if (rows.length === 0) {
+      console.error(`No session found.`);
+      return;
+    }
+    for (const row of rows) {
+      console.log(`Session id: ${row.id}, session dir: ${getSessionFileById(row.id)}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+_dumpSessionTable().catch(console.error);

package/lib/opencode/opencode-zen.runner.cjs

@@ -0,0 +1,48 @@
+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 __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
+));
+
+// src/opencode/opencode-zen.runner.mjs
+var import_openai = __toESM(require("openai"), 1);
+var import_axios = __toESM(require("axios"), 1);
+var client = new import_openai.default({
+  apiKey: "sk-9aLZhac0dYGY2v37HTBBAo6glifcRZLUNJmh8NaoRN5VOnPlGQ2kh53mBZY32inV",
+  baseURL: "https://opencode.ai/zen/v1"
+  // OpenCode Zen base URL
+});
+async function callZen(prompt) {
+  const res = await import_axios.default.post(
+    "https://opencode.ai/zen/v1/chat/completions",
+    {
+      model: "deepseek-v4-flash-free",
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 512
+    },
+    {
+      headers: { Authorization: `Bearer ${client.apiKey}` }
+    }
+  );
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  console.log(output);
+}
+callZen("Hello");

package/lib/opencode/opencode-zen.runner.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/opencode/opencode-zen.runner.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/opencode-zen.runner.mjs
+init_esm_shims();
+import OpenAI from "openai";
+import axios from "axios";
+var client = new OpenAI({
+  apiKey: "sk-9aLZhac0dYGY2v37HTBBAo6glifcRZLUNJmh8NaoRN5VOnPlGQ2kh53mBZY32inV",
+  baseURL: "https://opencode.ai/zen/v1"
+  // OpenCode Zen base URL
+});
+async function callZen(prompt) {
+  const res = await axios.post(
+    "https://opencode.ai/zen/v1/chat/completions",
+    {
+      model: "deepseek-v4-flash-free",
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 512
+    },
+    {
+      headers: { Authorization: `Bearer ${client.apiKey}` }
+    }
+  );
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  console.log(output);
+}
+callZen("Hello");

package/lib/opencode/sqlite.cjs

@@ -0,0 +1,114 @@
+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/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  DEFAULT_DB_PATH: () => DEFAULT_DB_PATH,
+  SQLite: () => SQLite
+});
+module.exports = __toCommonJS(sqlite_exports);
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_upath = __toESM(require("upath"), 1);
+var DEFAULT_DB_PATH = import_upath.default.join(process.cwd(), "data", "database", "db.sqlite");
+var SQLite = class {
+  constructor(dbPath = DEFAULT_DB_PATH) {
+    const dir = import_upath.default.dirname(dbPath);
+    if (!import_fs_extra.default.existsSync(dir)) {
+      import_fs_extra.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_extra.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DB_PATH,
+  SQLite
+});

package/lib/opencode/sqlite.d.ts

@@ -0,0 +1,18 @@
+import Database from 'better-sqlite3';
+export type QueryParams = Record<string, any>;
+export type SQLiteDatabase = InstanceType<typeof Database>;
+export declare const DEFAULT_DB_PATH: string;
+export declare class SQLite {
+    private db;
+    constructor(dbPath?: string);
+    migrate(schemaFilePath: string): void;
+    prepare<T = any>(sql: string): T;
+    get<T = any>(sql: string, params?: QueryParams): T | undefined;
+    all<T = any>(sql: string, params?: QueryParams): T[];
+    run(sql: string, params?: QueryParams): Database.RunResult;
+    transaction<T>(fn: () => T): T;
+    upsert(sql: string, params?: QueryParams): Database.RunResult;
+    insertMany(sql: string, rows: QueryParams[]): void;
+    close(): void;
+    raw(): SQLiteDatabase;
+}

package/lib/opencode/sqlite.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLite = exports.DEFAULT_DB_PATH = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const upath_1 = __importDefault(require("upath"));
+exports.DEFAULT_DB_PATH = upath_1.default.join(process.cwd(), 'data', 'database', 'db.sqlite');
+class SQLite {
+    constructor(dbPath = exports.DEFAULT_DB_PATH) {
+        const dir = upath_1.default.dirname(dbPath);
+        if (!fs_extra_1.default.existsSync(dir)) {
+            fs_extra_1.default.mkdirSync(dir, { recursive: true });
+        }
+        this.db = new better_sqlite3_1.default(dbPath);
+        // Performance pragmas (important for SSG workloads)
+        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 = fs_extra_1.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((rows) => {
+            for (const row of rows) {
+                stmt.run(row);
+            }
+        });
+        trx(rows);
+    }
+    // -------------------------
+    // Utility
+    // -------------------------
+    close() {
+        this.db.close();
+    }
+    // Raw access if needed (escape hatch)
+    raw() {
+        return this.db;
+    }
+}
+exports.SQLite = SQLite;

package/lib/opencode/sqlite.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  DEFAULT_DB_PATH,
+  SQLite
+} from "../chunk-56BVU63B.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  DEFAULT_DB_PATH,
+  SQLite
+};