binary-collections 2.0.12 → 2.0.14

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
+};

package/lib/opencode/storage.cjs

@@ -0,0 +1,124 @@
+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/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  AUTH_PATH: () => AUTH_PATH,
+  CACHE_DIR: () => CACHE_DIR,
+  CONFIG_DIR: () => CONFIG_DIR,
+  DATABASE_PATH: () => DATABASE_PATH,
+  LOG_DIR: () => LOG_DIR,
+  OPCODE_DIR: () => OPCODE_DIR,
+  PROJECT_DIR: () => PROJECT_DIR,
+  SESSION_DIFF_DIR: () => SESSION_DIFF_DIR,
+  SESSION_PATH: () => SESSION_PATH,
+  STORAGE_PATH: () => STORAGE_PATH,
+  getOpenCodeAuth: () => getOpenCodeAuth,
+  getSessionFileById: () => getSessionFileById,
+  readJson: () => readJson,
+  saveOpenCodeAuth: () => saveOpenCodeAuth,
+  scanDirs: () => scanDirs,
+  scanJson: () => scanJson
+});
+module.exports = __toCommonJS(storage_exports);
+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");
+async function scanJson(dir) {
+  const results = [];
+  try {
+    const entries = await import_fs_extra.default.readdir(dir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const content = await import_fs_extra.default.readFile(import_upath.default.join(dir, entry), "utf-8");
+      results.push(JSON.parse(content));
+    }
+  } catch {
+  }
+  return results;
+}
+async function scanDirs(dir) {
+  try {
+    const entries = await import_fs_extra.default.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function readJson(filePath) {
+  try {
+    const content = await import_fs_extra.default.readFile(filePath, "utf-8");
+    return (0, import_jsonc_parser.parse)(content);
+  } catch {
+    return null;
+  }
+}
+function getSessionFileById(sessionId) {
+  return import_upath.default.join(SESSION_DIFF_DIR, `${sessionId}.json`);
+}
+function getOpenCodeAuth() {
+  const file = import_upath.default.join(OPCODE_DIR, "auth.json");
+  if (!import_fs_extra.default.existsSync(file)) return null;
+  return readJson(file);
+}
+async function saveOpenCodeAuth(auth) {
+  const file = import_upath.default.join(OPCODE_DIR, "auth.json");
+  await import_fs_extra.default.ensureFile(file);
+  await import_fs_extra.default.writeFile(file, JSON.stringify(auth, null, 2), "utf-8");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_PATH,
+  CACHE_DIR,
+  CONFIG_DIR,
+  DATABASE_PATH,
+  LOG_DIR,
+  OPCODE_DIR,
+  PROJECT_DIR,
+  SESSION_DIFF_DIR,
+  SESSION_PATH,
+  STORAGE_PATH,
+  getOpenCodeAuth,
+  getSessionFileById,
+  readJson,
+  saveOpenCodeAuth,
+  scanDirs,
+  scanJson
+});

package/lib/opencode/storage.d.ts

@@ -0,0 +1,27 @@
+import { OpenCodeAuthData } from './types.js';
+/** Root data directory (`~/.local/share/opencode`). */
+export declare const OPCODE_DIR: string;
+/** Config directory (`~/.config/opencode`). */
+export declare const CONFIG_DIR: string;
+/** Cache directory (`~/.cache/opencode`). */
+export declare const CACHE_DIR: string;
+/** Logs directory. */
+export declare const LOG_DIR: string;
+/** Path to the auth JSON file. */
+export declare const AUTH_PATH: string;
+/** Project storage directory (sessions, messages). */
+export declare const PROJECT_DIR: string;
+/** @deprecated Legacy storage sub-path. Use `OPCODE_DIR` or `PROJECT_DIR` instead. */
+export declare const STORAGE_PATH: string;
+/** @deprecated Legacy session sub-path. Use `PROJECT_DIR` instead. */
+export declare const SESSION_PATH: string;
+/** Session diff directory. */
+export declare const SESSION_DIFF_DIR: string;
+/** Path to the OpenCode database. */
+export declare const DATABASE_PATH: string;
+export declare function scanJson<T>(dir: string): Promise<T[]>;
+export declare function scanDirs(dir: string): Promise<string[]>;
+export declare function readJson<T>(filePath: string): Promise<T | null>;
+export declare function getSessionFileById(sessionId: string): string;
+export declare function getOpenCodeAuth(): Promise<OpenCodeAuthData>;
+export declare function saveOpenCodeAuth(auth: OpenCodeAuthData): Promise<void>;

package/lib/opencode/storage.js

@@ -0,0 +1,101 @@
+"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.DATABASE_PATH = exports.SESSION_DIFF_DIR = exports.SESSION_PATH = exports.STORAGE_PATH = exports.PROJECT_DIR = exports.AUTH_PATH = exports.LOG_DIR = exports.CACHE_DIR = exports.CONFIG_DIR = exports.OPCODE_DIR = void 0;
+exports.scanJson = scanJson;
+exports.scanDirs = scanDirs;
+exports.readJson = readJson;
+exports.getSessionFileById = getSessionFileById;
+exports.getOpenCodeAuth = getOpenCodeAuth;
+exports.saveOpenCodeAuth = saveOpenCodeAuth;
+const upath_1 = __importDefault(require("upath"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const jsonc_parser_1 = require("jsonc-parser");
+/** Root data directory (`~/.local/share/opencode`). */
+exports.OPCODE_DIR = upath_1.default.join(os_1.default.homedir(), '.local/share/opencode');
+/** Config directory (`~/.config/opencode`). */
+exports.CONFIG_DIR = upath_1.default.join(os_1.default.homedir(), '.config/opencode');
+/** Cache directory (`~/.cache/opencode`). */
+exports.CACHE_DIR = upath_1.default.join(os_1.default.homedir(), '.cache/opencode');
+/** Logs directory. */
+exports.LOG_DIR = upath_1.default.join(exports.OPCODE_DIR, 'log');
+/** Path to the auth JSON file. */
+exports.AUTH_PATH = upath_1.default.join(exports.OPCODE_DIR, 'auth.json');
+/** Project storage directory (sessions, messages). */
+exports.PROJECT_DIR = upath_1.default.join(exports.OPCODE_DIR, 'project');
+/** @deprecated Legacy storage sub-path. Use `OPCODE_DIR` or `PROJECT_DIR` instead. */
+exports.STORAGE_PATH = upath_1.default.join(exports.OPCODE_DIR, 'storage');
+/** @deprecated Legacy session sub-path. Use `PROJECT_DIR` instead. */
+exports.SESSION_PATH = upath_1.default.join(exports.STORAGE_PATH, 'session');
+/** Session diff directory. */
+exports.SESSION_DIFF_DIR = upath_1.default.join(exports.STORAGE_PATH, 'session_diff');
+/** Path to the OpenCode database. */
+exports.DATABASE_PATH = upath_1.default.join(exports.OPCODE_DIR, 'opencode.db');
+function scanJson(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = [];
+        try {
+            const entries = yield fs_extra_1.default.readdir(dir);
+            for (const entry of entries) {
+                if (!entry.endsWith('.json'))
+                    continue;
+                const content = yield fs_extra_1.default.readFile(upath_1.default.join(dir, entry), 'utf-8');
+                results.push(JSON.parse(content));
+            }
+        }
+        catch (_a) {
+            // Ignore errors, return what we have
+        }
+        return results;
+    });
+}
+function scanDirs(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const entries = yield fs_extra_1.default.readdir(dir, { withFileTypes: true });
+            return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch (_a) {
+            return [];
+        }
+    });
+}
+function readJson(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const content = yield fs_extra_1.default.readFile(filePath, 'utf-8');
+            return (0, jsonc_parser_1.parse)(content);
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+function getSessionFileById(sessionId) {
+    return upath_1.default.join(exports.SESSION_DIFF_DIR, `${sessionId}.json`);
+}
+function getOpenCodeAuth() {
+    const file = upath_1.default.join(exports.OPCODE_DIR, 'auth.json');
+    if (!fs_extra_1.default.existsSync(file))
+        return null;
+    return readJson(file);
+}
+function saveOpenCodeAuth(auth) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = upath_1.default.join(exports.OPCODE_DIR, 'auth.json');
+        yield fs_extra_1.default.ensureFile(file);
+        yield fs_extra_1.default.writeFile(file, JSON.stringify(auth, null, 2), 'utf-8');
+    });
+}

package/lib/opencode/storage.mjs

@@ -0,0 +1,38 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  AUTH_PATH,
+  CACHE_DIR,
+  CONFIG_DIR,
+  DATABASE_PATH,
+  LOG_DIR,
+  OPCODE_DIR,
+  PROJECT_DIR,
+  SESSION_DIFF_DIR,
+  SESSION_PATH,
+  STORAGE_PATH,
+  getOpenCodeAuth,
+  getSessionFileById,
+  readJson,
+  saveOpenCodeAuth,
+  scanDirs,
+  scanJson
+} from "../chunk-XW5NZAKI.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  AUTH_PATH,
+  CACHE_DIR,
+  CONFIG_DIR,
+  DATABASE_PATH,
+  LOG_DIR,
+  OPCODE_DIR,
+  PROJECT_DIR,
+  SESSION_DIFF_DIR,
+  SESSION_PATH,
+  STORAGE_PATH,
+  getOpenCodeAuth,
+  getSessionFileById,
+  readJson,
+  saveOpenCodeAuth,
+  scanDirs,
+  scanJson
+};

package/lib/opencode/storage.runner.cjs

@@ -0,0 +1,50 @@
+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");
+
+// src/opencode/storage.runner.ts
+console.log(`OPCODE_DIR:       ${OPCODE_DIR}`);
+console.log(`CONFIG_DIR:       ${CONFIG_DIR}`);
+console.log(`CACHE_DIR:        ${CACHE_DIR}`);
+console.log(`LOG_DIR:          ${LOG_DIR}`);
+console.log(`AUTH_PATH:        ${AUTH_PATH}`);
+console.log(`PROJECT_DIR:      ${PROJECT_DIR}`);
+console.log(`STORAGE_PATH:     ${STORAGE_PATH}`);
+console.log(`SESSION_PATH:     ${SESSION_PATH}`);
+console.log(`SESSION_DIFF_DIR: ${SESSION_DIFF_DIR}`);
+console.log(`DATABASE_PATH:    ${DATABASE_PATH}`);

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

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

package/lib/opencode/storage.runner.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_js_1 = require("./storage.js");
+console.log(`OPCODE_DIR:       ${storage_js_1.OPCODE_DIR}`);
+console.log(`CONFIG_DIR:       ${storage_js_1.CONFIG_DIR}`);
+console.log(`CACHE_DIR:        ${storage_js_1.CACHE_DIR}`);
+console.log(`LOG_DIR:          ${storage_js_1.LOG_DIR}`);
+console.log(`AUTH_PATH:        ${storage_js_1.AUTH_PATH}`);
+console.log(`PROJECT_DIR:      ${storage_js_1.PROJECT_DIR}`);
+console.log(`STORAGE_PATH:     ${storage_js_1.STORAGE_PATH}`);
+console.log(`SESSION_PATH:     ${storage_js_1.SESSION_PATH}`);
+console.log(`SESSION_DIFF_DIR: ${storage_js_1.SESSION_DIFF_DIR}`);
+console.log(`DATABASE_PATH:    ${storage_js_1.DATABASE_PATH}`);

package/lib/opencode/storage.runner.mjs

@@ -0,0 +1,29 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  AUTH_PATH,
+  CACHE_DIR,
+  CONFIG_DIR,
+  DATABASE_PATH,
+  LOG_DIR,
+  OPCODE_DIR,
+  PROJECT_DIR,
+  SESSION_DIFF_DIR,
+  SESSION_PATH,
+  STORAGE_PATH
+} from "../chunk-XW5NZAKI.mjs";
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/storage.runner.ts
+init_esm_shims();
+console.log(`OPCODE_DIR:       ${OPCODE_DIR}`);
+console.log(`CONFIG_DIR:       ${CONFIG_DIR}`);
+console.log(`CACHE_DIR:        ${CACHE_DIR}`);
+console.log(`LOG_DIR:          ${LOG_DIR}`);
+console.log(`AUTH_PATH:        ${AUTH_PATH}`);
+console.log(`PROJECT_DIR:      ${PROJECT_DIR}`);
+console.log(`STORAGE_PATH:     ${STORAGE_PATH}`);
+console.log(`SESSION_PATH:     ${SESSION_PATH}`);
+console.log(`SESSION_DIFF_DIR: ${SESSION_DIFF_DIR}`);
+console.log(`DATABASE_PATH:    ${DATABASE_PATH}`);

package/lib/{ps/isWin.cjs → opencode/types.cjs}

@@ -2,10 +2,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 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))
@@ -16,11 +12,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/ps/isWin.js
-var isWin_exports = {};
-__export(isWin_exports, {
-  default: () => isWin_default
-});
-module.exports = __toCommonJS(isWin_exports);
-var isWin = process.platform === "win32";
-var isWin_default = isWin;
+// src/opencode/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);