@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/core/action-recorder.ts

@@ -0,0 +1,673 @@
+/**
+ * Bootspring Action Recorder
+ * Automatically records actions and creates .md files for reference
+ *
+ * Action Types:
+ * - agents: Agent invocation logs
+ * - code: Code generation logs
+ * - decisions: Decision records
+ * - fixes: Bug fix documentation
+ * - business: Business action logs
+ * - meetings: Meeting notes
+ *
+ * @package bootspring
+ * @module core/action-recorder
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Module interfaces
+interface Config {
+  _projectRoot: string;
+}
+
+interface ConfigModule {
+  load: () => Config | null;
+}
+
+interface Utils {
+  formatDate: () => string;
+  slugify: (text: string) => string;
+  truncate: (text: string, maxLength: number) => string;
+  writeFile: (path: string, content: string) => boolean;
+  readFile: (path: string) => string | null;
+  fileExists: (path: string) => boolean;
+  ensureDir: (dir: string) => void;
+  formatRelativeTime: (date: Date) => string;
+}
+
+interface ContextLoader {
+  ensureDirectories: (projectRoot: string) => void;
+}
+
+export interface Action {
+  type: string;
+  agent?: string | undefined;
+  title?: string | undefined;
+  input?: string | undefined;
+  output?: string | undefined;
+  files?: string[] | undefined;
+  context?: string[] | undefined;
+  metadata?: Record<string, unknown> | undefined;
+  // Decision-specific
+  options?: string[] | undefined;
+  rationale?: string | undefined;
+  // Fix-specific
+  problem?: string | undefined;
+  solution?: string | undefined;
+  prevention?: string | undefined;
+}
+
+export interface RecordResult {
+  success: boolean;
+  path: string;
+  filename: string;
+  relativePath: string;
+}
+
+export interface RecordOptions {
+  config?: Config | undefined;
+}
+
+export interface ListOptions {
+  config?: Config | undefined;
+  type?: string | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+}
+
+export interface SearchOptions {
+  config?: Config | undefined;
+  types?: string[] | undefined;
+  limit?: number | undefined;
+}
+
+export interface IndexEntry {
+  type: string;
+  filename: string;
+  timestamp: string;
+  agent?: string | undefined;
+  title?: string | undefined;
+  files?: string[] | undefined;
+}
+
+export interface LogIndex {
+  version: string;
+  entries: IndexEntry[];
+  lastUpdated?: string | undefined;
+}
+
+export interface SearchResult {
+  type: string;
+  file: string;
+  path: string;
+  matches: { line: number; preview: string }[];
+}
+
+export interface LogEntry {
+  type: string;
+  filename: string;
+  path: string;
+  relativePath: string;
+  content: string;
+  metadata: {
+    size: number;
+    modified: Date;
+    modifiedRelative: string;
+  };
+}
+
+export interface RelevantLog extends LogEntry {
+  type: string;
+  keyword?: string | undefined;
+}
+
+export interface ExportResult {
+  success: boolean;
+  count: number;
+  outputDir: string;
+}
+
+export interface ClearResult {
+  success: boolean;
+  deleted: number;
+}
+
+// Lazy-loaded modules
+let _config: ConfigModule | null = null;
+let _utils: Utils | null = null;
+let _contextLoader: ContextLoader | null = null;
+
+function getConfig(): ConfigModule {
+  if (!_config) {
+    _config = require('./config') as ConfigModule;
+  }
+  return _config;
+}
+
+function getUtils(): Utils {
+  if (!_utils) {
+    _utils = require('./utils') as Utils;
+  }
+  return _utils;
+}
+
+function getContextLoader(): ContextLoader {
+  if (!_contextLoader) {
+    _contextLoader = require('./context-loader') as ContextLoader;
+  }
+  return _contextLoader;
+}
+
+/**
+ * Action types and their log directories
+ */
+export const ACTION_TYPES: Record<string, string> = {
+  agent: 'agents',
+  code: 'code',
+  decision: 'decisions',
+  fix: 'fixes',
+  business: 'business',
+  meeting: 'meetings'
+};
+
+/**
+ * Get the logs directory path
+ */
+export function getLogsDir(projectRoot: string, actionType: string | null = null): string {
+  const baseDir = path.join(projectRoot, '.bootspring', 'logs');
+  if (actionType && ACTION_TYPES[actionType]) {
+    return path.join(baseDir, ACTION_TYPES[actionType]!);
+  }
+  return baseDir;
+}
+
+/**
+ * Generate a unique log filename
+ */
+export function generateFilename(actionType: string, identifier: string | null = null): string {
+  const utils = getUtils();
+  const date = utils.formatDate();
+  const timePart = new Date().toISOString().split('T')[1];
+  const time = timePart ? timePart.slice(0, 8).replace(/:/g, '-') : '00-00-00';
+  const id = identifier ? `-${utils.slugify(identifier)}` : '';
+  return `${date}-${time}${id}.md`;
+}
+
+/**
+ * Generate markdown content for an action
+ */
+function generateMarkdown(action: Action): string {
+  const timestamp = new Date().toISOString();
+  const lines: string[] = [];
+
+  // Header
+  const title = action.title || `${action.type} Action`;
+  lines.push(`# ${title}`);
+  lines.push('');
+  lines.push(`**Date**: ${timestamp}`);
+  lines.push(`**Type**: ${action.type}`);
+
+  if (action.agent) {
+    lines.push(`**Agent**: ${action.agent}`);
+  }
+
+  lines.push('');
+
+  // Input section
+  if (action.input) {
+    lines.push('## Input');
+    lines.push('');
+    lines.push(action.input);
+    lines.push('');
+  }
+
+  // Output section
+  if (action.output) {
+    lines.push('## Output');
+    lines.push('');
+    lines.push(action.output);
+    lines.push('');
+  }
+
+  // Files affected
+  if (action.files && action.files.length > 0) {
+    lines.push('## Files Affected');
+    lines.push('');
+    for (const file of action.files) {
+      lines.push(`- ${file}`);
+    }
+    lines.push('');
+  }
+
+  // Context used
+  if (action.context && action.context.length > 0) {
+    lines.push('## Context Used');
+    lines.push('');
+    for (const ctx of action.context) {
+      lines.push(`- ${ctx}`);
+    }
+    lines.push('');
+  }
+
+  // Decision-specific sections
+  if (action.type === 'decision') {
+    if (action.options) {
+      lines.push('## Options Considered');
+      lines.push('');
+      for (const opt of action.options) {
+        lines.push(`- ${opt}`);
+      }
+      lines.push('');
+    }
+
+    if (action.rationale) {
+      lines.push('## Rationale');
+      lines.push('');
+      lines.push(action.rationale);
+      lines.push('');
+    }
+  }
+
+  // Fix-specific sections
+  if (action.type === 'fix') {
+    if (action.problem) {
+      lines.push('## Problem');
+      lines.push('');
+      lines.push(action.problem);
+      lines.push('');
+    }
+
+    if (action.solution) {
+      lines.push('## Solution');
+      lines.push('');
+      lines.push(action.solution);
+      lines.push('');
+    }
+
+    if (action.prevention) {
+      lines.push('## Prevention');
+      lines.push('');
+      lines.push(action.prevention);
+      lines.push('');
+    }
+  }
+
+  // Metadata
+  if (action.metadata && Object.keys(action.metadata).length > 0) {
+    lines.push('## Metadata');
+    lines.push('');
+    lines.push('```json');
+    lines.push(JSON.stringify(action.metadata, null, 2));
+    lines.push('```');
+    lines.push('');
+  }
+
+  // Footer
+  lines.push('---');
+  lines.push('');
+  lines.push('*Automatically recorded by Bootspring*');
+
+  return lines.join('\n');
+}
+
+/**
+ * Update the logs index
+ */
+function updateIndex(projectRoot: string, entry: IndexEntry): void {
+  const utils = getUtils();
+  const indexPath = path.join(projectRoot, '.bootspring', 'logs', 'index.json');
+
+  let index: LogIndex = { version: '1.0', entries: [] };
+
+  // Load existing index
+  if (utils.fileExists(indexPath)) {
+    try {
+      const content = utils.readFile(indexPath);
+      if (content) {
+        index = JSON.parse(content) as LogIndex;
+      }
+    } catch {
+      // Keep default index
+    }
+  }
+
+  // Add new entry
+  index.entries.unshift(entry);
+
+  // Limit to last 1000 entries
+  if (index.entries.length > 1000) {
+    index.entries = index.entries.slice(0, 1000);
+  }
+
+  index.lastUpdated = new Date().toISOString();
+
+  // Save index
+  utils.writeFile(indexPath, JSON.stringify(index, null, 2));
+}
+
+/**
+ * Record an action
+ */
+export function record(action: Action, options: RecordOptions = {}): RecordResult {
+  const config = getConfig();
+  const utils = getUtils();
+  const contextLoader = getContextLoader();
+
+  const cfg = options.config || config.load();
+  const projectRoot = cfg?._projectRoot || process.cwd();
+
+  // Ensure directories exist
+  contextLoader.ensureDirectories(projectRoot);
+
+  const actionType = action.type || 'agent';
+  const logsDir = getLogsDir(projectRoot, actionType);
+  const identifier = action.agent || action.title || actionType;
+  const filename = generateFilename(actionType, identifier);
+  const filepath = path.join(logsDir, filename);
+
+  // Generate markdown content
+  const content = generateMarkdown(action);
+
+  // Write the log file
+  const success = utils.writeFile(filepath, content);
+
+  if (success) {
+    // Update the logs index
+    updateIndex(projectRoot, {
+      type: actionType,
+      filename,
+      timestamp: new Date().toISOString(),
+      agent: action.agent,
+      title: action.title,
+      files: action.files
+    });
+  }
+
+  return {
+    success,
+    path: filepath,
+    filename,
+    relativePath: path.relative(projectRoot, filepath)
+  };
+}
+
+/**
+ * List recent actions
+ */
+export function list(options: ListOptions = {}): IndexEntry[] {
+  const config = getConfig();
+  const utils = getUtils();
+
+  const cfg = options.config || config.load();
+  const projectRoot = cfg?._projectRoot || process.cwd();
+  const limit = options.limit || 20;
+  const offset = options.offset || 0;
+  const filterType = options.type;
+
+  const indexPath = path.join(projectRoot, '.bootspring', 'logs', 'index.json');
+
+  if (!utils.fileExists(indexPath)) {
+    return [];
+  }
+
+  try {
+    const content = utils.readFile(indexPath);
+    if (!content) return [];
+
+    const index = JSON.parse(content) as LogIndex;
+    let entries = index.entries || [];
+
+    // Filter by type
+    if (filterType) {
+      entries = entries.filter(e => e.type === filterType);
+    }
+
+    // Apply pagination
+    return entries.slice(offset, offset + limit);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Search action logs
+ */
+export function search(query: string, options: SearchOptions = {}): SearchResult[] {
+  const config = getConfig();
+  const utils = getUtils();
+
+  const cfg = options.config || config.load();
+  const projectRoot = cfg?._projectRoot || process.cwd();
+  const types = options.types || Object.keys(ACTION_TYPES);
+  const limit = options.limit || 20;
+  const results: SearchResult[] = [];
+  const queryLower = query.toLowerCase();
+
+  for (const type of types) {
+    const logsDir = getLogsDir(projectRoot, type);
+
+    if (!utils.fileExists(logsDir)) continue;
+
+    try {
+      const files = fs.readdirSync(logsDir)
+        .filter(f => f.endsWith('.md'))
+        .sort()
+        .reverse(); // Most recent first
+
+      for (const file of files) {
+        const filepath = path.join(logsDir, file);
+        const content = utils.readFile(filepath);
+
+        if (content && content.toLowerCase().includes(queryLower)) {
+          const lines = content.split('\n');
+          const matchingLines = lines
+            .map((line, i) => ({ line, num: i + 1 }))
+            .filter(l => l.line.toLowerCase().includes(queryLower))
+            .slice(0, 3);
+
+          results.push({
+            type,
+            file,
+            path: filepath,
+            matches: matchingLines.map(m => ({
+              line: m.num,
+              preview: utils.truncate(m.line.trim(), 100)
+            }))
+          });
+
+          if (results.length >= limit) break;
+        }
+      }
+    } catch {
+      // Directory read error, skip
+    }
+
+    if (results.length >= limit) break;
+  }
+
+  return results;
+}
+
+/**
+ * Get a specific log entry
+ */
+export function get(filename: string, options: RecordOptions = {}): LogEntry | null {
+  const config = getConfig();
+  const utils = getUtils();
+
+  const cfg = options.config || config.load();
+  const projectRoot = cfg?._projectRoot || process.cwd();
+
+  // Search in all log directories
+  for (const type of Object.keys(ACTION_TYPES)) {
+    const logsDir = getLogsDir(projectRoot, type);
+    const filepath = path.join(logsDir, filename);
+
+    if (utils.fileExists(filepath)) {
+      const content = utils.readFile(filepath);
+      const stats = fs.statSync(filepath);
+
+      return {
+        type,
+        filename,
+        path: filepath,
+        relativePath: path.relative(projectRoot, filepath),
+        content: content || '',
+        metadata: {
+          size: stats.size,
+          modified: stats.mtime,
+          modifiedRelative: utils.formatRelativeTime(stats.mtime)
+        }
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get relevant past actions for an agent
+ */
+export function getRelevantForAgent(
+  agentName: string,
+  options: { config?: Config; keywords?: string[]; limit?: number } = {}
+): RelevantLog[] {
+  const config = getConfig();
+  const cfg = options.config || config.load();
+  const keywords = options.keywords || [];
+  const limit = options.limit || 5;
+
+  const results: RelevantLog[] = [];
+
+  // First, get agent's own past invocations
+  const agentLogs = list({
+    config: cfg || undefined,
+    type: 'agent',
+    limit: 10
+  }).filter(e => e.agent === agentName);
+
+  for (const entry of agentLogs.slice(0, 3)) {
+    const log = get(entry.filename, { config: cfg || undefined });
+    if (log) {
+      results.push({
+        ...log,
+        type: 'previous_invocation'
+      });
+    }
+  }
+
+  // Then, search for keyword-relevant actions
+  if (keywords.length > 0) {
+    for (const keyword of keywords) {
+      const matches = search(keyword, {
+        config: cfg || undefined,
+        types: ['code', 'decisions', 'fixes'],
+        limit: 3
+      });
+
+      for (const match of matches) {
+        if (!results.find(r => r.path === match.path)) {
+          const log = get(match.file, { config: cfg || undefined });
+          if (log) {
+            results.push({
+              ...log,
+              type: 'keyword_match',
+              keyword
+            });
+          }
+        }
+      }
+
+      if (results.length >= limit) break;
+    }
+  }
+
+  return results.slice(0, limit);
+}
+
+/**
+ * Export logs to a directory
+ */
+export function exportLogs(
+  outputDir: string,
+  options: { config?: Config; types?: string[] } = {}
+): ExportResult {
+  const config = getConfig();
+  const utils = getUtils();
+
+  const cfg = options.config || config.load();
+  const projectRoot = cfg?._projectRoot || process.cwd();
+  const types = options.types || Object.keys(ACTION_TYPES);
+  let count = 0;
+
+  utils.ensureDir(outputDir);
+
+  for (const type of types) {
+    const logsDir = getLogsDir(projectRoot, type);
+
+    if (!utils.fileExists(logsDir)) continue;
+
+    const typeDir = path.join(outputDir, ACTION_TYPES[type]!);
+    utils.ensureDir(typeDir);
+
+    try {
+      const files = fs.readdirSync(logsDir).filter(f => f.endsWith('.md'));
+
+      for (const file of files) {
+        const src = path.join(logsDir, file);
+        const dest = path.join(typeDir, file);
+        fs.copyFileSync(src, dest);
+        count++;
+      }
+    } catch {
+      // Directory read error, skip
+    }
+  }
+
+  return { success: true, count, outputDir };
+}
+
+/**
+ * Clear old logs
+ */
+export function clearOld(
+  options: { config?: Config; olderThanDays?: number; types?: string[] } = {}
+): ClearResult {
+  const config = getConfig();
+  const utils = getUtils();
+
+  const cfg = options.config || config.load();
+  const projectRoot = cfg?._projectRoot || process.cwd();
+  const olderThanDays = options.olderThanDays || 30;
+  const types = options.types || Object.keys(ACTION_TYPES);
+  let deleted = 0;
+
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
+
+  for (const type of types) {
+    const logsDir = getLogsDir(projectRoot, type);
+
+    if (!utils.fileExists(logsDir)) continue;
+
+    try {
+      const files = fs.readdirSync(logsDir).filter(f => f.endsWith('.md'));
+
+      for (const file of files) {
+        const filepath = path.join(logsDir, file);
+        const stats = fs.statSync(filepath);
+
+        if (stats.mtime < cutoffDate) {
+          fs.unlinkSync(filepath);
+          deleted++;
+        }
+      }
+    } catch {
+      // Directory read error, skip
+    }
+  }
+
+  return { success: true, deleted };
+}