ai-control-center 1.15.2

package/lib/utils/audit-logger.js

@@ -0,0 +1,232 @@
+/**
+ * Audit Logger — immutable, structured event log for all actions.
+ *
+ * Records every significant action (feature creation, reviews, deploys,
+ * AI calls, plugin execution, user commands) in .ai-workflow/audit.jsonl.
+ *
+ * Each entry is timestamped, typed, and includes contextual metadata.
+ * Append-only, never modified — provides a complete audit trail.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { getWorkflowDir } from './pipeline.js';
+
+// ─── Event Types ─────────────────────────────────────────────────────────────
+
+export const AUDIT_EVENTS = {
+  // Pipeline actions
+  FEATURE_CREATED:    'feature_created',
+  REVIEW_STARTED:     'review_started',
+  REVIEW_COMPLETED:   'review_completed',
+  FEATURE_APPROVED:   'feature_approved',
+  FEATURE_REJECTED:   'feature_rejected',
+  DEPLOY_STARTED:     'deploy_started',
+  DEPLOY_COMPLETED:   'deploy_completed',
+  CLEANUP_EXECUTED:   'cleanup_executed',
+  PIPELINE_RESET:     'pipeline_reset',
+  BUG_FIX_STARTED:    'bug_fix_started',
+
+  // AI interactions
+  AI_CALL_STARTED:    'ai_call_started',
+  AI_CALL_COMPLETED:  'ai_call_completed',
+  AI_CALL_FAILED:     'ai_call_failed',
+  AI_RATE_LIMIT:      'ai_rate_limit',
+  AI_MODEL_BANNED:    'ai_model_banned',
+  AI_FALLBACK:        'ai_fallback',
+
+  // User interactions
+  USER_COMMAND:       'user_command',
+  USER_ASK_AI:        'user_ask_ai',
+  AUTOPILOT_TOGGLED:  'autopilot_toggled',
+
+  // Plugin system
+  PLUGIN_LOADED:      'plugin_loaded',
+  PLUGIN_EXECUTED:    'plugin_executed',
+  PLUGIN_ERROR:       'plugin_error',
+
+  // System
+  SERVICE_STARTED:    'service_started',
+  SERVICE_STOPPED:    'service_stopped',
+  CONFIG_LOADED:      'config_loaded',
+  ERROR:              'error',
+};
+
+// ─── Core Functions ──────────────────────────────────────────────────────────
+
+/**
+ * Get the audit file path.
+ */
+function getAuditFile() {
+  const dir = getWorkflowDir();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return resolve(dir, 'audit.jsonl');
+}
+
+/**
+ * Write an audit entry.
+ *
+ * @param {string} event    - Event type from AUDIT_EVENTS
+ * @param {object} data     - Event-specific data
+ * @param {object} options
+ * @param {string} options.source   - 'cli' | 'web' | 'telegram' | 'twitch' | 'system'
+ * @param {string} options.actor    - Who triggered the action (userId, 'autopilot', 'system')
+ * @param {string} options.featureId - Associated feature ID
+ * @returns {object|null} The audit entry, or null on error
+ */
+export function audit(event, data = {}, options = {}) {
+  try {
+    const entry = {
+      ts: new Date().toISOString(),
+      event,
+      source: options.source || 'system',
+      actor: options.actor || 'system',
+      featureId: options.featureId || data.featureId || null,
+      data,
+    };
+
+    const auditFile = getAuditFile();
+    appendFileSync(auditFile, JSON.stringify(entry) + '\n', 'utf8');
+
+    return entry;
+  } catch {
+    // Non-fatal — never crash the pipeline for audit logging
+    return null;
+  }
+}
+
+/**
+ * Read audit entries with optional filters.
+ *
+ * @param {object} filters
+ * @param {string}   filters.event     - Filter by event type
+ * @param {string}   filters.source    - Filter by source
+ * @param {string}   filters.actor     - Filter by actor
+ * @param {string}   filters.featureId - Filter by feature
+ * @param {number}   filters.last      - Only last N entries
+ * @param {string}   filters.since     - ISO date string — entries after this time
+ * @returns {Array} Parsed audit entries
+ */
+export function getAuditEntries(filters = {}) {
+  try {
+    const auditFile = getAuditFile();
+    if (!existsSync(auditFile)) return [];
+
+    let entries = readFileSync(auditFile, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map(line => {
+        try { return JSON.parse(line); }
+        catch { return null; }
+      })
+      .filter(Boolean);
+
+    if (filters.event)     entries = entries.filter(e => e.event === filters.event);
+    if (filters.source)    entries = entries.filter(e => e.source === filters.source);
+    if (filters.actor)     entries = entries.filter(e => e.actor === filters.actor);
+    if (filters.featureId) entries = entries.filter(e => e.featureId === filters.featureId);
+    if (filters.since)     entries = entries.filter(e => e.ts >= filters.since);
+    if (filters.last)      entries = entries.slice(-filters.last);
+
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get audit summary — counts by event type, recent activity.
+ *
+ * @returns {object} Summary with counts and recent entries
+ */
+export function getAuditSummary() {
+  const entries = getAuditEntries();
+
+  const summary = {
+    totalEntries: entries.length,
+    byEvent: {},
+    bySource: {},
+    recentEntries: entries.slice(-20),
+  };
+
+  for (const entry of entries) {
+    summary.byEvent[entry.event] = (summary.byEvent[entry.event] || 0) + 1;
+    summary.bySource[entry.source] = (summary.bySource[entry.source] || 0) + 1;
+  }
+
+  return summary;
+}
+
+/**
+ * Format audit entries for display.
+ *
+ * @param {Array}  entries - From getAuditEntries()
+ * @param {string} format  - 'text' | 'html'
+ * @returns {string}
+ */
+export function formatAuditEntries(entries, format = 'text') {
+  if (!entries || entries.length === 0) {
+    return format === 'html'
+      ? '<i>No audit entries found.</i>'
+      : 'No audit entries found.';
+  }
+
+  if (format === 'html') {
+    let html = `📋 <b>Audit Log</b> (${entries.length} entries)\n\n`;
+    for (const e of entries.slice(-15)) {
+      const time = new Date(e.ts).toLocaleTimeString();
+      const icon = getEventIcon(e.event);
+      html += `${icon} <code>${time}</code> ${e.event}`;
+      if (e.featureId) html += ` [${e.featureId}]`;
+      if (e.source !== 'system') html += ` via ${e.source}`;
+      html += '\n';
+    }
+    return html;
+  }
+
+  // Plain text
+  let text = `\n📋 Audit Log (${entries.length} entries)\n${'─'.repeat(50)}\n`;
+  for (const e of entries.slice(-20)) {
+    const time = new Date(e.ts).toLocaleTimeString();
+    const icon = getEventIcon(e.event);
+    text += `${icon} ${time}  ${e.event.padEnd(22)} `;
+    if (e.featureId) text += `[${e.featureId}] `;
+    if (e.source !== 'system') text += `(${e.source})`;
+    text += '\n';
+  }
+  return text;
+}
+
+/**
+ * Get emoji icon for event type.
+ */
+function getEventIcon(event) {
+  const icons = {
+    feature_created:   '🆕',
+    review_started:    '🔍',
+    review_completed:  '✅',
+    feature_approved:  '👍',
+    feature_rejected:  '👎',
+    deploy_started:    '🚀',
+    deploy_completed:  '🎯',
+    cleanup_executed:  '🧹',
+    pipeline_reset:    '🔄',
+    bug_fix_started:   '🐛',
+    ai_call_started:   '🤖',
+    ai_call_completed: '✨',
+    ai_call_failed:    '💥',
+    ai_rate_limit:     '⏳',
+    ai_model_banned:   '🚫',
+    ai_fallback:       '🔀',
+    user_command:      '👤',
+    user_ask_ai:       '💬',
+    autopilot_toggled: '🤖',
+    plugin_loaded:     '🔌',
+    plugin_executed:   '⚡',
+    plugin_error:      '⚠️',
+    service_started:   '🟢',
+    service_stopped:   '🔴',
+    config_loaded:     '⚙️',
+    error:             '❌',
+  };
+  return icons[event] || '📌';
+}

package/lib/utils/codebase-context.js

@@ -0,0 +1,288 @@
+/**
+ * Codebase Context Builder — creates structured context about the project
+ * for injection into AI prompts, enabling cross-session memory.
+ *
+ * Gathers: project tree, package.json summary, recent git commits,
+ * key file contents, and workflow state. Returns a structured context
+ * object that can be serialized into system prompts.
+ */
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { basename, join, relative, resolve } from 'path';
+import { getRootDir, getWorkflowDir } from './pipeline.js';
+
+// ─── Configuration ───────────────────────────────────────────────────────────
+
+const DEFAULT_OPTIONS = {
+  maxChars: 12000,           // Max total context chars (fits in most AI windows)
+  maxFileChars: 3000,        // Max chars per file content
+  maxTreeDepth: 3,           // Directory tree depth
+  maxCommits: 10,            // Recent git commits to include
+  includeGitHistory: true,
+  includeTree: true,
+  includePackageJson: true,
+  includeWorkflowState: true,
+  includeKeyFiles: true,
+  keyFilePatterns: [         // Files to always try to include
+    'README.md',
+    'package.json',
+    'aicc.config.js',
+    '.ai-workflow/status.json',
+  ],
+  ignoreDirs: [
+    'node_modules', '.git', 'dist', 'build', 'coverage',
+    '.next', '.nuxt', '__pycache__', '.venv', 'vendor',
+  ],
+  ignoreFiles: [
+    '.DS_Store', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml',
+  ],
+};
+
+// ─── Core Functions ──────────────────────────────────────────────────────────
+
+/**
+ * Build a comprehensive codebase context.
+ *
+ * @param {string} rootDir  - Project root (defaults to detected root)
+ * @param {object} options  - Override DEFAULT_OPTIONS
+ * @returns {object} Structured context object
+ */
+export function buildCodebaseContext(rootDir = null, options = {}) {
+  const root = rootDir || getRootDir();
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const context = { root, sections: [], charCount: 0 };
+
+  try {
+    // 1. Project identity
+    if (opts.includePackageJson) {
+      addPackageInfo(context, root, opts);
+    }
+
+    // 2. Directory tree
+    if (opts.includeTree) {
+      addDirectoryTree(context, root, opts);
+    }
+
+    // 3. Workflow state
+    if (opts.includeWorkflowState) {
+      addWorkflowState(context, opts);
+    }
+
+    // 4. Git history
+    if (opts.includeGitHistory) {
+      addGitHistory(context, root, opts);
+    }
+
+    // 5. Key files
+    if (opts.includeKeyFiles) {
+      addKeyFiles(context, root, opts);
+    }
+
+    return context;
+  } catch {
+    return context;
+  }
+}
+
+/**
+ * Serialize context to a string for AI prompt injection.
+ *
+ * @param {object} context - From buildCodebaseContext()
+ * @returns {string} Formatted context string
+ */
+export function serializeContext(context) {
+  if (!context || !context.sections || context.sections.length === 0) {
+    return '';
+  }
+
+  let output = '=== CODEBASE CONTEXT ===\n\n';
+
+  for (const section of context.sections) {
+    output += `--- ${section.title} ---\n`;
+    output += section.content + '\n\n';
+  }
+
+  output += '=== END CODEBASE CONTEXT ===\n';
+  return output;
+}
+
+/**
+ * Build and serialize context in one call — convenience method.
+ *
+ * @param {string} rootDir
+ * @param {object} options
+ * @returns {string}
+ */
+export function getContextString(rootDir = null, options = {}) {
+  const context = buildCodebaseContext(rootDir, options);
+  return serializeContext(context);
+}
+
+// ─── Section Builders ────────────────────────────────────────────────────────
+
+function addSection(context, title, content, opts) {
+  if (context.charCount + content.length > opts.maxChars) {
+    // Truncate to fit
+    const available = opts.maxChars - context.charCount;
+    if (available <= 100) return; // Not enough room
+    content = content.slice(0, available - 20) + '\n... [truncated]';
+  }
+  context.sections.push({ title, content });
+  context.charCount += content.length;
+}
+
+function addPackageInfo(context, root, opts) {
+  const pkgPath = join(root, 'package.json');
+  if (!existsSync(pkgPath)) return;
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const info = [
+      `Name: ${pkg.name || 'unknown'}`,
+      `Version: ${pkg.version || 'unknown'}`,
+      pkg.description ? `Description: ${pkg.description}` : null,
+      `Type: ${pkg.type || 'commonjs'}`,
+      pkg.scripts ? `Scripts: ${Object.keys(pkg.scripts).join(', ')}` : null,
+      pkg.dependencies ? `Dependencies: ${Object.keys(pkg.dependencies).join(', ')}` : null,
+      pkg.devDependencies ? `DevDependencies: ${Object.keys(pkg.devDependencies).join(', ')}` : null,
+    ].filter(Boolean).join('\n');
+
+    addSection(context, 'PROJECT', info, opts);
+  } catch { /* skip */ }
+}
+
+function addDirectoryTree(context, root, opts) {
+  try {
+    const tree = buildTree(root, opts.maxTreeDepth, opts);
+    if (tree) addSection(context, 'FILE STRUCTURE', tree, opts);
+  } catch { /* skip */ }
+}
+
+function buildTree(dir, depth, opts, prefix = '') {
+  if (depth <= 0) return '';
+
+  let result = '';
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+      .filter(e => {
+        if (opts.ignoreDirs.includes(e.name) && e.isDirectory()) return false;
+        if (opts.ignoreFiles.includes(e.name)) return false;
+        if (e.name.startsWith('.') && e.name !== '.ai-workflow') return false;
+        return true;
+      })
+      .sort((a, b) => {
+        // Dirs first, then files
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const isLast = i === entries.length - 1;
+      const connector = isLast ? '└── ' : '├── ';
+      const childPrefix = isLast ? '    ' : '│   ';
+
+      if (entry.isDirectory()) {
+        result += `${prefix}${connector}${entry.name}/\n`;
+        result += buildTree(join(dir, entry.name), depth - 1, opts, prefix + childPrefix);
+      } else {
+        result += `${prefix}${connector}${entry.name}\n`;
+      }
+    }
+  } catch { /* skip */ }
+
+  return result;
+}
+
+function addWorkflowState(context, opts) {
+  try {
+    const wfDir = getWorkflowDir();
+    const statusFile = join(wfDir, 'status.json');
+    if (!existsSync(statusFile)) return;
+
+    const status = JSON.parse(readFileSync(statusFile, 'utf8'));
+    const lines = [
+      `Current Stage: ${status.currentStage || 'idle'}`,
+      status.featureId ? `Feature: ${status.featureId}` : null,
+      status.featureName ? `Feature Name: ${status.featureName}` : null,
+      status.lastUpdated ? `Last Updated: ${status.lastUpdated}` : null,
+      status.autopilot !== undefined ? `Autopilot: ${status.autopilot ? 'ON' : 'OFF'}` : null,
+    ].filter(Boolean).join('\n');
+
+    addSection(context, 'WORKFLOW STATE', lines, opts);
+  } catch { /* skip */ }
+}
+
+function addGitHistory(context, root, opts) {
+  try {
+    const log = execSync(
+      `git log --oneline --no-decorate -n ${opts.maxCommits}`,
+      { cwd: root, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+
+    if (log) {
+      // Also get current branch
+      let branch = '';
+      try {
+        branch = execSync('git branch --show-current', {
+          cwd: root, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+      } catch { /* skip */ }
+
+      let content = branch ? `Branch: ${branch}\n\nRecent commits:\n` : 'Recent commits:\n';
+      content += log;
+
+      addSection(context, 'GIT HISTORY', content, opts);
+    }
+  } catch { /* skip — not a git repo */ }
+}
+
+function addKeyFiles(context, root, opts) {
+  for (const pattern of opts.keyFilePatterns) {
+    if (context.charCount >= opts.maxChars) break;
+
+    const filePath = resolve(root, pattern);
+    if (!existsSync(filePath)) continue;
+
+    try {
+      const stat = statSync(filePath);
+      if (stat.size > opts.maxFileChars * 4) continue; // Skip very large files
+
+      let content = readFileSync(filePath, 'utf8');
+      if (content.length > opts.maxFileChars) {
+        content = content.slice(0, opts.maxFileChars) + '\n... [truncated]';
+      }
+
+      // Use relative path as section title
+      const relPath = relative(root, filePath);
+      addSection(context, `FILE: ${relPath}`, content, opts);
+    } catch { /* skip */ }
+  }
+}
+
+/**
+ * Get a quick project summary (lightweight version of full context).
+ *
+ * @param {string} rootDir
+ * @returns {string} One-paragraph project description
+ */
+export function getProjectSummary(rootDir = null) {
+  const root = rootDir || getRootDir();
+
+  try {
+    const pkgPath = join(root, 'package.json');
+    if (!existsSync(pkgPath)) return `Project at ${basename(root)}`;
+
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const parts = [
+      pkg.name ? `${pkg.name}` : basename(root),
+      pkg.version ? `v${pkg.version}` : null,
+      pkg.description ? `— ${pkg.description}` : null,
+    ].filter(Boolean);
+
+    return parts.join(' ');
+  } catch {
+    return `Project at ${basename(root)}`;
+  }
+}