opencode-manager 0.3.1 → 0.4.1

package/src/cli/backup.ts

@@ -0,0 +1,324 @@
+/**
+ * CLI backup utilities module.
+ *
+ * Provides helpers for backing up files and directories before
+ * destructive operations like delete.
+ */
+
+import { promises as fs } from "node:fs"
+import { basename, dirname, join, relative, resolve } from "node:path"
+import { FileOperationError } from "./errors"
+
+// ========================
+// Types
+// ========================
+
+/**
+ * Options for backup operations.
+ */
+export interface BackupOptions {
+  /** Base directory for backups. Files are copied here with structure preserved. */
+  backupDir: string
+  /** Optional prefix for backup directory name (defaults to timestamp). */
+  prefix?: string
+  /** Whether to preserve the original directory structure relative to a root. */
+  preserveStructure?: boolean
+  /** Root directory for preserving structure (paths are relative to this). */
+  structureRoot?: string
+}
+
+/**
+ * Result of a backup operation.
+ */
+export interface BackupResult {
+  /** Source paths that were backed up. */
+  sources: string[]
+  /** Destination paths where backups were created. */
+  destinations: string[]
+  /** The backup directory used (may include timestamp subdirectory). */
+  backupDir: string
+  /** Any paths that failed to backup. */
+  failed: Array<{ path: string; error: string }>
+}
+
+// ========================
+// Helpers
+// ========================
+
+/**
+ * Generate a timestamp string for backup directory names.
+ *
+ * @returns ISO-like timestamp without colons (filesystem safe)
+ */
+export function generateBackupTimestamp(): string {
+  const now = new Date()
+  // Format: YYYY-MM-DD_HH-MM-SS
+  const year = now.getFullYear()
+  const month = String(now.getMonth() + 1).padStart(2, "0")
+  const day = String(now.getDate()).padStart(2, "0")
+  const hours = String(now.getHours()).padStart(2, "0")
+  const minutes = String(now.getMinutes()).padStart(2, "0")
+  const seconds = String(now.getSeconds()).padStart(2, "0")
+  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`
+}
+
+/**
+ * Ensure a directory exists, creating it if necessary.
+ *
+ * @param dir - Directory path to ensure
+ */
+async function ensureDir(dir: string): Promise<void> {
+  await fs.mkdir(dir, { recursive: true })
+}
+
+/**
+ * Check if a path exists.
+ *
+ * @param path - Path to check
+ * @returns true if exists, false otherwise
+ */
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await fs.access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if a path is a directory.
+ *
+ * @param path - Path to check
+ * @returns true if directory, false otherwise
+ */
+async function isDirectory(path: string): Promise<boolean> {
+  try {
+    const stat = await fs.stat(path)
+    return stat.isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Recursively copy a directory.
+ *
+ * @param src - Source directory
+ * @param dest - Destination directory
+ */
+async function copyDir(src: string, dest: string): Promise<void> {
+  await ensureDir(dest)
+  const entries = await fs.readdir(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name)
+    const destPath = join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath)
+    } else {
+      await fs.copyFile(srcPath, destPath)
+    }
+  }
+}
+
+/**
+ * Copy a file or directory to a destination.
+ *
+ * @param src - Source path (file or directory)
+ * @param dest - Destination path
+ */
+async function copyPath(src: string, dest: string): Promise<void> {
+  if (await isDirectory(src)) {
+    await copyDir(src, dest)
+  } else {
+    // Ensure parent directory exists
+    await ensureDir(dirname(dest))
+    await fs.copyFile(src, dest)
+  }
+}
+
+// ========================
+// Main Backup Functions
+// ========================
+
+/**
+ * Copy files to a backup directory before deletion.
+ *
+ * Creates a timestamped subdirectory within backupDir to store the backups.
+ * Preserves directory structure relative to structureRoot if specified.
+ *
+ * @param paths - Array of file/directory paths to backup
+ * @param options - Backup options
+ * @returns BackupResult with details of the operation
+ *
+ * @example
+ * ```ts
+ * // Simple backup
+ * const result = await copyToBackupDir(
+ *   ["/path/to/project.json", "/path/to/session/data"],
+ *   { backupDir: "/backups" }
+ * )
+ * // Files are copied to /backups/2024-01-15_12-30-45/...
+ *
+ * // Preserve structure
+ * const result = await copyToBackupDir(
+ *   ["/data/storage/project/abc.json"],
+ *   {
+ *     backupDir: "/backups",
+ *     preserveStructure: true,
+ *     structureRoot: "/data"
+ *   }
+ * )
+ * // File is copied to /backups/2024-01-15_12-30-45/storage/project/abc.json
+ * ```
+ */
+export async function copyToBackupDir(
+  paths: string[],
+  options: BackupOptions
+): Promise<BackupResult> {
+  const { backupDir, prefix, preserveStructure, structureRoot } = options
+
+  // Validate backup directory
+  const resolvedBackupDir = resolve(backupDir)
+
+  // Create timestamped subdirectory
+  const timestamp = generateBackupTimestamp()
+  const backupSubdir = prefix
+    ? `${prefix}_${timestamp}`
+    : timestamp
+  const targetBackupDir = join(resolvedBackupDir, backupSubdir)
+
+  const result: BackupResult = {
+    sources: [],
+    destinations: [],
+    backupDir: targetBackupDir,
+    failed: [],
+  }
+
+  // If no paths, return early
+  if (paths.length === 0) {
+    return result
+  }
+
+  // Ensure backup directory exists
+  try {
+    await ensureDir(targetBackupDir)
+  } catch (error) {
+    throw new FileOperationError(
+      `Failed to create backup directory: ${targetBackupDir}`,
+      "backup"
+    )
+  }
+
+  // Copy each path
+  for (const srcPath of paths) {
+    const resolvedSrc = resolve(srcPath)
+
+    // Check if source exists
+    if (!(await pathExists(resolvedSrc))) {
+      result.failed.push({
+        path: resolvedSrc,
+        error: "Source path does not exist",
+      })
+      continue
+    }
+
+    // Determine destination path
+    let destPath: string
+    if (preserveStructure && structureRoot) {
+      // Preserve directory structure relative to root
+      const relativePath = relative(resolve(structureRoot), resolvedSrc)
+      if (relativePath.startsWith("..")) {
+        // Path is outside structureRoot, use basename
+        destPath = join(targetBackupDir, basename(resolvedSrc))
+      } else {
+        destPath = join(targetBackupDir, relativePath)
+      }
+    } else {
+      // Just use the basename
+      destPath = join(targetBackupDir, basename(resolvedSrc))
+    }
+
+    // Copy the file/directory
+    try {
+      await copyPath(resolvedSrc, destPath)
+      result.sources.push(resolvedSrc)
+      result.destinations.push(destPath)
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      result.failed.push({
+        path: resolvedSrc,
+        error: errorMessage,
+      })
+    }
+  }
+
+  return result
+}
+
+/**
+ * Get the paths that would be backed up (for dry-run display).
+ *
+ * @param paths - Source paths to backup
+ * @param options - Backup options
+ * @returns Object with source and computed destination paths
+ */
+export function previewBackupPaths(
+  paths: string[],
+  options: BackupOptions
+): { sources: string[]; destinations: string[]; backupDir: string } {
+  const { backupDir, prefix, preserveStructure, structureRoot } = options
+
+  const resolvedBackupDir = resolve(backupDir)
+  const timestamp = generateBackupTimestamp()
+  const backupSubdir = prefix ? `${prefix}_${timestamp}` : timestamp
+  const targetBackupDir = join(resolvedBackupDir, backupSubdir)
+
+  const sources: string[] = []
+  const destinations: string[] = []
+
+  for (const srcPath of paths) {
+    const resolvedSrc = resolve(srcPath)
+    sources.push(resolvedSrc)
+
+    let destPath: string
+    if (preserveStructure && structureRoot) {
+      const relativePath = relative(resolve(structureRoot), resolvedSrc)
+      if (relativePath.startsWith("..")) {
+        destPath = join(targetBackupDir, basename(resolvedSrc))
+      } else {
+        destPath = join(targetBackupDir, relativePath)
+      }
+    } else {
+      destPath = join(targetBackupDir, basename(resolvedSrc))
+    }
+    destinations.push(destPath)
+  }
+
+  return { sources, destinations, backupDir: targetBackupDir }
+}
+
+/**
+ * Format backup result for display.
+ *
+ * @param result - Backup result to format
+ * @returns Human-readable summary string
+ */
+export function formatBackupResult(result: BackupResult): string {
+  const lines: string[] = []
+
+  if (result.sources.length > 0) {
+    lines.push(`Backed up ${result.sources.length} item(s) to: ${result.backupDir}`)
+  }
+
+  if (result.failed.length > 0) {
+    lines.push(`Failed to backup ${result.failed.length} item(s):`)
+    for (const { path, error } of result.failed) {
+      lines.push(`  ${path}: ${error}`)
+    }
+  }
+
+  return lines.join("\n")
+}

package/src/cli/commands/chat.ts

@@ -0,0 +1,336 @@
+/**
+ * Chat CLI subcommands.
+ *
+ * Provides commands for listing, showing, and searching chat messages
+ * across OpenCode sessions.
+ */
+
+import { Command, type OptionValues } from "commander"
+import { parseGlobalOptions, type GlobalOptions } from "../index"
+import { type ChatMessage, type ChatSearchResult } from "../../lib/opencode-data"
+import { createProviderFromGlobalOptions } from "../../lib/opencode-data-provider"
+import { copyToClipboard } from "../../lib/clipboard"
+import { resolveSessionId } from "../resolvers"
+import { withErrorHandling, UsageError, NotFoundError } from "../errors"
+import {
+  getOutputOptions,
+  printChatOutput,
+  printChatMessageOutput,
+  printChatSearchOutput,
+  type IndexedChatMessage,
+  type IndexedChatSearchResult,
+  type OutputFormat,
+} from "../output"
+
+/**
+ * Collect all options from a command and its ancestors.
+ * Commander stores global options on the root program, not on subcommands.
+ */
+function collectOptions(cmd: Command): OptionValues {
+  const opts: OptionValues = {}
+  let current: Command | null = cmd
+  while (current) {
+    Object.assign(opts, current.opts())
+    current = current.parent
+  }
+  return opts
+}
+
+/**
+ * Options specific to the chat list command.
+ */
+export interface ChatListOptions {
+  /** Session ID to list messages from */
+  session: string
+  /** Include message parts in output */
+  includeParts: boolean
+}
+
+/**
+ * Options specific to the chat show command.
+ */
+export interface ChatShowOptions {
+  /** Session ID containing the message */
+  session: string
+  /** Message ID to show */
+  message?: string
+  /** Message index (1-based) to show */
+  index?: number
+  /** Copy message content to clipboard */
+  clipboard?: boolean
+}
+
+/**
+ * Options specific to the chat search command.
+ */
+export interface ChatSearchOptions {
+  /** Search query */
+  query: string
+  /** Filter by project ID */
+  project?: string
+}
+
+/**
+ * Register chat subcommands on the given parent command.
+ */
+export function registerChatCommands(parent: Command): void {
+  const chat = parent
+    .command("chat")
+    .description("View and search chat messages")
+
+  chat
+    .command("list")
+    .description("List messages in a session")
+    .requiredOption("--session <sessionId>", "Session ID to list messages from")
+    .option("--include-parts", "Include message parts in output", false)
+    .action(async function (this: Command) {
+      const globalOpts = parseGlobalOptions(collectOptions(this))
+      const cmdOpts = this.opts()
+      const listOpts: ChatListOptions = {
+        session: String(cmdOpts.session),
+        includeParts: Boolean(cmdOpts.includeParts),
+      }
+      await withErrorHandling(handleChatList, globalOpts.format)(
+        globalOpts,
+        listOpts
+      )
+    })
+
+  chat
+    .command("show")
+    .description("Show a specific message")
+    .requiredOption("--session <sessionId>", "Session ID containing the message")
+    .option("-m, --message <messageId>", "Message ID to show")
+    .option("-i, --index <number>", "Message index (1-based) to show")
+    .action(async function (this: Command) {
+      const allOpts = collectOptions(this)
+      const globalOpts = parseGlobalOptions(allOpts)
+      const cmdOpts = this.opts()
+      const showOpts: ChatShowOptions = {
+        session: String(cmdOpts.session),
+        message: cmdOpts.message as string | undefined,
+        index: cmdOpts.index ? parseInt(String(cmdOpts.index), 10) : undefined,
+        // Use global --clipboard option since it's defined at root level
+        clipboard: globalOpts.clipboard,
+      }
+      await withErrorHandling(handleChatShow, globalOpts.format)(
+        globalOpts,
+        showOpts
+      )
+    })
+
+  chat
+    .command("search")
+    .description("Search chat content across sessions")
+    .requiredOption("-q, --query <query>", "Search query")
+    .option("-p, --project <projectId>", "Filter by project ID")
+    .action(async function (this: Command) {
+      const globalOpts = parseGlobalOptions(collectOptions(this))
+      const cmdOpts = this.opts()
+      const searchOpts: ChatSearchOptions = {
+        query: String(cmdOpts.query),
+        project: cmdOpts.project as string | undefined,
+      }
+      await withErrorHandling(handleChatSearch, globalOpts.format)(
+        globalOpts,
+        searchOpts
+      )
+    })
+
+  chat.addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  opencode-manager chat list --session <id> --experimental-sqlite",
+      "  opencode-manager chat list --session <id> --db ~/.local/share/opencode/opencode.db",
+    ].join("\n")
+  )
+}
+
+/**
+ * Handle the chat list command.
+ *
+ * Lists messages in a session, ordered by createdAt (ascending).
+ * Optionally includes message parts for full content.
+ */
+async function handleChatList(
+  globalOpts: GlobalOptions,
+  listOpts: ChatListOptions
+): Promise<void> {
+  // Create provider from global options (JSONL or SQLite)
+  const provider = createProviderFromGlobalOptions(globalOpts)
+
+  // Resolve session ID (with prefix matching) using the provider
+  const { session } = await resolveSessionId(listOpts.session, {
+    root: globalOpts.root,
+    allowPrefix: true,
+    provider,
+  })
+
+  // Load message index for the session
+  let messages = await provider.loadSessionChatIndex(session.sessionId)
+
+  // Hydrate parts if requested
+  if (listOpts.includeParts) {
+    messages = await Promise.all(
+      messages.map((msg: ChatMessage) => provider.hydrateChatMessageParts(msg))
+    )
+  }
+
+  // Apply limit
+  if (globalOpts.limit && messages.length > globalOpts.limit) {
+    messages = messages.slice(0, globalOpts.limit)
+  }
+
+  // Add 1-based index for display
+  const indexedMessages: IndexedChatMessage[] = messages.map((msg: ChatMessage, i: number) => ({
+    ...msg,
+    index: i + 1,
+  }))
+
+  // Output using configured format
+  const outputOpts = getOutputOptions(globalOpts)
+  printChatOutput(indexedMessages, outputOpts)
+}
+
+/**
+ * Handle the chat show command.
+ *
+ * Shows a specific message by ID or 1-based index.
+ * Optionally copies the message content to clipboard.
+ */
+async function handleChatShow(
+  globalOpts: GlobalOptions,
+  showOpts: ChatShowOptions
+): Promise<void> {
+  // Validate that either --message or --index is provided
+  if (!showOpts.message && showOpts.index === undefined) {
+    throw new UsageError(
+      "Either --message <messageId> or --index <number> is required"
+    )
+  }
+  if (showOpts.message && showOpts.index !== undefined) {
+    throw new UsageError(
+      "Cannot use both --message and --index. Use one or the other."
+    )
+  }
+
+  // Create provider from global options (JSONL or SQLite)
+  const provider = createProviderFromGlobalOptions(globalOpts)
+
+  // Resolve session ID (with prefix matching) using the provider
+  const { session } = await resolveSessionId(showOpts.session, {
+    root: globalOpts.root,
+    allowPrefix: true,
+    provider,
+  })
+
+  // Load all messages for the session
+  const messages = await provider.loadSessionChatIndex(session.sessionId)
+
+  if (messages.length === 0) {
+    throw new NotFoundError(
+      `Session "${session.sessionId}" has no messages`,
+      "message"
+    )
+  }
+
+  let message: ChatMessage | undefined
+
+  if (showOpts.message) {
+    // Find by message ID (exact or prefix match)
+    const messageId = showOpts.message
+    message = messages.find((m: ChatMessage) => m.messageId === messageId)
+    if (!message) {
+      // Try prefix matching
+      const prefixMatches = messages.filter((m: ChatMessage) =>
+        m.messageId.startsWith(messageId)
+      )
+      if (prefixMatches.length === 1) {
+        message = prefixMatches[0]
+      } else if (prefixMatches.length > 1) {
+        throw new NotFoundError(
+          `Ambiguous message ID prefix "${messageId}" matches ${prefixMatches.length} messages: ${prefixMatches.map((m: ChatMessage) => m.messageId).join(", ")}`,
+          "message"
+        )
+      } else {
+        throw new NotFoundError(
+          `Message "${messageId}" not found in session "${session.sessionId}"`,
+          "message"
+        )
+      }
+    }
+  } else {
+    // Find by index (1-based)
+    const index = showOpts.index!
+    if (index < 1 || index > messages.length) {
+      throw new NotFoundError(
+        `Message index ${index} is out of range. Session has ${messages.length} message(s).`,
+        "message"
+      )
+    }
+    message = messages[index - 1]
+  }
+
+  // Hydrate message parts to get full content
+  const hydratedMessage = await provider.hydrateChatMessageParts(message)
+
+  // Copy to clipboard if requested
+  if (showOpts.clipboard) {
+    const content = hydratedMessage.parts
+      ?.map((p: { text: string }) => p.text)
+      .join("\n\n") ?? hydratedMessage.previewText
+    try {
+      await copyToClipboard(content)
+      if (globalOpts.format === "table") {
+        console.log("(copied to clipboard)")
+      }
+    } catch {
+      // Clipboard copy failed (e.g., xclip/pbcopy not available)
+      // Warn but continue - the user still gets the message output
+      if (globalOpts.format === "table") {
+        console.error("Warning: Could not copy to clipboard")
+      }
+    }
+  }
+
+  // Output the message
+  printChatMessageOutput(hydratedMessage, globalOpts.format)
+}
+
+/**
+ * Handle the chat search command.
+ *
+ * Searches chat content across all sessions (or filtered by project).
+ * Returns matching messages with context snippets.
+ */
+async function handleChatSearch(
+  globalOpts: GlobalOptions,
+  searchOpts: ChatSearchOptions
+): Promise<void> {
+  // Create provider from global options (JSONL or SQLite)
+  const provider = createProviderFromGlobalOptions(globalOpts)
+
+  // Load sessions to search
+  const sessions = await provider.loadSessionRecords({
+    projectId: searchOpts.project,
+  })
+
+  // Search across sessions using the limit from global options
+  const results = await provider.searchSessionsChat(
+    sessions,
+    searchOpts.query,
+    { maxResults: globalOpts.limit }
+  )
+
+  // Add 1-based index for display
+  const indexedResults: IndexedChatSearchResult[] = results.map((result: ChatSearchResult, i: number) => ({
+    ...result,
+    index: i + 1,
+  }))
+
+  // Output using configured format
+  const outputOpts = getOutputOptions(globalOpts)
+  printChatSearchOutput(indexedResults, outputOpts)
+}