@aladac/hu 0.1.0-a1 → 0.1.0-a2

package/src/commands/data.ts

@@ -0,0 +1,877 @@
+/**
+ * hu data - Data access commands for Claude Code data
+ */
+
+import { defineCommand } from 'citty';
+import { getDb, closeDb } from '../lib/db.ts';
+import { initializeSchema } from '../lib/schema.ts';
+import { syncAll, syncIfNeeded } from '../lib/sync.ts';
+import { getConfig, getConfigPath, getDatabasePath, getClaudeDir } from '../lib/config.ts';
+import { getDebugDir } from '../lib/claude-paths.ts';
+import { c } from '../lib/colors.ts';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+// Ensure DB is initialized on first access
+function getInitializedDb() {
+  const db = getDb();
+  initializeSchema(db);
+  return db;
+}
+
+// Sync subcommand
+const syncCommand = defineCommand({
+  meta: {
+    name: 'sync',
+    description: 'Sync Claude Code data to local database',
+  },
+  args: {
+    force: {
+      type: 'boolean',
+      alias: 'f',
+      description: 'Force full sync even if recent',
+      default: false,
+    },
+    quiet: {
+      type: 'boolean',
+      alias: 'q',
+      description: 'Suppress output',
+      default: false,
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    
+    if (!args.quiet) {
+      console.log(`${c.dim}Syncing Claude Code data...${c.reset}`);
+    }
+    const result = syncAll(db);
+    
+    if (!args.quiet) {
+      console.log(`${c.green}✓${c.reset} Synced:`);
+      console.log(`  Sessions: ${result.history}`);
+      console.log(`  Messages: ${result.messages}`);
+      console.log(`  Todos: ${result.todos}`);
+    }
+    
+    closeDb();
+  },
+});
+
+// Config subcommand
+const configCommand = defineCommand({
+  meta: {
+    name: 'config',
+    description: 'Show current configuration',
+  },
+  args: {
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  },
+  run: ({ args }) => {
+    const config = getConfig();
+    
+    if (args.json) {
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+
+    console.log(`${c.bold}hu Configuration${c.reset}\n`);
+    console.log(`${c.dim}Config file:${c.reset}  ${getConfigPath()}`);
+    console.log(`${c.dim}Database:${c.reset}     ${getDatabasePath()}`);
+    console.log(`${c.dim}Claude dir:${c.reset}   ${getClaudeDir()}`);
+    console.log();
+    console.log(`${c.bold}[general]${c.reset}`);
+    console.log(`  claude_dir = "${config.general.claude_dir}"`);
+    console.log(`  database = "${config.general.database}"`);
+    console.log();
+    console.log(`${c.bold}[sync]${c.reset}`);
+    console.log(`  auto_sync_interval = ${config.sync.auto_sync_interval}`);
+    console.log(`  sync_on_start = ${config.sync.sync_on_start}`);
+    console.log();
+    console.log(`${c.bold}[hooks]${c.reset}`);
+    console.log(`  enabled = ${config.hooks.enabled}`);
+    console.log(`  temp_dir = "${config.hooks.temp_dir}"`);
+    console.log(`  temp_file_ttl = ${config.hooks.temp_file_ttl}`);
+    console.log();
+    console.log(`${c.bold}[search]${c.reset}`);
+    console.log(`  default_limit = ${config.search.default_limit}`);
+    console.log(`  show_snippets = ${config.search.show_snippets}`);
+    console.log();
+    console.log(`${c.bold}[output]${c.reset}`);
+    console.log(`  default_format = "${config.output.default_format}"`);
+    console.log(`  colors = ${config.output.colors}`);
+    console.log(`  date_format = "${config.output.date_format}"`);
+  },
+});
+
+// Session list subcommand
+const sessionListCommand = defineCommand({
+  meta: {
+    name: 'list',
+    description: 'List sessions',
+  },
+  args: {
+    project: {
+      type: 'string',
+      alias: 'p',
+      description: 'Filter by project path',
+    },
+    limit: {
+      type: 'string',
+      alias: 'n',
+      description: 'Number of sessions to show',
+      default: '20',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    let query = 'SELECT * FROM sessions';
+    const params: unknown[] = [];
+
+    if (args.project) {
+      query += ' WHERE project LIKE ?';
+      params.push(`%${args.project}%`);
+    }
+
+    query += ' ORDER BY started_at DESC LIMIT ?';
+    params.push(parseInt(args.limit, 10));
+
+    const sessions = db.prepare(query).all(...params) as Array<{
+      id: string;
+      project: string;
+      display: string;
+      started_at: number;
+      message_count: number;
+      total_cost_usd: number;
+    }>;
+
+    if (args.json || args.output) {
+      const output = JSON.stringify(sessions, null, 2);
+      if (args.output) {
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Sessions${c.reset} (${sessions.length})\n`);
+      for (const session of sessions) {
+        const date = new Date(session.started_at).toLocaleString();
+        const preview = session.display?.slice(0, 60) || '(no preview)';
+        console.log(`${c.cyan}${session.id.slice(0, 8)}${c.reset} ${c.dim}${date}${c.reset}`);
+        console.log(`  ${c.dim}Project:${c.reset} ${session.project}`);
+        console.log(`  ${c.dim}Messages:${c.reset} ${session.message_count} ${c.dim}Cost:${c.reset} $${(session.total_cost_usd || 0).toFixed(4)}`);
+        console.log(`  ${preview}${session.display?.length > 60 ? '...' : ''}`);
+        console.log();
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Session read subcommand
+const sessionReadCommand = defineCommand({
+  meta: {
+    name: 'read',
+    description: 'Read session transcript',
+  },
+  args: {
+    id: {
+      type: 'positional',
+      description: 'Session ID (or prefix)',
+      required: true,
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    // Find session by ID or prefix
+    const session = db.prepare(
+      'SELECT * FROM sessions WHERE id LIKE ? ORDER BY started_at DESC LIMIT 1'
+    ).get(`${args.id}%`) as { id: string; project: string; started_at: number } | undefined;
+
+    if (!session) {
+      console.error(`Session not found: ${args.id}`);
+      process.exit(1);
+    }
+
+    const messages = db.prepare(
+      'SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC'
+    ).all(session.id) as Array<{
+      id: string;
+      role: string;
+      content: string;
+      model: string;
+      created_at: number;
+    }>;
+
+    if (args.json || args.output) {
+      const output = JSON.stringify({ session, messages }, null, 2);
+      if (args.output) {
+        
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Session: ${session.id}${c.reset}`);
+      console.log(`${c.dim}Project:${c.reset} ${session.project}`);
+      console.log(`${c.dim}Started:${c.reset} ${new Date(session.started_at).toLocaleString()}`);
+      console.log(`${c.dim}Messages:${c.reset} ${messages.length}\n`);
+      console.log('─'.repeat(60) + '\n');
+
+      for (const msg of messages) {
+        const roleColor = msg.role === 'user' ? c.green : c.blue;
+        console.log(`${roleColor}[${msg.role}]${c.reset} ${c.dim}${msg.model || ''}${c.reset}`);
+        console.log(msg.content.slice(0, 500) + (msg.content.length > 500 ? '...' : ''));
+        console.log();
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Session current subcommand
+const sessionCurrentCommand = defineCommand({
+  meta: {
+    name: 'current',
+    description: 'Show current session (from $SESSION_ID env)',
+  },
+  args: {
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const sessionId = process.env.SESSION_ID;
+    
+    if (!sessionId) {
+      console.error('No current session. SESSION_ID environment variable not set.');
+      console.error('This command is designed to be used within Claude Code hooks.');
+      process.exit(1);
+    }
+
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    const session = db.prepare(
+      'SELECT * FROM sessions WHERE id = ?'
+    ).get(sessionId) as { id: string; project: string; started_at: number } | undefined;
+
+    if (!session) {
+      console.error(`Session not found: ${sessionId}`);
+      process.exit(1);
+    }
+
+    const messages = db.prepare(
+      'SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC'
+    ).all(session.id) as Array<{
+      id: string;
+      role: string;
+      content: string;
+      model: string;
+      created_at: number;
+    }>;
+
+    if (args.json || args.output) {
+      const output = JSON.stringify({ session, messages }, null, 2);
+      if (args.output) {
+        
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Current Session: ${session.id}${c.reset}`);
+      console.log(`${c.dim}Project:${c.reset} ${session.project}`);
+      console.log(`${c.dim}Started:${c.reset} ${new Date(session.started_at).toLocaleString()}`);
+      console.log(`${c.dim}Messages:${c.reset} ${messages.length}`);
+    }
+
+    closeDb();
+  },
+});
+
+// Session subcommand group
+const sessionCommand = defineCommand({
+  meta: {
+    name: 'session',
+    description: 'Session management commands',
+  },
+  subCommands: {
+    list: sessionListCommand,
+    read: sessionReadCommand,
+    current: sessionCurrentCommand,
+  },
+});
+
+// Stats subcommand
+const statsCommand = defineCommand({
+  meta: {
+    name: 'stats',
+    description: 'Show usage statistics',
+  },
+  args: {
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    today: {
+      type: 'boolean',
+      alias: 't',
+      description: 'Show today\'s stats only',
+      default: false,
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    let whereClause = '';
+    if (args.today) {
+      const todayStart = new Date();
+      todayStart.setHours(0, 0, 0, 0);
+      whereClause = ` WHERE created_at >= ${todayStart.getTime()}`;
+    }
+
+    const stats = {
+      totalSessions: (db.prepare(`SELECT COUNT(*) as count FROM sessions`).get() as { count: number }).count,
+      totalMessages: (db.prepare(`SELECT COUNT(*) as count FROM messages${whereClause}`).get() as { count: number }).count,
+      totalCost: (db.prepare(`SELECT COALESCE(SUM(cost_usd), 0) as total FROM messages${whereClause}`).get() as { total: number }).total,
+      totalInputTokens: (db.prepare(`SELECT COALESCE(SUM(input_tokens), 0) as total FROM messages${whereClause}`).get() as { total: number }).total,
+      totalOutputTokens: (db.prepare(`SELECT COALESCE(SUM(output_tokens), 0) as total FROM messages${whereClause}`).get() as { total: number }).total,
+      modelUsage: db.prepare(`
+        SELECT model, COUNT(*) as count, SUM(cost_usd) as cost
+        FROM messages
+        WHERE model IS NOT NULL ${args.today ? `AND created_at >= ${new Date().setHours(0,0,0,0)}` : ''}
+        GROUP BY model
+        ORDER BY count DESC
+      `).all() as Array<{ model: string; count: number; cost: number }>,
+    };
+
+    if (args.json) {
+      console.log(JSON.stringify(stats, null, 2));
+    } else {
+      console.log(`${c.bold}Usage Statistics${args.today ? ' (Today)' : ''}${c.reset}\n`);
+      console.log(`${c.dim}Sessions:${c.reset}      ${stats.totalSessions}`);
+      console.log(`${c.dim}Messages:${c.reset}      ${stats.totalMessages}`);
+      console.log(`${c.dim}Total Cost:${c.reset}    $${stats.totalCost.toFixed(4)}`);
+      console.log(`${c.dim}Input Tokens:${c.reset}  ${stats.totalInputTokens.toLocaleString()}`);
+      console.log(`${c.dim}Output Tokens:${c.reset} ${stats.totalOutputTokens.toLocaleString()}`);
+      
+      if (stats.modelUsage.length > 0) {
+        console.log(`\n${c.bold}By Model${c.reset}`);
+        for (const model of stats.modelUsage) {
+          console.log(`  ${model.model}: ${model.count} messages, $${(model.cost || 0).toFixed(4)}`);
+        }
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Todos list subcommand
+const todosListCommand = defineCommand({
+  meta: {
+    name: 'list',
+    description: 'List todos',
+  },
+  args: {
+    status: {
+      type: 'string',
+      alias: 's',
+      description: 'Filter by status (pending, in_progress, completed)',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    let query = 'SELECT * FROM todos';
+    const params: unknown[] = [];
+
+    if (args.status) {
+      query += ' WHERE status = ?';
+      params.push(args.status);
+    }
+
+    query += ' ORDER BY id DESC';
+
+    const todos = db.prepare(query).all(...params) as Array<{
+      id: number;
+      session_id: string;
+      content: string;
+      status: string;
+      active_form: string;
+    }>;
+
+    if (args.json || args.output) {
+      const output = JSON.stringify(todos, null, 2);
+      if (args.output) {
+        
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Todos${c.reset} (${todos.length})\n`);
+      for (const todo of todos) {
+        const statusColor = 
+          todo.status === 'completed' ? c.green :
+          todo.status === 'in_progress' ? c.yellow : c.dim;
+        console.log(`${statusColor}[${todo.status}]${c.reset} ${todo.content}`);
+        console.log(`  ${c.dim}Session: ${todo.session_id.slice(0, 8)}${c.reset}`);
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Todos pending subcommand
+const todosPendingCommand = defineCommand({
+  meta: {
+    name: 'pending',
+    description: 'List pending todos',
+  },
+  args: {
+    project: {
+      type: 'string',
+      alias: 'p',
+      description: 'Filter by project path',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    let query = `
+      SELECT t.*, s.project 
+      FROM todos t 
+      JOIN sessions s ON t.session_id = s.id 
+      WHERE t.status != 'completed'
+    `;
+    const params: unknown[] = [];
+
+    if (args.project) {
+      query += ' AND s.project LIKE ?';
+      params.push(`%${args.project}%`);
+    }
+
+    query += ' ORDER BY t.id DESC';
+
+    const todos = db.prepare(query).all(...params) as Array<{
+      id: number;
+      session_id: string;
+      content: string;
+      status: string;
+      project: string;
+    }>;
+
+    if (args.json || args.output) {
+      const output = JSON.stringify(todos, null, 2);
+      if (args.output) {
+        
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Pending Todos${c.reset} (${todos.length})\n`);
+      
+      // Group by project
+      const byProject = new Map<string, typeof todos>();
+      for (const todo of todos) {
+        const list = byProject.get(todo.project) || [];
+        list.push(todo);
+        byProject.set(todo.project, list);
+      }
+
+      for (const [project, projectTodos] of byProject) {
+        console.log(`${c.cyan}${project}${c.reset}`);
+        for (const todo of projectTodos) {
+          const statusColor = todo.status === 'in_progress' ? c.yellow : c.dim;
+          console.log(`  ${statusColor}[${todo.status}]${c.reset} ${todo.content}`);
+        }
+        console.log();
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Todos subcommand group
+const todosCommand = defineCommand({
+  meta: {
+    name: 'todos',
+    description: 'Todo management commands',
+  },
+  subCommands: {
+    list: todosListCommand,
+    pending: todosPendingCommand,
+  },
+});
+
+// Search subcommand
+const searchCommand = defineCommand({
+  meta: {
+    name: 'search',
+    description: 'Search messages',
+  },
+  args: {
+    query: {
+      type: 'positional',
+      description: 'Search query',
+      required: true,
+    },
+    limit: {
+      type: 'string',
+      alias: 'n',
+      description: 'Number of results',
+      default: '20',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    const results = db.prepare(`
+      SELECT m.*, s.project
+      FROM messages m
+      JOIN sessions s ON m.session_id = s.id
+      WHERE m.content LIKE ?
+      ORDER BY m.created_at DESC
+      LIMIT ?
+    `).all(`%${args.query}%`, parseInt(args.limit, 10)) as Array<{
+      id: string;
+      session_id: string;
+      role: string;
+      content: string;
+      project: string;
+      created_at: number;
+    }>;
+
+    if (args.json || args.output) {
+      const output = JSON.stringify(results, null, 2);
+      if (args.output) {
+        
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Search Results for "${args.query}"${c.reset} (${results.length})\n`);
+      
+      for (const result of results) {
+        const date = new Date(result.created_at).toLocaleString();
+        const roleColor = result.role === 'user' ? c.green : c.blue;
+        
+        console.log(`${roleColor}[${result.role}]${c.reset} ${c.dim}${date}${c.reset}`);
+        console.log(`${c.dim}Project:${c.reset} ${result.project}`);
+        
+        // Show snippet around match
+        const content = result.content;
+        const matchIndex = content.toLowerCase().indexOf(args.query.toLowerCase());
+        if (matchIndex >= 0) {
+          const start = Math.max(0, matchIndex - 50);
+          const end = Math.min(content.length, matchIndex + args.query.length + 50);
+          const snippet = (start > 0 ? '...' : '') + 
+            content.slice(start, end) + 
+            (end < content.length ? '...' : '');
+          console.log(snippet);
+        } else {
+          console.log(content.slice(0, 100) + (content.length > 100 ? '...' : ''));
+        }
+        console.log();
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Tools subcommand
+const toolsCommand = defineCommand({
+  meta: {
+    name: 'tools',
+    description: 'Show tool usage statistics',
+  },
+  args: {
+    tool: {
+      type: 'string',
+      alias: 't',
+      description: 'Filter by tool name',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+  },
+  run: ({ args }) => {
+    const db = getInitializedDb();
+    syncIfNeeded(db);
+
+    if (args.tool) {
+      // Show details for specific tool
+      const usage = db.prepare(`
+        SELECT tu.*, s.project
+        FROM tool_usage tu
+        JOIN sessions s ON tu.session_id = s.id
+        WHERE tu.tool_name = ?
+        ORDER BY tu.created_at DESC
+        LIMIT 20
+      `).all(args.tool) as Array<{
+        tool_name: string;
+        session_id: string;
+        project: string;
+        created_at: number;
+      }>;
+
+      if (args.json) {
+        console.log(JSON.stringify(usage, null, 2));
+      } else {
+        console.log(`${c.bold}Tool: ${args.tool}${c.reset} (${usage.length} recent uses)\n`);
+        for (const u of usage) {
+          const date = new Date(u.created_at).toLocaleString();
+          console.log(`${c.dim}${date}${c.reset} ${u.project}`);
+        }
+      }
+    } else {
+      // Show aggregate stats
+      const stats = db.prepare(`
+        SELECT tool_name, COUNT(*) as count, MAX(created_at) as last_used
+        FROM tool_usage
+        GROUP BY tool_name
+        ORDER BY count DESC
+      `).all() as Array<{ tool_name: string; count: number; last_used: number }>;
+
+      if (args.json) {
+        console.log(JSON.stringify(stats, null, 2));
+      } else {
+        console.log(`${c.bold}Tool Usage${c.reset}\n`);
+        for (const stat of stats) {
+          const lastUsed = new Date(stat.last_used).toLocaleDateString();
+          console.log(`${c.cyan}${stat.tool_name}${c.reset}: ${stat.count} uses (last: ${lastUsed})`);
+        }
+      }
+    }
+
+    closeDb();
+  },
+});
+
+// Errors subcommand
+const errorsCommand = defineCommand({
+  meta: {
+    name: 'errors',
+    description: 'Extract errors from debug logs',
+  },
+  args: {
+    recent: {
+      type: 'string',
+      alias: 'r',
+      description: 'Show errors from last N days',
+      default: '7',
+    },
+    json: {
+      type: 'boolean',
+      alias: 'j',
+      description: 'Output as JSON',
+      default: false,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Write output to file',
+    },
+  },
+  run: ({ args }) => {
+    const debugDir = getDebugDir();
+    
+    if (!fs.existsSync(debugDir)) {
+      console.log('No debug logs found.');
+      return;
+    }
+
+    const days = parseInt(args.recent, 10);
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    
+    const errorPatterns = [
+      /error/i,
+      /failed/i,
+      /exception/i,
+      /warning/i,
+      /ENOENT/i,
+      /EACCES/i,
+      /EPERM/i,
+    ];
+
+    const errors: Array<{ file: string; line: number; content: string; timestamp: number }> = [];
+
+    const logFiles = fs.readdirSync(debugDir)
+      .filter(f => f.endsWith('.txt'))
+      .map(f => ({
+        name: f,
+        path: path.join(debugDir, f),
+        stat: fs.statSync(path.join(debugDir, f)),
+      }))
+      .filter(f => f.stat.mtimeMs > cutoff);
+
+    for (const logFile of logFiles) {
+      try {
+        const content = fs.readFileSync(logFile.path, 'utf-8');
+        const lines = content.split('\n');
+        
+        lines.forEach((line, idx) => {
+          if (errorPatterns.some(p => p.test(line))) {
+            errors.push({
+              file: logFile.name,
+              line: idx + 1,
+              content: line.trim(),
+              timestamp: logFile.stat.mtimeMs,
+            });
+          }
+        });
+      } catch {
+        // Skip files that can't be read
+      }
+    }
+
+    // Sort by timestamp descending
+    errors.sort((a, b) => b.timestamp - a.timestamp);
+
+    if (args.json || args.output) {
+      const output = JSON.stringify(errors, null, 2);
+      if (args.output) {
+        fs.writeFileSync(args.output, output);
+        console.log(`Written to ${args.output}`);
+      } else {
+        console.log(output);
+      }
+    } else {
+      console.log(`${c.bold}Errors from Debug Logs${c.reset} (last ${days} days)\n`);
+      console.log(`Found ${errors.length} error/warning entries in ${logFiles.length} log files\n`);
+      
+      // Show unique errors (dedupe by content)
+      const seen = new Set<string>();
+      let shown = 0;
+      
+      for (const err of errors) {
+        if (shown >= 50) break;
+        if (seen.has(err.content)) continue;
+        seen.add(err.content);
+        
+        console.log(`${c.dim}${err.file}:${err.line}${c.reset}`);
+        console.log(`  ${c.red}${err.content.slice(0, 200)}${err.content.length > 200 ? '...' : ''}${c.reset}`);
+        console.log();
+        shown++;
+      }
+      
+      if (errors.length > shown) {
+        console.log(`${c.dim}... and ${errors.length - shown} more (use --json for full output)${c.reset}`);
+      }
+    }
+  },
+});
+
+// Main data command
+export const dataCommand = defineCommand({
+  meta: {
+    name: 'data',
+    description: 'Access Claude Code session data',
+  },
+  subCommands: {
+    sync: syncCommand,
+    config: configCommand,
+    session: sessionCommand,
+    stats: statsCommand,
+    todos: todosCommand,
+    search: searchCommand,
+    tools: toolsCommand,
+    errors: errorsCommand,
+  },
+});