@hatem427/code-guard-ci 1.0.0

package/scripts/delete-bypass-logs.ts

@@ -0,0 +1,253 @@
+#!/usr/bin/env ts-node
+/**
+ * ============================================================================
+ * delete-bypass-logs.ts — Delete bypass log entries (ADMIN ONLY)
+ * ============================================================================
+ *
+ * Requires admin password to delete entries from bypass log.
+ * Deleted entries are automatically archived for audit trail.
+ *
+ * Usage:
+ *   npm run delete-bypass-logs
+ *   npm run delete-bypass-logs -- --id="entry-uuid"
+ *   npm run delete-bypass-logs -- --author="john@example.com"
+ *   npm run delete-bypass-logs -- --before="2024-01-01"
+ */
+
+import { 
+  deleteBypassEntries, 
+  getBypassesByAuthor, 
+  getRecentBypasses 
+} from './utils/bypass-manager';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface BypassEntry {
+  id: string;
+  author: string;
+  email: string;
+  timestamp: string;
+  reason: string;
+  commitMessage: string;
+  commitHash?: string;
+  branch: string;
+  files: string[];
+  method: 'commit-message' | 'env-variable' | 'password';
+}
+
+function promptPassword(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const stdin = process.stdin as any;
+    stdin.setRawMode(true);
+    
+    let password = '';
+    process.stdout.write(question);
+    
+    stdin.on('data', (char: Buffer) => {
+      const str = char.toString('utf-8');
+      
+      if (str === '\n' || str === '\r' || str === '\u0004') {
+        stdin.setRawMode(false);
+        process.stdout.write('\n');
+        rl.close();
+        resolve(password);
+      } else if (str === '\u0003') {
+        // Ctrl+C
+        process.exit(1);
+      } else if (str === '\u007f' || str === '\b') {
+        // Backspace
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          process.stdout.write('\b \b');
+        }
+      } else {
+        password += str;
+        process.stdout.write('*');
+      }
+    });
+  });
+}
+
+function promptConfirmation(question: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+
+function parseArgs(): { id?: string; author?: string; before?: string } {
+  const args = process.argv.slice(2);
+  const opts: { id?: string; author?: string; before?: string } = {};
+
+  for (const arg of args) {
+    const [key, ...valueParts] = arg.replace(/^--/, '').split('=');
+    const value = valueParts.join('=').replace(/^["']|["']$/g, '');
+
+    switch (key) {
+      case 'id':
+        opts.id = value;
+        break;
+      case 'author':
+        opts.author = value;
+        break;
+      case 'before':
+        opts.before = value;
+        break;
+    }
+  }
+
+  return opts;
+}
+
+function loadBypassLog(): BypassEntry[] {
+  const logPath = path.join(process.cwd(), '.code-guardian', 'bypass-log.json');
+  
+  if (!fs.existsSync(logPath)) {
+    return [];
+  }
+
+  try {
+    const content = fs.readFileSync(logPath, 'utf-8');
+    const log = JSON.parse(content);
+    return log.entries || [];
+  } catch {
+    return [];
+  }
+}
+
+async function main() {
+  console.log('🗑️  Code Guardian — Delete Bypass Logs (ADMIN ONLY)\n');
+  console.log('⚠️  WARNING: This operation requires admin authentication.');
+  console.log('   Deleted entries will be archived for audit purposes.\n');
+
+  const opts = parseArgs();
+  const allEntries = loadBypassLog();
+
+  if (allEntries.length === 0) {
+    console.log('ℹ️  No bypass entries found in the log.');
+    return;
+  }
+
+  let entriesToDelete: BypassEntry[] = [];
+
+  if (opts.id) {
+    // Delete specific entry by ID
+    const entry = allEntries.find((e) => e.id === opts.id);
+    if (!entry) {
+      console.error(`❌ Entry with ID "${opts.id}" not found.`);
+      process.exit(1);
+    }
+    entriesToDelete = [entry];
+    console.log(`Found entry to delete:`);
+    console.log(`  • ID: ${entry.id}`);
+    console.log(`  • Author: ${entry.author} <${entry.email}>`);
+    console.log(`  • Date: ${new Date(entry.timestamp).toLocaleString()}`);
+    console.log(`  • Reason: ${entry.reason}\n`);
+  } else if (opts.author) {
+    // Delete entries by author
+    entriesToDelete = allEntries.filter((e) => 
+      e.email === opts.author || e.author === opts.author
+    );
+    if (entriesToDelete.length === 0) {
+      console.error(`❌ No entries found for author "${opts.author}".`);
+      process.exit(1);
+    }
+    console.log(`Found ${entriesToDelete.length} entry(ies) by ${opts.author}:\n`);
+    entriesToDelete.forEach((entry) => {
+      console.log(`  • ${new Date(entry.timestamp).toLocaleString()} - ${entry.reason}`);
+    });
+    console.log('');
+  } else if (opts.before) {
+    // Delete entries before a certain date
+    const cutoffDate = new Date(opts.before);
+    if (isNaN(cutoffDate.getTime())) {
+      console.error(`❌ Invalid date format: "${opts.before}"`);
+      process.exit(1);
+    }
+    entriesToDelete = allEntries.filter((e) => new Date(e.timestamp) < cutoffDate);
+    if (entriesToDelete.length === 0) {
+      console.error(`❌ No entries found before ${cutoffDate.toLocaleDateString()}.`);
+      process.exit(1);
+    }
+    console.log(`Found ${entriesToDelete.length} entry(ies) before ${cutoffDate.toLocaleDateString()}:\n`);
+    entriesToDelete.slice(0, 5).forEach((entry) => {
+      console.log(`  • ${new Date(entry.timestamp).toLocaleString()} - ${entry.author}`);
+    });
+    if (entriesToDelete.length > 5) {
+      console.log(`  ... and ${entriesToDelete.length - 5} more\n`);
+    }
+  } else {
+    // Interactive mode: show all entries
+    console.log('Available entries:\n');
+    allEntries.forEach((entry, index) => {
+      console.log(`${index + 1}. ${new Date(entry.timestamp).toLocaleString()}`);
+      console.log(`   Author: ${entry.author} <${entry.email}>`);
+      console.log(`   Reason: ${entry.reason}`);
+      console.log(`   ID: ${entry.id}\n`);
+    });
+
+    const confirmed = await promptConfirmation(
+      'Enter entry number(s) to delete (comma-separated) or "all": '
+    );
+    
+    if (!confirmed) {
+      console.log('Operation cancelled.');
+      return;
+    }
+
+    // For simplicity in interactive mode, we'll just exit with instructions
+    console.log('\n📝 To delete specific entries, use:');
+    console.log('   npm run delete-bypass-logs -- --id="<entry-id>"');
+    console.log('   npm run delete-bypass-logs -- --author="<email>"');
+    console.log('   npm run delete-bypass-logs -- --before="YYYY-MM-DD"');
+    return;
+  }
+
+  // Confirm deletion
+  const confirmDelete = await promptConfirmation(
+    `❗ Are you sure you want to delete ${entriesToDelete.length} entry(ies)? (y/N): `
+  );
+
+  if (!confirmDelete) {
+    console.log('Operation cancelled.');
+    return;
+  }
+
+  // Request admin password
+  console.log('');
+  const adminPassword = await promptPassword('Enter admin password: ');
+
+  if (!adminPassword) {
+    console.error('\n❌ Password is required.');
+    process.exit(1);
+  }
+
+  // Attempt deletion
+  const entryIds = entriesToDelete.map((e) => e.id);
+  const result = deleteBypassEntries(entryIds, adminPassword);
+
+  console.log('\n' + result.message);
+
+  if (result.success) {
+    console.log(`📊 Remaining entries: ${allEntries.length - result.deletedCount}`);
+    console.log('📦 Deleted entries have been archived for audit purposes.');
+  }
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/scripts/generate-doc.ts

@@ -0,0 +1,317 @@
+/**
+ * ============================================================================
+ * generate-doc.ts — Feature documentation generator
+ * ============================================================================
+ *
+ * Generates Markdown feature documentation from templates.
+ * Supports multiple template types: ui, api, service.
+ *
+ * Usage:
+ *   npm run generate-doc -- --name="my-feature" --type=ui
+ *   npm run generate-doc -- --name="auth-api" --type=api
+ *   npm run generate-doc -- --name="user-service" --type=service
+ *
+ * Templates live in /templates/feature-doc-{type}.md
+ * Output goes to /docs/features/{name}.md
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from './utils/logger';
+import { analyzeComponent, findComponentFile, ComponentInfo } from './utils/code-analyzer';
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+type DocType = 'ui' | 'api' | 'service';
+
+interface DocOptions {
+  /** Feature name — used for file naming and placeholder replacement */
+  name: string;
+  /** Template type */
+  type: DocType;
+  /** Optional description to pre-fill */
+  description?: string;
+  /** Optional author */
+  author?: string;
+  /** Auto-analyze code and generate docs */
+  auto?: boolean;
+  /** File path for auto-analysis */
+  file?: string;
+}
+
+// ── Argument parsing ────────────────────────────────────────────────────────
+
+/**
+ * Parse CLI arguments into DocOptions.
+ * Expected format: --name="feature-name" --type=ui [--description="..."] [--author="..."]
+ */
+function parseArgs(): DocOptions {
+  const args = process.argv.slice(2);
+  const opts: Partial<DocOptions> = {};
+
+  for (const arg of args) {
+    const [key, ...valueParts] = arg.replace(/^--/, '').split('=');
+    const value = valueParts.join('=').replace(/^["']|["']$/g, ''); // Remove surrounding quotes
+
+    switch (key) {
+      case 'name':
+        opts.name = value;
+        break;
+      case 'type':
+        if (['ui', 'api', 'service'].includes(value)) {
+          opts.type = value as DocType;
+        } else {
+          logger.error(`Invalid type "${value}". Expected: ui, api, or service.`);
+          process.exit(1);
+        }
+        break;
+      case 'description':
+        opts.description = value;
+        break;
+      case 'author':
+        opts.author = value;
+        break;
+      case 'auto':
+        opts.auto = value === 'true' || value === '' || !value; // --auto or --auto=true
+        break;
+      case 'file':
+        opts.file = value;
+        break;
+    }
+  }
+
+  // Validate required fields
+  if (!opts.name) {
+    logger.error('Missing required argument: --name="feature-name"');
+    logger.dim('Usage: npm run generate-doc -- --name="my-feature" --type=ui');
+    process.exit(1);
+  }
+
+  if (!opts.type) {
+    logger.warn('No --type specified, defaulting to "ui".');
+    opts.type = 'ui';
+  }
+
+  return opts as DocOptions;
+}
+
+// ── Template processing ─────────────────────────────────────────────────────
+
+/**
+ * Load and process a template file, replacing placeholders with actual values.
+ *
+ * Supported placeholders:
+ *   {{FEATURE_NAME}}     — The feature name (kebab-case)
+ *   {{FEATURE_TITLE}}    — The feature name in Title Case
+ *   {{DATE}}             — Today's date in YYYY-MM-DD format
+ *   {{AUTHOR}}           — Author name (or "Team" if not provided)
+ *   {{DESCRIPTION}}      — Pre-filled description (or placeholder text)
+ *   {{DOC_TYPE}}         — The template type (ui, api, service)
+ */
+function processTemplate(templatePath: string, opts: DocOptions): string {
+  if (!fs.existsSync(templatePath)) {
+    logger.error(`Template not found: ${templatePath}`);
+    logger.dim('Available templates:');
+    logger.dim('  templates/feature-doc-ui.md');
+    logger.dim('  templates/feature-doc-api.md');
+    logger.dim('  templates/feature-doc-service.md');
+    process.exit(1);
+  }
+
+  let content = fs.readFileSync(templatePath, 'utf-8');
+
+  // Convert kebab-case to Title Case
+  const titleCase = opts.name
+    .split('-')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+
+  // Today's date
+  const today = new Date().toISOString().split('T')[0];
+
+  // Replace all placeholders
+  const replacements: Record<string, string> = {
+    '{{FEATURE_NAME}}': opts.name,
+    '{{FEATURE_TITLE}}': titleCase,
+    '{{DATE}}': today,
+    '{{AUTHOR}}': opts.author || 'Team',
+    '{{DESCRIPTION}}': opts.description || 'TODO: Add feature description here.',
+    '{{DOC_TYPE}}': opts.type,
+  };
+
+  for (const [placeholder, value] of Object.entries(replacements)) {
+    content = content.replace(new RegExp(placeholder.replace(/[{}]/g, '\\$&'), 'g'), value);
+  }
+
+  return content;
+}
+
+/**
+ * Generate documentation automatically from code analysis
+ */
+function generateFromCode(componentInfo: ComponentInfo, opts: DocOptions): string {
+  const today = new Date().toISOString().split('T')[0];
+  const titleCase = componentInfo.name
+    .replace(/([A-Z])/g, ' $1')
+    .trim();
+
+  let doc = `# ${titleCase}\n\n`;
+  doc += `> **Type**: UI Component  \n`;
+  doc += `> **Created**: ${today}  \n`;
+  doc += `> **Author**: ${opts.author || 'Team'}  \n`;
+  doc += `> **Status**: ✅ Auto-generated\n\n`;
+  doc += `---\n\n`;
+
+  // Description
+  doc += `## 📝 Description\n\n`;
+  if (componentInfo.description) {
+    doc += `${componentInfo.description}\n\n`;
+  } else {
+    doc += `_Auto-generated from \`${path.basename(componentInfo.filePath)}\`_\n\n`;
+  }
+
+  // Usage
+  doc += `## 🚀 Usage\n\n`;
+  doc += `\`\`\`tsx\n`;
+  doc += `import { ${componentInfo.name} } from './${path.basename(componentInfo.filePath, path.extname(componentInfo.filePath))}';\n\n`;
+  
+  if (componentInfo.props.length > 0) {
+    doc += `<${componentInfo.name}\n`;
+    componentInfo.props.slice(0, 3).forEach(prop => {
+      const example = getExampleValue(prop.type);
+      doc += `  ${prop.name}={${example}}\n`;
+    });
+    if (componentInfo.props.length > 3) {
+      doc += `  // ... more props\n`;
+    }
+    doc += `/>\n`;
+  } else {
+    doc += `<${componentInfo.name} />\n`;
+  }
+  doc += `\`\`\`\n\n`;
+
+  // Props table
+  if (componentInfo.props.length > 0) {
+    doc += `## 📥 Props\n\n`;
+    doc += `| Name | Type | Required | Default | Description |\n`;
+    doc += `|------|------|----------|---------|-------------|\n`;
+    
+    componentInfo.props.forEach(prop => {
+      const req = prop.required ? '✅ Yes' : 'No';
+      const def = prop.defaultValue || '-';
+      const desc = prop.description || '-';
+      doc += `| \`${prop.name}\` | \`${prop.type}\` | ${req} | \`${def}\` | ${desc} |\n`;
+    });
+    doc += `\n`;
+  }
+
+  // Footer
+  doc += `## 📝 Notes\n\n`;
+  doc += `- Auto-generated from code analysis\n`;
+  doc += `- Source file: \`${componentInfo.filePath}\`\n`;
+  doc += `- Last analyzed: ${today}\n\n`;
+  doc += `---\n\n`;
+  doc += `_Generated by Code Guardian — Auto-analysis_\n`;
+
+  return doc;
+}
+
+/**
+ * Get example value for a type
+ */
+function getExampleValue(type: string): string {
+  if (type.includes('string')) return '"example"';
+  if (type.includes('number')) return '42';
+  if (type.includes('boolean')) return 'true';
+  if (type.includes('Function') || type.includes('=>')) return '{handleClick}';
+  if (type.includes('[]')) return '[]';
+  if (type.includes('{}') || type.includes('object')) return '{{}}';
+  return '...';
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+function main(): void {
+  logger.header('📄 Code Guardian — Feature Doc Generator');
+
+  const opts = parseArgs();
+
+  logger.info(`Generating "${opts.type}" doc for feature: "${opts.name}"`);
+
+  // Resolve paths
+  const rootDir = process.cwd();
+  const outputDir = path.join(rootDir, 'docs', 'features');
+  const outputPath = path.join(outputDir, `${opts.name}.md`);
+
+  // Create output directory if needed
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+    logger.dim(`Created directory: ${outputDir}`);
+  }
+
+  // Check if doc already exists
+  if (fs.existsSync(outputPath)) {
+    logger.warn(`Doc already exists: ${outputPath}`);
+    logger.warn('Overwriting with fresh content...');
+  }
+
+  let content: string;
+
+  // Auto-analyze mode
+  if (opts.auto) {
+    logger.info('Auto-analysis mode enabled — analyzing code...');
+    
+    // Find component file
+    let componentPath = opts.file;
+    if (!componentPath) {
+      logger.dim(`Searching for ${opts.name} component...`);
+      const foundPath = findComponentFile(opts.name, rootDir);
+      componentPath = foundPath || undefined;
+      
+      if (!componentPath) {
+        logger.error(`Could not find component file for "${opts.name}"`);
+        logger.dim('Use --file="path/to/component.tsx" to specify manually');
+        logger.dim('Or use template mode: remove --auto flag');
+        process.exit(1);
+      }
+      
+      logger.dim(`Found: ${componentPath}`);
+    }
+
+    // Analyze component
+    const componentInfo = analyzeComponent(componentPath);
+    
+    if (!componentInfo || !componentInfo.isReactComponent) {
+      logger.error(`Could not analyze component at ${componentPath}`);
+      logger.warn('Falling back to template mode...');
+      const templatePath = path.join(rootDir, 'templates', `feature-doc-${opts.type}.md`);
+      content = processTemplate(templatePath, opts);
+    } else {
+      logger.success(`Analyzed ${componentInfo.name} — found ${componentInfo.props.length} prop(s)`);
+      content = generateFromCode(componentInfo, opts);
+    }
+  } else {
+    // Template mode
+    const templatePath = path.join(rootDir, 'templates', `feature-doc-${opts.type}.md`);
+    content = processTemplate(templatePath, opts);
+  }
+
+  // Write output
+  fs.writeFileSync(outputPath, content, 'utf-8');
+
+  logger.success(`Feature doc generated: ${outputPath}`);
+  
+  if (!opts.auto) {
+    logger.dim('');
+    logger.dim('Next steps:');
+    logger.dim(`  1. Open ${outputPath} and fill in the details`);
+    logger.dim('  2. Add it to your commit');
+    logger.dim('  3. The PR checklist will verify doc completeness');
+    logger.dim('');
+    logger.dim('💡 Tip: Use --auto flag to auto-generate from code!');
+  }
+}
+
+// ── Execute ─────────────────────────────────────────────────────────────────
+
+main();