opencode-manager 0.4.0 → 0.4.2

package/src/cli/commands/tokens.ts

@@ -7,13 +7,7 @@
 
 import { Command, type OptionValues } from "commander"
 import { parseGlobalOptions, type GlobalOptions } from "../index"
-import {
-  computeGlobalTokenSummary,
-  computeProjectTokenSummary,
-  computeSessionTokenSummary,
-  loadProjectRecords,
-  loadSessionRecords,
-} from "../../lib/opencode-data"
+import { createProviderFromGlobalOptions } from "../../lib/opencode-data-provider"
 import { getOutputOptions, printAggregateTokensOutput, printTokensOutput } from "../output"
 import { handleError } from "../errors"
 import { findProjectById, findSessionById } from "../resolvers"
@@ -101,6 +95,16 @@ export function registerTokensCommands(parent: Command): void {
         handleError(error, globalOpts.format)
       }
     })
+
+  tokens.addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  opencode-manager tokens session --session <id> --experimental-sqlite",
+      "  opencode-manager tokens global --db ~/.local/share/opencode/opencode.db",
+    ].join("\n")
+  )
 }
 
 /**
@@ -110,14 +114,17 @@ async function handleTokensSession(
   globalOpts: GlobalOptions,
   sessionOpts: TokensSessionOptions
 ): Promise<void> {
+  // Create provider based on global options (JSONL or SQLite)
+  const provider = createProviderFromGlobalOptions(globalOpts)
+
   // Load all sessions to find the one we want
-  const sessions = await loadSessionRecords({ root: globalOpts.root })
+  const sessions = await provider.loadSessionRecords()
 
   // Find the session by ID
   const session = findSessionById(sessions, sessionOpts.session)
 
   // Compute token summary for the session
-  const summary = await computeSessionTokenSummary(session, globalOpts.root)
+  const summary = await provider.computeSessionTokenSummary(session)
 
   // Output the result
   const outputOpts = getOutputOptions(globalOpts)
@@ -131,20 +138,22 @@ async function handleTokensProject(
   globalOpts: GlobalOptions,
   projectOpts: TokensProjectOptions
 ): Promise<void> {
+  // Create provider based on global options (JSONL or SQLite)
+  const provider = createProviderFromGlobalOptions(globalOpts)
+
   // Load all projects to validate the project exists
-  const projects = await loadProjectRecords({ root: globalOpts.root })
+  const projects = await provider.loadProjectRecords()
 
   // Find the project by ID (throws if not found)
   findProjectById(projects, projectOpts.project)
 
   // Load all sessions to compute token summary
-  const sessions = await loadSessionRecords({ root: globalOpts.root })
+  const sessions = await provider.loadSessionRecords()
 
   // Compute token summary for the project
-  const summary = await computeProjectTokenSummary(
+  const summary = await provider.computeProjectTokenSummary(
     projectOpts.project,
-    sessions,
-    globalOpts.root
+    sessions
   )
 
   // Output the result
@@ -156,11 +165,14 @@ async function handleTokensProject(
  * Handle the tokens global command.
  */
 async function handleTokensGlobal(globalOpts: GlobalOptions): Promise<void> {
+  // Create provider based on global options (JSONL or SQLite)
+  const provider = createProviderFromGlobalOptions(globalOpts)
+
   // Load all sessions to compute global token summary
-  const sessions = await loadSessionRecords({ root: globalOpts.root })
+  const sessions = await provider.loadSessionRecords()
 
   // Compute token summary across all sessions
-  const summary = await computeGlobalTokenSummary(sessions, globalOpts.root)
+  const summary = await provider.computeGlobalTokenSummary(sessions)
 
   // Output the result
   const outputOpts = getOutputOptions(globalOpts)

package/src/cli/index.ts

@@ -51,6 +51,14 @@ export interface GlobalOptions {
   clipboard: boolean
   /** Directory for backup copies before deletion */
   backupDir?: string
+  /** Use SQLite database instead of JSONL files (experimental) */
+  experimentalSqlite: boolean
+  /** Path to SQLite database (implies --experimental-sqlite) */
+  dbPath?: string
+  /** Fail fast on any SQLite error or malformed data */
+  sqliteStrict: boolean
+  /** Wait for SQLite write locks to clear before failing */
+  forceWrite: boolean
 }
 
 /**
@@ -66,6 +74,10 @@ export const DEFAULT_OPTIONS: GlobalOptions = {
   quiet: false,
   clipboard: false,
   backupDir: undefined,
+  experimentalSqlite: false,
+  dbPath: undefined,
+  sqliteStrict: false,
+  forceWrite: false,
 }
 
 /**
@@ -73,11 +85,12 @@ export const DEFAULT_OPTIONS: GlobalOptions = {
  */
 function createProgram(): Command {
   const program = new Command()
+  program.configureHelp({ showGlobalOptions: true })
 
   program
     .name("opencode-manager")
     .description("CLI for managing OpenCode metadata stores")
-    .version("0.4.0")
+    .version("0.4.2")
     // Global options
     .option(
       "-r, --root <path>",
@@ -108,6 +121,25 @@ function createProgram(): Command {
     .option("-q, --quiet", "Suppress non-essential output", DEFAULT_OPTIONS.quiet)
     .option("-c, --clipboard", "Copy output to clipboard", DEFAULT_OPTIONS.clipboard)
     .option("--backup-dir <path>", "Directory for backup copies before deletion")
+    .option(
+      "--experimental-sqlite",
+      "Use SQLite database instead of JSONL files (experimental; schema may change)",
+      DEFAULT_OPTIONS.experimentalSqlite
+    )
+    .option(
+      "--db <path>",
+      "Path to SQLite database (implies --experimental-sqlite). Default: ~/.local/share/opencode/opencode.db"
+    )
+    .option(
+      "--sqlite-strict",
+      "Fail on any SQLite warning or malformed data (no partial results)",
+      DEFAULT_OPTIONS.sqliteStrict
+    )
+    .option(
+      "--force-write",
+      "Wait for SQLite write locks to clear before failing",
+      DEFAULT_OPTIONS.forceWrite
+    )
 
   // Projects subcommand group
   registerProjectsCommands(program)
@@ -132,6 +164,10 @@ function createProgram(): Command {
  * Resolves paths and converts types as needed.
  */
 export function parseGlobalOptions(opts: Record<string, unknown>): GlobalOptions {
+  // --db implies --experimental-sqlite
+  const dbPath = opts.db ? resolve(String(opts.db)) : undefined
+  const experimentalSqlite = Boolean(opts.experimentalSqlite) || dbPath !== undefined
+
   return {
     root: resolve(String(opts.root ?? DEFAULT_OPTIONS.root)),
     format: validateFormat(String(opts.format ?? DEFAULT_OPTIONS.format)),
@@ -142,6 +178,10 @@ export function parseGlobalOptions(opts: Record<string, unknown>): GlobalOptions
     quiet: Boolean(opts.quiet ?? DEFAULT_OPTIONS.quiet),
     clipboard: Boolean(opts.clipboard ?? DEFAULT_OPTIONS.clipboard),
     backupDir: opts.backupDir ? resolve(String(opts.backupDir)) : undefined,
+    experimentalSqlite,
+    dbPath,
+    sqliteStrict: Boolean(opts.sqliteStrict ?? DEFAULT_OPTIONS.sqliteStrict),
+    forceWrite: Boolean(opts.forceWrite ?? DEFAULT_OPTIONS.forceWrite),
   }
 }
 

package/src/cli/resolvers.ts

@@ -3,6 +3,10 @@
  *
  * These helpers provide consistent ID resolution across all CLI commands,
  * supporting both exact matches and flexible matching patterns.
+ *
+ * Resolvers can optionally accept a DataProvider to support both JSONL and
+ * SQLite backends. When no provider is given, they fall back to direct JSONL
+ * loading for backward compatibility.
  */
 
 import {
@@ -13,6 +17,7 @@ import {
   type ProjectRecord,
   type SessionRecord,
 } from "../lib/opencode-data"
+import { type DataProvider } from "../lib/opencode-data-provider"
 import { NotFoundError, projectNotFound, sessionNotFound } from "./errors"
 
 // ========================
@@ -29,6 +34,13 @@ export interface ResolveSessionOptions extends SessionLoadOptions {
    * Defaults to false.
    */
   allowPrefix?: boolean
+
+  /**
+   * Optional data provider for backend-agnostic data loading.
+   * When provided, uses the provider's loadSessionRecords method.
+   * When omitted, falls back to direct JSONL loading for backward compatibility.
+   */
+  provider?: DataProvider
 }
 
 /**
@@ -81,7 +93,7 @@ export function findSessionsByPrefix(
  * Supports exact matching and optional prefix matching.
  *
  * @param sessionId - Session ID or prefix to resolve
- * @param options - Resolution options including root and projectId filters
+ * @param options - Resolution options including root, projectId filters, and optional provider
  * @returns Resolution result with session and metadata
  * @throws NotFoundError if no session matches
  * @throws NotFoundError if prefix matches multiple sessions (ambiguous)
@@ -90,10 +102,13 @@ export async function resolveSessionId(
   sessionId: string,
   options: ResolveSessionOptions = {}
 ): Promise<ResolveSessionResult> {
-  const sessions = await loadSessionRecords({
-    root: options.root,
-    projectId: options.projectId,
-  })
+  // Use provider if available, otherwise fall back to direct JSONL loading
+  const sessions = options.provider
+    ? await options.provider.loadSessionRecords({ projectId: options.projectId })
+    : await loadSessionRecords({
+        root: options.root,
+        projectId: options.projectId,
+      })
 
   // Try exact match first
   const exactMatch = sessions.find((s) => s.sessionId === sessionId)
@@ -146,6 +161,13 @@ export interface ResolveProjectOptions extends LoadOptions {
    * Defaults to false.
    */
   allowPrefix?: boolean
+
+  /**
+   * Optional data provider for backend-agnostic data loading.
+   * When provided, uses the provider's loadProjectRecords method.
+   * When omitted, falls back to direct JSONL loading for backward compatibility.
+   */
+  provider?: DataProvider
 }
 
 /**
@@ -198,7 +220,7 @@ export function findProjectsByPrefix(
  * Supports exact matching and optional prefix matching.
  *
  * @param projectId - Project ID or prefix to resolve
- * @param options - Resolution options including root
+ * @param options - Resolution options including root and optional provider
  * @returns Resolution result with project and metadata
  * @throws NotFoundError if no project matches
  * @throws NotFoundError if prefix matches multiple projects (ambiguous)
@@ -207,9 +229,12 @@ export async function resolveProjectId(
   projectId: string,
   options: ResolveProjectOptions = {}
 ): Promise<ResolveProjectResult> {
-  const projects = await loadProjectRecords({
-    root: options.root,
-  })
+  // Use provider if available, otherwise fall back to direct JSONL loading
+  const projects = options.provider
+    ? await options.provider.loadProjectRecords()
+    : await loadProjectRecords({
+        root: options.root,
+      })
 
   // Try exact match first
   const exactMatch = projects.find((p) => p.projectId === projectId)