baseguard 1.0.0

package/tests/e2e/git-integration.e2e.test.ts

@@ -0,0 +1,487 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync, spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TEST_TIMEOUT = 45000; // 45 seconds for git operations
+const TEMP_DIR = path.join(__dirname, '../temp-git');
+
+// Helper function to run git commands
+function runGit(args: string[], cwd: string): string {
+  try {
+    return execSync(`git ${args.join(' ')}`, { 
+      cwd, 
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+  } catch (error: any) {
+    throw new Error(`Git command failed: ${error.message}`);
+  }
+}
+
+// Helper function to run BaseGuard commands
+async function runBaseGuard(args: string[], cwd: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise((resolve) => {
+    const basePath = path.join(__dirname, '../../bin/base.js');
+    const child = spawn('node', [basePath, ...args], {
+      cwd,
+      stdio: 'pipe',
+      env: { ...process.env, NODE_ENV: 'test' }
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code || 0
+      });
+    });
+
+    setTimeout(() => {
+      child.kill();
+      resolve({ stdout, stderr, exitCode: 1 });
+    }, TEST_TIMEOUT);
+  });
+}
+
+// Helper function to setup git repository
+async function setupGitRepo(repoPath: string): Promise<void> {
+  await fs.mkdir(repoPath, { recursive: true });
+  
+  // Initialize git repo
+  runGit(['init'], repoPath);
+  runGit(['config', 'user.name', 'Test User'], repoPath);
+  runGit(['config', 'user.email', 'test@example.com'], repoPath);
+  
+  // Create initial commit
+  await fs.writeFile(path.join(repoPath, 'README.md'), '# Test Project\n');
+  runGit(['add', 'README.md'], repoPath);
+  runGit(['commit', '-m', 'Initial commit'], repoPath);
+}
+
+// Helper function to create test files with violations
+async function createTestFiles(repoPath: string): Promise<void> {
+  // Create a file with modern features that will trigger violations
+  const jsContent = `
+// Modern JavaScript features
+const data = { test: 'value' };
+const cloned = structuredClone(data);
+const observer = new ResizeObserver(() => {});
+
+// Dialog API usage
+const dialog = document.querySelector('dialog');
+if (dialog) {
+  dialog.showModal();
+}
+`;
+
+  const cssContent = `
+.container {
+  container-type: inline-size;
+  aspect-ratio: 16/9;
+  backdrop-filter: blur(10px);
+}
+
+@container (min-width: 400px) {
+  .container {
+    font-size: 1.2rem;
+  }
+}
+
+.modern-selector:has(dialog[open]) {
+  background: color-mix(in srgb, red 50%, blue);
+}
+`;
+
+  await fs.writeFile(path.join(repoPath, 'test.js'), jsContent);
+  await fs.writeFile(path.join(repoPath, 'test.css'), cssContent);
+}
+
+describe('Git Integration End-to-End Tests', () => {
+  beforeEach(async () => {
+    try {
+      await fs.rm(TEMP_DIR, { recursive: true, force: true });
+    } catch (error) {
+      // Directory might not exist
+    }
+    await fs.mkdir(TEMP_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(TEMP_DIR, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('Git Hook Installation', () => {
+    it('should install pre-commit hooks successfully', async () => {
+      const repoPath = path.join(TEMP_DIR, 'hook-install-test');
+      await setupGitRepo(repoPath);
+      
+      // Initialize BaseGuard with automation
+      const initResult = await runBaseGuard(['init'], repoPath);
+      expect(initResult.exitCode).toBe(0);
+      
+      // Install git hooks
+      const hookResult = await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      expect(hookResult.exitCode).toBe(0);
+      
+      // Check if hook files were created
+      const hookPath = path.join(repoPath, '.husky/pre-commit');
+      const hookExists = await fs.access(hookPath).then(() => true).catch(() => false);
+      expect(hookExists).toBe(true);
+      
+      if (hookExists) {
+        const hookContent = await fs.readFile(hookPath, 'utf8');
+        expect(hookContent).toContain('base automation run');
+      }
+    }, TEST_TIMEOUT);
+
+    it('should install pre-push hooks successfully', async () => {
+      const repoPath = path.join(TEMP_DIR, 'pre-push-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      const hookResult = await runBaseGuard(['automation', 'enable', '--trigger', 'pre-push'], repoPath);
+      expect(hookResult.exitCode).toBe(0);
+      
+      const hookPath = path.join(repoPath, '.husky/pre-push');
+      const hookExists = await fs.access(hookPath).then(() => true).catch(() => false);
+      expect(hookExists).toBe(true);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Pre-commit Hook Behavior', () => {
+    it('should block commits when violations are found', async () => {
+      const repoPath = path.join(TEMP_DIR, 'block-commit-test');
+      await setupGitRepo(repoPath);
+      
+      // Initialize BaseGuard and enable automation
+      await runBaseGuard(['init'], repoPath);
+      
+      // Create configuration that will find violations
+      const config = {
+        version: '1.0.0',
+        targets: [{ browser: 'safari', minVersion: '15' }],
+        automation: {
+          enabled: true,
+          trigger: 'pre-commit',
+          autoAnalyze: false,
+          autoFix: false,
+          blockCommit: true
+        }
+      };
+      await fs.writeFile(path.join(repoPath, '.baseguardrc.json'), JSON.stringify(config, null, 2));
+      
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      
+      // Create files with violations
+      await createTestFiles(repoPath);
+      runGit(['add', '.'], repoPath);
+      
+      // Try to commit - should fail
+      try {
+        runGit(['commit', '-m', 'Add files with violations'], repoPath);
+        expect.fail('Commit should have been blocked');
+      } catch (error: any) {
+        expect(error.message).toContain('Git command failed');
+      }
+    }, TEST_TIMEOUT);
+
+    it('should allow commits when no violations are found', async () => {
+      const repoPath = path.join(TEMP_DIR, 'allow-commit-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      // Create configuration targeting very old browsers (everything should pass)
+      const config = {
+        version: '1.0.0',
+        targets: [{ browser: 'chrome', minVersion: '120' }], // Very new browser
+        automation: {
+          enabled: true,
+          trigger: 'pre-commit',
+          blockCommit: true
+        }
+      };
+      await fs.writeFile(path.join(repoPath, '.baseguardrc.json'), JSON.stringify(config, null, 2));
+      
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      
+      // Create files without violations (for very new browsers)
+      await fs.writeFile(path.join(repoPath, 'safe.js'), 'console.log("Hello World");');
+      await fs.writeFile(path.join(repoPath, 'safe.css'), '.safe { color: red; }');
+      
+      runGit(['add', '.'], repoPath);
+      
+      // Commit should succeed
+      const commitOutput = runGit(['commit', '-m', 'Add safe files'], repoPath);
+      expect(commitOutput).toContain('Add safe files');
+    }, TEST_TIMEOUT);
+
+    it('should respect --no-verify flag', async () => {
+      const repoPath = path.join(TEMP_DIR, 'no-verify-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      const config = {
+        version: '1.0.0',
+        targets: [{ browser: 'safari', minVersion: '15' }],
+        automation: {
+          enabled: true,
+          trigger: 'pre-commit',
+          blockCommit: true
+        }
+      };
+      await fs.writeFile(path.join(repoPath, '.baseguardrc.json'), JSON.stringify(config, null, 2));
+      
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      
+      // Create files with violations
+      await createTestFiles(repoPath);
+      runGit(['add', '.'], repoPath);
+      
+      // Commit with --no-verify should succeed
+      const commitOutput = runGit(['commit', '--no-verify', '-m', 'Bypass BaseGuard'], repoPath);
+      expect(commitOutput).toContain('Bypass BaseGuard');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Auto-fix Mode', () => {
+    it('should automatically fix violations and include in commit', async () => {
+      const repoPath = path.join(TEMP_DIR, 'auto-fix-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      // Enable auto-fix mode (would require API keys in real scenario)
+      const config = {
+        version: '1.0.0',
+        targets: [{ browser: 'safari', minVersion: '15' }],
+        apiKeys: {
+          jules: 'test-key',
+          gemini: 'test-key'
+        },
+        automation: {
+          enabled: true,
+          trigger: 'pre-commit',
+          autoAnalyze: true,
+          autoFix: true,
+          blockCommit: false
+        }
+      };
+      await fs.writeFile(path.join(repoPath, '.baseguardrc.json'), JSON.stringify(config, null, 2));
+      
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      
+      // Create files with violations
+      await createTestFiles(repoPath);
+      runGit(['add', '.'], repoPath);
+      
+      // Note: This test would require mock API responses in a real scenario
+      // For now, we test that the automation runs without crashing
+      try {
+        runGit(['commit', '-m', 'Test auto-fix'], repoPath);
+      } catch (error: any) {
+        // Expected to fail due to missing API keys, but should not crash
+        expect(error.message).toContain('API') || expect(error.message).toContain('key');
+      }
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Pre-push Hook Behavior', () => {
+    it('should check violations before push', async () => {
+      const repoPath = path.join(TEMP_DIR, 'pre-push-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      const config = {
+        version: '1.0.0',
+        targets: [{ browser: 'safari', minVersion: '15' }],
+        automation: {
+          enabled: true,
+          trigger: 'pre-push',
+          blockCommit: true
+        }
+      };
+      await fs.writeFile(path.join(repoPath, '.baseguardrc.json'), JSON.stringify(config, null, 2));
+      
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-push'], repoPath);
+      
+      // Create and commit files with violations (bypassing pre-commit)
+      await createTestFiles(repoPath);
+      runGit(['add', '.'], repoPath);
+      runGit(['commit', '--no-verify', '-m', 'Add files with violations'], repoPath);
+      
+      // Create a remote repository simulation
+      const remoteRepo = path.join(TEMP_DIR, 'remote-repo');
+      await fs.mkdir(remoteRepo, { recursive: true });
+      runGit(['init', '--bare'], remoteRepo);
+      runGit(['remote', 'add', 'origin', remoteRepo], repoPath);
+      
+      // Try to push - should fail due to violations
+      try {
+        runGit(['push', 'origin', 'main'], repoPath);
+        expect.fail('Push should have been blocked');
+      } catch (error: any) {
+        expect(error.message).toContain('Git command failed');
+      }
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Automation Configuration', () => {
+    it('should enable and disable automation correctly', async () => {
+      const repoPath = path.join(TEMP_DIR, 'automation-config-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      // Enable automation
+      const enableResult = await runBaseGuard(['automation', 'enable'], repoPath);
+      expect(enableResult.exitCode).toBe(0);
+      
+      // Check configuration
+      const configPath = path.join(repoPath, '.baseguardrc.json');
+      const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
+      expect(config.automation.enabled).toBe(true);
+      
+      // Disable automation
+      const disableResult = await runBaseGuard(['automation', 'disable'], repoPath);
+      expect(disableResult.exitCode).toBe(0);
+      
+      // Check configuration updated
+      const updatedConfig = JSON.parse(await fs.readFile(configPath, 'utf8'));
+      expect(updatedConfig.automation.enabled).toBe(false);
+    }, TEST_TIMEOUT);
+
+    it('should handle different trigger configurations', async () => {
+      const repoPath = path.join(TEMP_DIR, 'trigger-config-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      // Test pre-commit trigger
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      let config = JSON.parse(await fs.readFile(path.join(repoPath, '.baseguardrc.json'), 'utf8'));
+      expect(config.automation.trigger).toBe('pre-commit');
+      
+      // Test pre-push trigger
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-push'], repoPath);
+      config = JSON.parse(await fs.readFile(path.join(repoPath, '.baseguardrc.json'), 'utf8'));
+      expect(config.automation.trigger).toBe('pre-push');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Incremental Scanning', () => {
+    it('should only scan changed files in git workflow', async () => {
+      const repoPath = path.join(TEMP_DIR, 'incremental-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      
+      // Create multiple files
+      await fs.writeFile(path.join(repoPath, 'file1.js'), 'console.log("file1");');
+      await fs.writeFile(path.join(repoPath, 'file2.js'), 'console.log("file2");');
+      await createTestFiles(repoPath); // Creates files with violations
+      
+      runGit(['add', 'file1.js', 'file2.js'], repoPath);
+      runGit(['commit', '-m', 'Add safe files'], repoPath);
+      
+      // Now stage only the files with violations
+      runGit(['add', 'test.js', 'test.css'], repoPath);
+      
+      const config = {
+        version: '1.0.0',
+        targets: [{ browser: 'safari', minVersion: '15' }],
+        automation: {
+          enabled: true,
+          trigger: 'pre-commit',
+          blockCommit: true
+        }
+      };
+      await fs.writeFile(path.join(repoPath, '.baseguardrc.json'), JSON.stringify(config, null, 2));
+      
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      
+      // The automation should only check staged files
+      try {
+        runGit(['commit', '-m', 'Add files with violations'], repoPath);
+        expect.fail('Commit should have been blocked');
+      } catch (error: any) {
+        expect(error.message).toContain('Git command failed');
+      }
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Error Recovery', () => {
+    it('should handle corrupted git hooks gracefully', async () => {
+      const repoPath = path.join(TEMP_DIR, 'corrupted-hook-test');
+      await setupGitRepo(repoPath);
+      
+      await runBaseGuard(['init'], repoPath);
+      await runBaseGuard(['automation', 'enable', '--trigger', 'pre-commit'], repoPath);
+      
+      // Corrupt the hook file
+      const hookPath = path.join(repoPath, '.husky/pre-commit');
+      await fs.writeFile(hookPath, 'invalid shell script content {{{');
+      
+      // Create and stage files
+      await fs.writeFile(path.join(repoPath, 'test.js'), 'console.log("test");');
+      runGit(['add', '.'], repoPath);
+      
+      // Commit should either succeed (hook fails) or provide clear error
+      try {
+        const result = runGit(['commit', '-m', 'Test corrupted hook'], repoPath);
+        // If it succeeds, that's also acceptable behavior
+        expect(result).toContain('Test corrupted hook');
+      } catch (error: any) {
+        // If it fails, error should be about the hook, not BaseGuard crashing
+        expect(error.message).toContain('hook') || expect(error.message).toContain('script');
+      }
+    }, TEST_TIMEOUT);
+
+    it('should handle missing BaseGuard configuration in git workflow', async () => {
+      const repoPath = path.join(TEMP_DIR, 'missing-config-test');
+      await setupGitRepo(repoPath);
+      
+      // Install hooks without proper BaseGuard initialization
+      await fs.mkdir(path.join(repoPath, '.husky'), { recursive: true });
+      await fs.writeFile(
+        path.join(repoPath, '.husky/pre-commit'),
+        '#!/bin/sh\n. "$(dirname "$0")/_/husky.sh"\nbase automation run --trigger pre-commit'
+      );
+      
+      // Create and stage files
+      await fs.writeFile(path.join(repoPath, 'test.js'), 'console.log("test");');
+      runGit(['add', '.'], repoPath);
+      
+      // Should handle missing configuration gracefully
+      try {
+        runGit(['commit', '-m', 'Test missing config'], repoPath);
+      } catch (error: any) {
+        // Should provide helpful error about missing configuration
+        expect(error.message).toContain('configuration') || expect(error.message).toContain('init');
+      }
+    }, TEST_TIMEOUT);
+  });
+});

package/tests/fixtures/react-project/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "react-test-project",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "typescript": "^5.0.0"
+  }
+}

package/tests/fixtures/react-project/src/App.css

@@ -0,0 +1,76 @@
+/* Modern CSS features that may have compatibility issues */
+
+.app {
+  /* Container queries - baseline newly available */
+  container-type: inline-size;
+  container-name: app-container;
+  
+  /* Modern CSS properties */
+  aspect-ratio: 16/9;
+  accent-color: #007bff;
+  color-scheme: light dark;
+  
+  /* Modern CSS functions */
+  background: color-mix(in srgb, red 50%, blue);
+  
+  /* Backdrop filter - baseline newly available */
+  backdrop-filter: blur(10px);
+  
+  /* CSS Grid gap shorthand */
+  display: grid;
+  gap: 1rem;
+}
+
+/* Container query usage */
+@container app-container (min-width: 400px) {
+  .container-query-test {
+    font-size: 1.2rem;
+    color: green;
+  }
+}
+
+/* Modern CSS selectors */
+.app:has(dialog[open]) {
+  background-color: rgba(0, 0, 0, 0.1);
+}
+
+/* CSS nesting (very new feature) */
+.app {
+  .container-query-test {
+    padding: 1rem;
+    
+    &:hover {
+      background-color: #f0f0f0;
+    }
+  }
+}
+
+/* Modern CSS at-rules */
+@supports (container-type: inline-size) {
+  .app {
+    border: 2px solid green;
+  }
+}
+
+/* CSS custom properties with modern functions */
+:root {
+  --primary-color: oklch(0.7 0.15 200);
+  --secondary-color: color(display-p3 1 0 0);
+}
+
+/* Modern pseudo-classes */
+.app button:focus-visible {
+  outline: 2px solid var(--primary-color);
+}
+
+.app button:is(:hover, :focus) {
+  transform: scale(1.05);
+}
+
+/* Modern CSS units */
+.container-query-test {
+  width: min(100%, 50ch);
+  height: max(200px, 20vh);
+  margin-block: 1rem;
+  padding-inline: 2rem;
+}

package/tests/fixtures/react-project/src/App.tsx

@@ -0,0 +1,77 @@
+import React, { useState, useEffect } from 'react';
+import './App.css';
+
+// Component using modern web features that may have compatibility issues
+const App: React.FC = () => {
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [resizeObserver, setResizeObserver] = useState<ResizeObserver | null>(null);
+
+  useEffect(() => {
+    // Modern JavaScript API - ResizeObserver (baseline newly available)
+    const observer = new ResizeObserver((entries) => {
+      console.log('Element resized:', entries);
+    });
+    setResizeObserver(observer);
+
+    // Modern JavaScript API - structuredClone (baseline newly available)
+    const data = { name: 'test', nested: { value: 42 } };
+    const cloned = structuredClone(data);
+    console.log('Cloned data:', cloned);
+
+    // Modern Array method - Array.at() (baseline newly available)
+    const items = [1, 2, 3, 4, 5];
+    const lastItem = items.at(-1);
+    console.log('Last item:', lastItem);
+
+    return () => {
+      observer.disconnect();
+    };
+  }, []);
+
+  const openDialog = () => {
+    // Modern HTML API - HTMLDialogElement.showModal() (baseline newly available)
+    const dialog = document.querySelector('dialog');
+    if (dialog) {
+      dialog.showModal();
+    }
+    setDialogOpen(true);
+  };
+
+  const closeDialog = () => {
+    const dialog = document.querySelector('dialog');
+    if (dialog) {
+      dialog.close();
+    }
+    setDialogOpen(false);
+  };
+
+  // Canvas API usage (widely supported but good test case)
+  const drawCanvas = () => {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    if (ctx) {
+      // Modern Canvas API - filter property (baseline newly available)
+      ctx.filter = 'blur(5px)';
+      ctx.fillRect(0, 0, 100, 100);
+    }
+  };
+
+  return (
+    <div className="app">
+      <h1>React Test App</h1>
+      <button onClick={openDialog}>Open Dialog</button>
+      <button onClick={drawCanvas}>Draw Canvas</button>
+      
+      <dialog open={dialogOpen}>
+        <p>This is a modern dialog element</p>
+        <button onClick={closeDialog}>Close</button>
+      </dialog>
+
+      <div className="container-query-test">
+        <p>Container with modern CSS</p>
+      </div>
+    </div>
+  );
+};
+
+export default App;

package/tests/fixtures/svelte-project/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "svelte-test-project",
+  "version": "1.0.0",
+  "private": true,
+  "dependencies": {
+    "svelte": "^4.2.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}