codeslick-cli 1.0.0

package/__tests__/config-loader.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Configuration Loader Tests
+ *
+ * Tests for loading, saving, and updating .codeslick.json configuration.
+ *
+ * Coverage:
+ * - Default configuration
+ * - Loading configuration from file
+ * - Saving configuration to file
+ * - Updating specific configuration values
+ * - Validation of configuration values
+ * - Error handling for invalid JSON
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  loadConfig,
+  saveConfig,
+  updateConfig,
+  configExists,
+  getConfigPath,
+  DEFAULT_CONFIG,
+  type CodeSlickConfig,
+} from '../src/config/config-loader';
+
+describe('Configuration Loader', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // Create temporary directory for each test
+    tempDir = mkdtempSync(join(tmpdir(), 'codeslick-test-'));
+  });
+
+  afterEach(() => {
+    // Clean up temporary directory
+    if (tempDir) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('Configuration Path', () => {
+    it('should return correct config path', () => {
+      const path = getConfigPath(tempDir);
+      expect(path).toBe(join(tempDir, '.codeslick.json'));
+    });
+
+    it('should use process.cwd() by default', () => {
+      const path = getConfigPath();
+      expect(path).toContain('.codeslick.json');
+    });
+  });
+
+  describe('Configuration Existence Check', () => {
+    it('should return false when config does not exist', () => {
+      expect(configExists(tempDir)).toBe(false);
+    });
+
+    it('should return true when config exists', async () => {
+      await saveConfig(DEFAULT_CONFIG, tempDir);
+      expect(configExists(tempDir)).toBe(true);
+    });
+  });
+
+  describe('Load Configuration', () => {
+    it('should return default config when file does not exist', async () => {
+      const config = await loadConfig(tempDir);
+      expect(config).toEqual(DEFAULT_CONFIG);
+    });
+
+    it('should load config from file', async () => {
+      const customConfig: CodeSlickConfig = {
+        ...DEFAULT_CONFIG,
+        severity: 'high',
+        autofix: true,
+      };
+
+      await saveConfig(customConfig, tempDir);
+      const loaded = await loadConfig(tempDir);
+
+      expect(loaded.severity).toBe('high');
+      expect(loaded.autofix).toBe(true);
+    });
+
+    it('should merge with defaults for missing fields', async () => {
+      // Create partial config (missing some fields)
+      const partialConfig = {
+        version: '1.0',
+        severity: 'high',
+      };
+
+      // Write partial config directly
+      const configPath = getConfigPath(tempDir);
+      const fs = await import('fs/promises');
+      await fs.writeFile(configPath, JSON.stringify(partialConfig), 'utf-8');
+
+      // Load should merge with defaults
+      const loaded = await loadConfig(tempDir);
+
+      expect(loaded.severity).toBe('high');
+      expect(loaded.autofix).toBe(DEFAULT_CONFIG.autofix);
+      expect(loaded.exclude).toEqual(DEFAULT_CONFIG.exclude);
+      expect(loaded.languages).toEqual(DEFAULT_CONFIG.languages);
+    });
+
+    it('should throw error for invalid JSON', async () => {
+      const configPath = getConfigPath(tempDir);
+      const fs = await import('fs/promises');
+      await fs.writeFile(configPath, 'invalid json{', 'utf-8');
+
+      await expect(loadConfig(tempDir)).rejects.toThrow('Failed to parse .codeslick.json');
+    });
+  });
+
+  describe('Save Configuration', () => {
+    it('should save config to file', async () => {
+      await saveConfig(DEFAULT_CONFIG, tempDir);
+
+      const fs = await import('fs/promises');
+      const configPath = getConfigPath(tempDir);
+      const content = await fs.readFile(configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+
+      expect(parsed).toEqual(DEFAULT_CONFIG);
+    });
+
+    it('should format JSON with 2-space indentation', async () => {
+      await saveConfig(DEFAULT_CONFIG, tempDir);
+
+      const fs = await import('fs/promises');
+      const configPath = getConfigPath(tempDir);
+      const content = await fs.readFile(configPath, 'utf-8');
+
+      // Check formatting (should have newlines and indentation)
+      expect(content).toContain('\n');
+      expect(content).toMatch(/^{\n  "version"/);
+    });
+
+    it('should overwrite existing config', async () => {
+      // Save initial config
+      await saveConfig(DEFAULT_CONFIG, tempDir);
+
+      // Save modified config
+      const modified: CodeSlickConfig = {
+        ...DEFAULT_CONFIG,
+        severity: 'high',
+      };
+      await saveConfig(modified, tempDir);
+
+      // Load and verify
+      const loaded = await loadConfig(tempDir);
+      expect(loaded.severity).toBe('high');
+    });
+  });
+
+  describe('Update Configuration', () => {
+    beforeEach(async () => {
+      // Create initial config file
+      await saveConfig(DEFAULT_CONFIG, tempDir);
+    });
+
+    it('should update severity', async () => {
+      await updateConfig('severity', 'high', tempDir);
+
+      const loaded = await loadConfig(tempDir);
+      expect(loaded.severity).toBe('high');
+    });
+
+    it('should reject invalid severity', async () => {
+      await expect(
+        updateConfig('severity', 'invalid', tempDir)
+      ).rejects.toThrow('Invalid severity value');
+    });
+
+    it('should update autofix', async () => {
+      await updateConfig('autofix', true, tempDir);
+
+      const loaded = await loadConfig(tempDir);
+      expect(loaded.autofix).toBe(true);
+    });
+
+    it('should reject invalid autofix value', async () => {
+      await expect(
+        updateConfig('autofix', 'yes', tempDir)
+      ).rejects.toThrow('Invalid autofix value');
+    });
+
+    it('should update exclude patterns', async () => {
+      const newPatterns = ['test/**', '*.min.js'];
+      await updateConfig('exclude', newPatterns, tempDir);
+
+      const loaded = await loadConfig(tempDir);
+      expect(loaded.exclude).toEqual(newPatterns);
+    });
+
+    it('should reject non-array exclude value', async () => {
+      await expect(
+        updateConfig('exclude', 'not-an-array', tempDir)
+      ).rejects.toThrow('Invalid exclude value');
+    });
+
+    it('should update languages', async () => {
+      const newLanguages = ['javascript', 'python'];
+      await updateConfig('languages', newLanguages, tempDir);
+
+      const loaded = await loadConfig(tempDir);
+      expect(loaded.languages).toEqual(newLanguages);
+    });
+
+    it('should reject invalid language', async () => {
+      await expect(
+        updateConfig('languages', ['javascript', 'ruby'], tempDir)
+      ).rejects.toThrow('Invalid language(s): ruby');
+    });
+
+    it('should reject unknown configuration key', async () => {
+      await expect(
+        updateConfig('unknown' as any, 'value', tempDir)
+      ).rejects.toThrow('Unknown configuration key');
+    });
+  });
+
+  describe('Default Configuration', () => {
+    it('should have correct default values', () => {
+      expect(DEFAULT_CONFIG.version).toBe('1.0');
+      expect(DEFAULT_CONFIG.severity).toBe('critical');
+      expect(DEFAULT_CONFIG.autofix).toBe(false);
+      expect(Array.isArray(DEFAULT_CONFIG.exclude)).toBe(true);
+      expect(Array.isArray(DEFAULT_CONFIG.languages)).toBe(true);
+    });
+
+    it('should exclude common directories by default', () => {
+      expect(DEFAULT_CONFIG.exclude).toContain('node_modules/**');
+      expect(DEFAULT_CONFIG.exclude).toContain('dist/**');
+      expect(DEFAULT_CONFIG.exclude).toContain('build/**');
+    });
+
+    it('should support all languages by default', () => {
+      expect(DEFAULT_CONFIG.languages).toContain('javascript');
+      expect(DEFAULT_CONFIG.languages).toContain('typescript');
+      expect(DEFAULT_CONFIG.languages).toContain('python');
+      expect(DEFAULT_CONFIG.languages).toContain('java');
+    });
+  });
+});

package/__tests__/local-scanner.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Local Scanner Tests
+ *
+ * Tests for the local scanner module that handles offline security analysis.
+ *
+ * Coverage:
+ * - Language detection
+ * - File exclusion patterns
+ * - Vulnerability counting
+ * - Single file scanning
+ * - Multiple file scanning
+ * - Threshold checking
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  detectLanguage,
+  shouldExclude,
+  countVulnerabilities,
+  exceedsThreshold,
+  type FileScanResult,
+} from '../src/scanner/local-scanner';
+import type { AnalysisResult, SecurityVulnerability } from '../../../src/lib/types';
+
+describe('Local Scanner - Language Detection', () => {
+  it('should detect JavaScript from .js extension', () => {
+    expect(detectLanguage('src/index.js')).toBe('javascript');
+    expect(detectLanguage('app.jsx')).toBe('javascript');
+  });
+
+  it('should detect TypeScript from .ts extension', () => {
+    expect(detectLanguage('src/index.ts')).toBe('typescript');
+    expect(detectLanguage('component.tsx')).toBe('typescript');
+  });
+
+  it('should detect Python from .py extension', () => {
+    expect(detectLanguage('script.py')).toBe('python');
+    expect(detectLanguage('src/main.py')).toBe('python');
+  });
+
+  it('should detect Java from .java extension', () => {
+    expect(detectLanguage('Main.java')).toBe('java');
+    expect(detectLanguage('src/com/example/App.java')).toBe('java');
+  });
+
+  it('should return null for unsupported extensions', () => {
+    expect(detectLanguage('README.md')).toBe(null);
+    expect(detectLanguage('config.json')).toBe(null);
+    expect(detectLanguage('style.css')).toBe(null);
+  });
+
+  it('should be case-insensitive', () => {
+    expect(detectLanguage('App.JS')).toBe('javascript');
+    expect(detectLanguage('Main.JAVA')).toBe('java');
+  });
+});
+
+describe('Local Scanner - File Exclusion', () => {
+  it('should exclude node_modules', () => {
+    const patterns = ['node_modules/**'];
+    expect(shouldExclude('node_modules/package/index.js', patterns)).toBe(true);
+    expect(shouldExclude('src/index.js', patterns)).toBe(false);
+  });
+
+  it('should exclude dist and build directories', () => {
+    const patterns = ['dist/**', 'build/**'];
+    expect(shouldExclude('dist/bundle.js', patterns)).toBe(true);
+    expect(shouldExclude('build/app.js', patterns)).toBe(true);
+    expect(shouldExclude('src/app.js', patterns)).toBe(false);
+  });
+
+  it('should exclude test files', () => {
+    const patterns = ['**/*.test.js', '**/*.spec.ts'];
+    expect(shouldExclude('src/app.test.js', patterns)).toBe(true);
+    expect(shouldExclude('tests/unit.spec.ts', patterns)).toBe(true);
+    expect(shouldExclude('src/app.js', patterns)).toBe(false);
+  });
+
+  it('should handle multiple patterns', () => {
+    const patterns = ['node_modules/**', 'dist/**', '**/*.test.js'];
+    expect(shouldExclude('node_modules/lib/index.js', patterns)).toBe(true);
+    expect(shouldExclude('dist/bundle.js', patterns)).toBe(true);
+    expect(shouldExclude('src/app.test.js', patterns)).toBe(true);
+    expect(shouldExclude('src/app.js', patterns)).toBe(false);
+  });
+
+  it('should handle wildcard patterns correctly', () => {
+    const patterns = ['**/test/**', '**/*.min.js'];
+    expect(shouldExclude('src/test/helper.js', patterns)).toBe(true);
+    expect(shouldExclude('lib/jquery.min.js', patterns)).toBe(true);
+    expect(shouldExclude('src/app.js', patterns)).toBe(false);
+  });
+});
+
+describe('Local Scanner - Vulnerability Counting', () => {
+  it('should count vulnerabilities by severity', () => {
+    const result: AnalysisResult = {
+      language: 'javascript',
+      syntax: { isValid: true, errors: [] },
+      security: {
+        vulnerabilities: [
+          { severity: 'CRITICAL', message: 'SQL injection', line: 1 } as SecurityVulnerability,
+          { severity: 'CRITICAL', message: 'XSS', line: 2 } as SecurityVulnerability,
+          { severity: 'HIGH', message: 'Auth bypass', line: 3 } as SecurityVulnerability,
+          { severity: 'MEDIUM', message: 'Weak crypto', line: 4 } as SecurityVulnerability,
+          { severity: 'LOW', message: 'Info disclosure', line: 5 } as SecurityVulnerability,
+        ],
+      },
+      quality: { score: 80, issues: [] },
+      performance: { score: 90, suggestions: [] },
+      metrics: {
+        linesOfCode: 100,
+        complexity: 5,
+        maintainability: 80,
+      },
+    };
+
+    const counts = countVulnerabilities(result);
+
+    expect(counts.critical).toBe(2);
+    expect(counts.high).toBe(1);
+    expect(counts.medium).toBe(1);
+    expect(counts.low).toBe(1);
+  });
+
+  it('should return zero counts for no vulnerabilities', () => {
+    const result: AnalysisResult = {
+      language: 'javascript',
+      syntax: { isValid: true, errors: [] },
+      security: { vulnerabilities: [] },
+      quality: { score: 100, issues: [] },
+      performance: { score: 100, suggestions: [] },
+      metrics: { linesOfCode: 50, complexity: 2, maintainability: 90 },
+    };
+
+    const counts = countVulnerabilities(result);
+
+    expect(counts.critical).toBe(0);
+    expect(counts.high).toBe(0);
+    expect(counts.medium).toBe(0);
+    expect(counts.low).toBe(0);
+  });
+
+  it('should handle missing security object', () => {
+    const result: AnalysisResult = {
+      language: 'javascript',
+      syntax: { isValid: true, errors: [] },
+      quality: { score: 100, issues: [] },
+      performance: { score: 100, suggestions: [] },
+      metrics: { linesOfCode: 50, complexity: 2, maintainability: 90 },
+    };
+
+    const counts = countVulnerabilities(result);
+
+    expect(counts.critical).toBe(0);
+    expect(counts.high).toBe(0);
+    expect(counts.medium).toBe(0);
+    expect(counts.low).toBe(0);
+  });
+});
+
+describe('Local Scanner - Threshold Checking', () => {
+  const mockResults: FileScanResult[] = [
+    {
+      filePath: '/path/to/file1.js',
+      relativePath: 'file1.js',
+      language: 'javascript',
+      result: {} as AnalysisResult,
+      critical: 2,
+      high: 1,
+      medium: 3,
+      low: 5,
+    },
+    {
+      filePath: '/path/to/file2.js',
+      relativePath: 'file2.js',
+      language: 'javascript',
+      result: {} as AnalysisResult,
+      critical: 0,
+      high: 2,
+      medium: 1,
+      low: 0,
+    },
+  ];
+
+  it('should detect CRITICAL threshold exceeded', () => {
+    expect(exceedsThreshold(mockResults, 'critical')).toBe(true);
+  });
+
+  it('should detect HIGH threshold exceeded', () => {
+    expect(exceedsThreshold(mockResults, 'high')).toBe(true);
+  });
+
+  it('should detect MEDIUM threshold exceeded', () => {
+    expect(exceedsThreshold(mockResults, 'medium')).toBe(true);
+  });
+
+  it('should detect LOW threshold exceeded', () => {
+    expect(exceedsThreshold(mockResults, 'low')).toBe(true);
+  });
+
+  it('should return false when no CRITICAL issues exist', () => {
+    const cleanResults: FileScanResult[] = [
+      {
+        filePath: '/path/to/file.js',
+        relativePath: 'file.js',
+        language: 'javascript',
+        result: {} as AnalysisResult,
+        critical: 0,
+        high: 1,
+        medium: 2,
+        low: 3,
+      },
+    ];
+
+    expect(exceedsThreshold(cleanResults, 'critical')).toBe(false);
+  });
+
+  it('should return false when no issues at all', () => {
+    const cleanResults: FileScanResult[] = [
+      {
+        filePath: '/path/to/file.js',
+        relativePath: 'file.js',
+        language: 'javascript',
+        result: {} as AnalysisResult,
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0,
+      },
+    ];
+
+    expect(exceedsThreshold(cleanResults, 'critical')).toBe(false);
+    expect(exceedsThreshold(cleanResults, 'high')).toBe(false);
+    expect(exceedsThreshold(cleanResults, 'medium')).toBe(false);
+    expect(exceedsThreshold(cleanResults, 'low')).toBe(false);
+  });
+
+  it('should handle empty results array', () => {
+    expect(exceedsThreshold([], 'critical')).toBe(false);
+    expect(exceedsThreshold([], 'high')).toBe(false);
+    expect(exceedsThreshold([], 'medium')).toBe(false);
+    expect(exceedsThreshold([], 'low')).toBe(false);
+  });
+});

package/bin/codeslick.cjs

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+/**
+ * CodeSlick CLI - Pre-commit Security Scanner
+ *
+ * This is the main entry point for the CodeSlick CLI tool.
+ * It handles command routing and error handling for all CLI commands.
+ *
+ * Usage:
+ *   codeslick init          - Initialize CodeSlick in repository
+ *   codeslick scan          - Scan staged files for vulnerabilities
+ *   codeslick config        - Manage configuration
+ *   codeslick auth          - Authenticate CLI (login, logout, whoami)
+ *
+ * Short alias: Use 'cs' instead of 'codeslick' for faster typing
+ *   cs init                 - Same as 'codeslick init'
+ *   cs scan                 - Same as 'codeslick scan'
+ *
+ * @see https://codeslick.dev/docs/cli for full documentation
+ */
+
+const yargs = require('yargs');
+const { hideBin } = require('yargs/helpers');
+const { scanCommand } = require('../dist/packages/cli/src/commands/scan');
+const { initCommand } = require('../dist/packages/cli/src/commands/init');
+const { configCommand } = require('../dist/packages/cli/src/commands/config');
+const { loginCommand, logoutCommand, whoamiCommand } = require('../dist/packages/cli/src/commands/auth');
+
+// Detect if running as 'cs' or 'codeslick'
+const scriptName = process.argv[1].includes('/cs') ? 'cs' : 'codeslick';
+
+// Main CLI application
+yargs(hideBin(process.argv))
+  .scriptName(scriptName)
+  .usage('$0 <command> [options]')
+  .command(
+    'init',
+    'Initialize CodeSlick in your repository',
+    (yargs) => {
+      return yargs
+        .option('force', {
+          alias: 'f',
+          type: 'boolean',
+          description: 'Force re-initialization (overwrite existing config)',
+          default: false,
+        })
+        .option('severity', {
+          alias: 's',
+          type: 'string',
+          description: 'Default severity threshold (critical|high|medium|low)',
+          default: 'critical',
+          choices: ['critical', 'high', 'medium', 'low'],
+        });
+    },
+    initCommand
+  )
+  .command(
+    'scan [files..]',
+    'Scan files for security vulnerabilities',
+    (yargs) => {
+      return yargs
+        .positional('files', {
+          type: 'string',
+          array: true,
+          description: 'Files or patterns to scan (default: staged files)',
+        })
+        .option('staged', {
+          type: 'boolean',
+          description: 'Scan only staged files (git)',
+          default: false,
+        })
+        .option('severity', {
+          alias: 's',
+          type: 'string',
+          description: 'Severity threshold (critical|high|medium|low)',
+          choices: ['critical', 'high', 'medium', 'low'],
+        })
+        .option('fix', {
+          type: 'boolean',
+          description: 'Auto-apply fixes (where possible)',
+          default: false,
+        })
+        .option('json', {
+          type: 'boolean',
+          description: 'Output results as JSON',
+          default: false,
+        });
+    },
+    scanCommand
+  )
+  .command(
+    'config <action> [key] [value]',
+    'Manage CodeSlick configuration',
+    (yargs) => {
+      return yargs
+        .positional('action', {
+          type: 'string',
+          description: 'Action to perform (get|set|list)',
+          choices: ['get', 'set', 'list'],
+        })
+        .positional('key', {
+          type: 'string',
+          description: 'Configuration key',
+        })
+        .positional('value', {
+          type: 'string',
+          description: 'Configuration value',
+        });
+    },
+    configCommand
+  )
+  .command(
+    'auth <action>',
+    'Manage CLI authentication',
+    (yargs) => {
+      return yargs
+        .positional('action', {
+          type: 'string',
+          description: 'Action to perform (login|logout|whoami)',
+          choices: ['login', 'logout', 'whoami'],
+        });
+    },
+    async (argv) => {
+      switch (argv.action) {
+        case 'login':
+          await loginCommand();
+          break;
+        case 'logout':
+          await logoutCommand();
+          break;
+        case 'whoami':
+          await whoamiCommand();
+          break;
+      }
+    }
+  )
+  .example('$0 init', 'Initialize CodeSlick in your repository')
+  .example('$0 scan', 'Scan all staged files')
+  .example('$0 scan src/**/*.js', 'Scan specific files')
+  .example('$0 scan --staged --severity high', 'Scan staged files, block on HIGH+')
+  .example('$0 config set severity critical', 'Set severity threshold')
+  .example('$0 config list', 'List all configuration')
+  .example('$0 auth login', 'Authenticate CLI via browser')
+  .example('$0 auth whoami', 'Show current user and quota')
+  .example('$0 auth logout', 'Remove local credentials')
+  .demandCommand(1, 'You must provide a command')
+  .help()
+  .alias('help', 'h')
+  .version('1.0.0')
+  .alias('version', 'v')
+  .epilog('For more information, visit https://codeslick.dev/docs/cli')
+  .strict()
+  .parse();

package/dist/packages/cli/src/commands/auth.d.ts

@@ -0,0 +1,36 @@
+/**
+ * CLI Authentication Commands
+ * Phase 1.5 Week 10 - CLI Authentication System
+ *
+ * Commands:
+ * - login: Browser-based OAuth authentication
+ * - logout: Remove local credentials
+ * - whoami: Display current user info and quota
+ */
+interface AuthConfig {
+    accessToken: string;
+    email: string;
+    plan: string;
+    expiresAt?: string;
+}
+/**
+ * Login Command
+ * Opens browser for authentication and polls for validation
+ */
+export declare function loginCommand(): Promise<void>;
+/**
+ * Logout Command
+ * Removes local credentials
+ */
+export declare function logoutCommand(): Promise<void>;
+/**
+ * Whoami Command
+ * Displays current user info and quota
+ */
+export declare function whoamiCommand(): Promise<void>;
+/**
+ * Load authentication config from disk
+ */
+export declare function loadAuth(): AuthConfig | null;
+export {};
+//# sourceMappingURL=auth.d.ts.map

package/dist/packages/cli/src/commands/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../../src/commands/auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAeH,UAAU,UAAU;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAiCD;;;GAGG;AACH,wBAAsB,YAAY,kBA0GjC;AAED;;;GAGG;AACH,wBAAsB,aAAa,kBAiBlC;AAED;;;GAGG;AACH,wBAAsB,aAAa,kBAuDlC;AAaD;;GAEG;AACH,wBAAgB,QAAQ,IAAI,UAAU,GAAG,IAAI,CAW5C"}