@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/log.ts

@@ -0,0 +1,316 @@
+/**
+ * Bootspring Log Command
+ * View and manage action logs
+ *
+ * Commands:
+ *   list              List recent actions
+ *   search <query>    Search action logs
+ *   show <filename>   View a specific log
+ *   export            Export logs to a directory
+ *   clear             Clear old logs
+ *
+ * @package bootspring
+ * @module cli/log
+ */
+
+// Import JS modules with type interfaces
+interface LogEntry {
+  type: string;
+  timestamp: string;
+  agent?: string;
+  title?: string;
+  filename: string;
+}
+
+interface SearchResult {
+  type: string;
+  file: string;
+  matches?: Array<{
+    line: number;
+    preview: string;
+  }>;
+}
+
+interface LogDetails {
+  type: string;
+  relativePath: string;
+  content: string;
+  metadata?: {
+    size: number;
+    modifiedRelative: string;
+  };
+}
+
+interface ActionRecorderModule {
+  list(options: { type?: string | undefined; limit?: number | undefined }): LogEntry[];
+  search(query: string, options: { limit?: number | undefined }): SearchResult[];
+  get(filename: string): LogDetails | null;
+  exportLogs(outputDir: string): { count: number; outputDir: string };
+  clearOld(options: { olderThanDays: number }): { deleted: number };
+}
+
+interface ParsedArgs {
+  _: string[];
+  type?: string;
+  limit?: string;
+  output?: string;
+  o?: string;
+  days?: string;
+  force?: boolean;
+  f?: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const actionRecorder = require('../../core/action-recorder') as ActionRecorderModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const utils = require('../../core/utils') as typeof import('../core/utils');
+
+/**
+ * Run log command
+ */
+export async function run(args: string[]): Promise<void> {
+  const parsedArgs = utils.parseArgs(args) as ParsedArgs;
+  const subcommand = parsedArgs._[0] || 'list';
+  const subArgs = args.slice(1);
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      listLogs(parsedArgs);
+      return;
+    case 'search':
+    case 'find':
+      searchLogs(subArgs);
+      return;
+    case 'show':
+    case 'get':
+    case 'view':
+      showLog(subArgs);
+      return;
+    case 'export':
+      exportLogs(parsedArgs);
+      return;
+    case 'clear':
+    case 'clean':
+      clearLogs(parsedArgs);
+      return;
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      return;
+    default:
+      utils.print.error(`Unknown subcommand: ${subcommand}`);
+      showHelp();
+  }
+}
+
+/**
+ * List recent action logs
+ */
+function listLogs(args: ParsedArgs): void {
+  utils.print.header('Action Logs');
+
+  const type = args.type;
+  const limit = args.limit ? parseInt(args.limit, 10) : 20;
+
+  const logs = actionRecorder.list({ type, limit });
+
+  if (logs.length === 0) {
+    utils.print.info('No action logs found');
+    utils.print.dim('Actions are automatically recorded when you use bootspring');
+    return;
+  }
+
+  // Group by type
+  const grouped: Record<string, LogEntry[]> = {};
+  for (const log of logs) {
+    if (!grouped[log.type]) {
+      grouped[log.type] = [];
+    }
+    const group = grouped[log.type];
+    if (group) {
+      group.push(log);
+    }
+  }
+
+  for (const [logType, entries] of Object.entries(grouped)) {
+    console.log(`\n${utils.COLORS.bold}${logType}${utils.COLORS.reset} (${entries.length})`);
+
+    for (const entry of entries) {
+      const time = new Date(entry.timestamp).toLocaleString();
+      const agent = entry.agent ? ` [${entry.agent}]` : '';
+      const title = entry.title || entry.filename;
+
+      console.log(`  ${utils.COLORS.dim}${time}${utils.COLORS.reset}${agent} ${title}`);
+    }
+  }
+
+  console.log(`\n${utils.COLORS.dim}Total: ${logs.length} entries${utils.COLORS.reset}`);
+}
+
+/**
+ * Search action logs
+ */
+function searchLogs(args: string[]): void {
+  const parsedArgs = utils.parseArgs(args) as ParsedArgs;
+  const query = parsedArgs._[0];
+
+  if (!query) {
+    utils.print.error('Please specify a search query');
+    utils.print.dim('Example: bootspring log search "authentication"');
+    return;
+  }
+
+  utils.print.header(`Searching logs for: ${query}`);
+
+  const limit = parsedArgs.limit ? parseInt(parsedArgs.limit, 10) : 20;
+  const results = actionRecorder.search(query, { limit });
+
+  if (results.length === 0) {
+    utils.print.warning('No results found');
+    return;
+  }
+
+  console.log(`${utils.COLORS.dim}Found ${results.length} result(s)${utils.COLORS.reset}\n`);
+
+  for (const result of results) {
+    console.log(`${utils.COLORS.bold}${result.type}${utils.COLORS.reset}: ${result.file}`);
+
+    if (result.matches) {
+      for (const match of result.matches) {
+        console.log(`  ${utils.COLORS.dim}L${match.line}:${utils.COLORS.reset} ${highlightMatch(match.preview, query)}`);
+      }
+    }
+    console.log('');
+  }
+}
+
+/**
+ * Show a specific log entry
+ */
+function showLog(args: string[]): void {
+  const parsedArgs = utils.parseArgs(args) as ParsedArgs;
+  const filename = parsedArgs._[0];
+
+  if (!filename) {
+    utils.print.error('Please specify a log filename');
+    utils.print.dim('Example: bootspring log show 2026-02-16-12-30-00-agent.md');
+    return;
+  }
+
+  const log = actionRecorder.get(filename);
+
+  if (!log) {
+    utils.print.error(`Log not found: ${filename}`);
+    return;
+  }
+
+  utils.print.header(`Log: ${filename}`);
+  console.log(`${utils.COLORS.dim}Type: ${log.type} | Path: ${log.relativePath}${utils.COLORS.reset}\n`);
+
+  if (log.metadata) {
+    console.log(`${utils.COLORS.dim}Size: ${formatSize(log.metadata.size)} | Modified: ${log.metadata.modifiedRelative}${utils.COLORS.reset}\n`);
+  }
+
+  console.log(log.content);
+}
+
+/**
+ * Export logs to a directory
+ */
+function exportLogs(args: ParsedArgs): void {
+  const outputDir = args.output || args.o || './bootspring-logs-export';
+
+  const spinner = utils.createSpinner('Exporting logs...').start();
+
+  try {
+    const result = actionRecorder.exportLogs(outputDir);
+    spinner.succeed(`Exported ${result.count} logs to ${result.outputDir}`);
+  } catch (error) {
+    spinner.fail(`Export failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Clear old logs
+ */
+function clearLogs(args: ParsedArgs): void {
+  const days = args.days ? parseInt(args.days, 10) : 30;
+  const force = args.force || args.f;
+
+  if (!force) {
+    utils.print.warning(`This will delete logs older than ${days} days`);
+    utils.print.dim('Use --force to confirm');
+    return;
+  }
+
+  const spinner = utils.createSpinner('Clearing old logs...').start();
+
+  try {
+    const result = actionRecorder.clearOld({ olderThanDays: days });
+    spinner.succeed(`Deleted ${result.deleted} old log entries`);
+  } catch (error) {
+    spinner.fail(`Clear failed: ${(error as Error).message}`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp(): void {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Log${utils.COLORS.reset}
+${utils.COLORS.dim}View and manage action logs${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring log <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List recent actions (default)
+  ${utils.COLORS.cyan}search <query>${utils.COLORS.reset}    Search action logs
+  ${utils.COLORS.cyan}show <filename>${utils.COLORS.reset}   View a specific log
+  ${utils.COLORS.cyan}export${utils.COLORS.reset}            Export logs to a directory
+  ${utils.COLORS.cyan}clear${utils.COLORS.reset}             Clear old logs
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --type=<type>       Filter by log type (agent, code, decision, fix, business, meeting)
+  --limit=<n>         Limit results (default: 20)
+  --output=<dir>      Export output directory
+  --days=<n>          Clear logs older than N days (default: 30)
+  --force             Confirm destructive actions
+
+${utils.COLORS.bold}Log Types:${utils.COLORS.reset}
+  agent               Agent invocation logs
+  code                Code generation logs
+  decision            Decision records
+  fix                 Bug fix documentation
+  business            Business action logs
+  meeting             Meeting notes
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring log
+  bootspring log list --type=agent
+  bootspring log search "authentication"
+  bootspring log show 2026-02-16-agent-frontend.md
+  bootspring log export --output=./logs
+  bootspring log clear --days=60 --force
+`);
+}
+
+/**
+ * Format file size
+ */
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+/**
+ * Highlight search match in text
+ */
+function highlightMatch(text: string, query: string): string {
+  const regex = new RegExp(`(${query})`, 'gi');
+  return text.replace(regex, `${utils.COLORS.yellow}$1${utils.COLORS.reset}`);
+}