codeslick-cli 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,202 @@
+/**
+ * Init Command - Repository Initialization
+ *
+ * This command initializes CodeSlick in a git repository by:
+ * 1. Creating a .codeslick.json configuration file
+ * 2. Installing the pre-commit hook
+ * 3. Making the hook executable
+ *
+ * After running this command, CodeSlick will automatically scan
+ * staged files before each commit.
+ *
+ * @module packages/cli/src/commands/init
+ */
+
+import { existsSync } from 'fs';
+import { writeFile, mkdir, chmod } from 'fs/promises';
+import { resolve } from 'path';
+import ora from 'ora';
+import {
+  DEFAULT_CONFIG,
+  configExists,
+  saveConfig,
+  type CodeSlickConfig,
+} from '../config/config-loader';
+import { printSuccess, printError, printWarning } from '../reporters/cli-reporter';
+
+/**
+ * Command arguments type
+ */
+interface InitArgs {
+  force?: boolean;
+  severity?: 'critical' | 'high' | 'medium' | 'low';
+}
+
+/**
+ * Pre-commit hook template
+ */
+const PRE_COMMIT_HOOK = `#!/bin/sh
+# CodeSlick pre-commit hook
+# Automatically scans staged files for security vulnerabilities
+#
+# To skip this hook temporarily, use: git commit --no-verify
+
+# Run CodeSlick scan on staged files
+codeslick scan --staged
+
+# Exit with the scan status
+exit $?
+`;
+
+/**
+ * Check if we're in a git repository
+ */
+function isGitRepository(cwd: string = process.cwd()): boolean {
+  return existsSync(resolve(cwd, '.git'));
+}
+
+/**
+ * Get git hooks directory path
+ */
+function getHooksPath(cwd: string = process.cwd()): string {
+  return resolve(cwd, '.git', 'hooks');
+}
+
+/**
+ * Get pre-commit hook file path
+ */
+function getPreCommitPath(cwd: string = process.cwd()): string {
+  return resolve(getHooksPath(cwd), 'pre-commit');
+}
+
+/**
+ * Check if pre-commit hook already exists
+ */
+function preCommitExists(cwd: string = process.cwd()): boolean {
+  return existsSync(getPreCommitPath(cwd));
+}
+
+/**
+ * Create .codeslick.json configuration file
+ */
+async function createConfigFile(
+  args: InitArgs,
+  cwd: string = process.cwd()
+): Promise<void> {
+  const spinner = ora('Creating .codeslick.json').start();
+
+  try {
+    const config: CodeSlickConfig = {
+      ...DEFAULT_CONFIG,
+      severity: args.severity || DEFAULT_CONFIG.severity,
+    };
+
+    await saveConfig(config, cwd);
+
+    spinner.succeed('.codeslick.json created');
+  } catch (error) {
+    spinner.fail('Failed to create .codeslick.json');
+    throw error;
+  }
+}
+
+/**
+ * Install pre-commit hook
+ */
+async function installPreCommitHook(cwd: string = process.cwd()): Promise<void> {
+  const spinner = ora('Installing pre-commit hook').start();
+
+  try {
+    const hooksPath = getHooksPath(cwd);
+    const preCommitPath = getPreCommitPath(cwd);
+
+    // Create hooks directory if it doesn't exist
+    if (!existsSync(hooksPath)) {
+      await mkdir(hooksPath, { recursive: true });
+    }
+
+    // Write pre-commit hook
+    await writeFile(preCommitPath, PRE_COMMIT_HOOK, 'utf-8');
+
+    // Make hook executable (Unix)
+    if (process.platform !== 'win32') {
+      await chmod(preCommitPath, 0o755);
+    }
+
+    spinner.succeed('Pre-commit hook installed');
+  } catch (error) {
+    spinner.fail('Failed to install pre-commit hook');
+    throw error;
+  }
+}
+
+/**
+ * Init Command Handler
+ *
+ * This function:
+ * 1. Checks if we're in a git repository
+ * 2. Creates .codeslick.json (or overwrites with --force)
+ * 3. Installs pre-commit hook (or overwrites with --force)
+ * 4. Displays success message with usage instructions
+ */
+export async function initCommand(args: InitArgs): Promise<void> {
+  try {
+    const cwd = process.cwd();
+
+    // Check if we're in a git repository
+    if (!isGitRepository(cwd)) {
+      printError('Not a git repository. Initialize git first with: git init');
+      process.exit(1);
+    }
+
+    console.log('');
+    console.log('Initializing CodeSlick...');
+    console.log('');
+
+    // Check if config already exists
+    if (configExists(cwd) && !args.force) {
+      printWarning(
+        '.codeslick.json already exists. Use --force to overwrite.'
+      );
+    } else {
+      await createConfigFile(args, cwd);
+    }
+
+    // Check if pre-commit hook already exists
+    if (preCommitExists(cwd) && !args.force) {
+      printWarning(
+        'Pre-commit hook already exists. Use --force to overwrite.'
+      );
+    } else {
+      await installPreCommitHook(cwd);
+    }
+
+    // Print success message
+    printSuccess('CodeSlick initialized successfully!');
+
+    console.log('Next steps:');
+    console.log('  1. Review .codeslick.json configuration');
+    console.log('  2. Stage files: git add <files>');
+    console.log('  3. Commit: git commit -m "message"');
+    console.log('');
+    console.log('CodeSlick will automatically scan staged files before each commit.');
+    console.log('');
+    console.log('To scan files manually:');
+    console.log('  codeslick scan                  # Scan all files');
+    console.log('  codeslick scan --staged         # Scan staged files only');
+    console.log('  codeslick scan src/**/*.js      # Scan specific files');
+    console.log('');
+    console.log('To skip the pre-commit hook temporarily:');
+    console.log('  git commit --no-verify');
+    console.log('');
+
+    process.exit(0);
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+    } else {
+      printError('An unknown error occurred');
+    }
+    process.exit(1);
+  }
+}

package/src/commands/scan.ts

@@ -0,0 +1,238 @@
+/**
+ * Scan Command - Security Vulnerability Scanner
+ *
+ * This command scans files for security vulnerabilities using CodeSlick's
+ * analysis engine. It can scan staged files (for pre-commit hooks) or
+ * specific files/patterns.
+ *
+ * Features:
+ * - Scan staged files only (--staged)
+ * - Scan specific files or patterns
+ * - Configurable severity thresholds
+ * - Beautiful terminal output
+ * - JSON output mode for CI/CD
+ * - Exit codes for automation (0 = pass, 1 = fail)
+ *
+ * @module packages/cli/src/commands/scan
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { resolve } from 'path';
+import { glob } from 'glob';
+import ora from 'ora';
+import chalk from 'chalk';
+import { scanFiles, exceedsThreshold, type ScannerConfig } from '../scanner/local-scanner';
+import {
+  printScanStart,
+  printScanComplete,
+  printDetailedResults,
+  printSummaryTable,
+  printCommitBlocked,
+  printCommitAllowed,
+  printError,
+  printJSONResults,
+} from '../reporters/cli-reporter';
+import { loadConfig } from '../config/config-loader';
+
+const execAsync = promisify(exec);
+
+/**
+ * Command arguments type
+ */
+interface ScanArgs {
+  files?: string[];
+  staged?: boolean;
+  severity?: 'critical' | 'high' | 'medium' | 'low';
+  fix?: boolean;
+  json?: boolean;
+}
+
+/**
+ * Get list of staged files from git
+ */
+async function getStagedFiles(): Promise<string[]> {
+  try {
+    const { stdout } = await execAsync('git diff --cached --name-only --diff-filter=ACM');
+    return stdout
+      .trim()
+      .split('\n')
+      .filter((f) => f.length > 0)
+      .map((f) => resolve(process.cwd(), f));
+  } catch (error) {
+    throw new Error('Failed to get staged files. Are you in a git repository?');
+  }
+}
+
+/**
+ * Expand glob patterns to file paths
+ */
+async function expandGlobPatterns(patterns: string[]): Promise<string[]> {
+  const allFiles: string[] = [];
+
+  for (const pattern of patterns) {
+    const files = await glob(pattern, {
+      cwd: process.cwd(),
+      absolute: true,
+      nodir: true,
+    });
+    allFiles.push(...files);
+  }
+
+  // Remove duplicates
+  return [...new Set(allFiles)];
+}
+
+/**
+ * Scan Command Handler
+ *
+ * This function:
+ * 1. Determines which files to scan (staged, specific, or all)
+ * 2. Loads configuration from .codeslick.json
+ * 3. Scans files using local scanner
+ * 4. Displays results
+ * 5. Exits with appropriate code
+ */
+export async function scanCommand(args: ScanArgs): Promise<void> {
+  const startTime = Date.now();
+
+  try {
+    // Load configuration
+    const config = await loadConfig();
+
+    // Merge command-line args with config
+    const scannerConfig: ScannerConfig = {
+      severityThreshold: args.severity || config.severity || 'critical',
+      exclude: config.exclude || [],
+      autofix: args.fix || config.autofix || false,
+    };
+
+    // Determine which files to scan
+    let filePaths: string[] = [];
+
+    if (args.staged) {
+      // Scan staged files
+      filePaths = await getStagedFiles();
+
+      if (filePaths.length === 0) {
+        printError('No staged files found. Stage files with: git add <files>');
+        process.exit(0);
+      }
+    } else if (args.files && args.files.length > 0) {
+      // Scan specific files/patterns
+      filePaths = await expandGlobPatterns(args.files);
+
+      if (filePaths.length === 0) {
+        printError(`No files matched patterns: ${args.files.join(', ')}`);
+        process.exit(1);
+      }
+    } else {
+      // Scan all files (default patterns from config)
+      const defaultPatterns = config.languages?.map((lang) => {
+        switch (lang) {
+          case 'javascript':
+            return '**/*.{js,jsx}';
+          case 'typescript':
+            return '**/*.{ts,tsx}';
+          case 'python':
+            return '**/*.py';
+          case 'java':
+            return '**/*.java';
+          default:
+            return '';
+        }
+      }).filter(Boolean) || ['**/*.{js,jsx,ts,tsx,py,java}'];
+
+      filePaths = await expandGlobPatterns(defaultPatterns);
+
+      if (filePaths.length === 0) {
+        printError('No files found to scan.');
+        process.exit(0);
+      }
+    }
+
+    // Print scan start
+    if (!args.json) {
+      printScanStart(filePaths.length);
+    }
+
+    // Show progress spinner
+    const spinner = !args.json ? ora('Scanning files...').start() : null;
+
+    // Scan all files
+    const results = await scanFiles(filePaths, scannerConfig);
+
+    // Stop spinner
+    if (spinner) {
+      spinner.stop();
+    }
+
+    const duration = Date.now() - startTime;
+
+    // Output results
+    if (args.json) {
+      // JSON output mode (for CI/CD)
+      printJSONResults(results);
+    } else {
+      // Human-readable output
+      printScanComplete(duration);
+      printDetailedResults(results);
+      printSummaryTable(results);
+    }
+
+    // Show AI-Fix availability message if --fix flag was used
+    if (args.fix && !args.json) {
+      const totalVulns = results.reduce((sum, r) => sum + r.critical + r.high + r.medium + r.low, 0);
+
+      if (totalVulns > 0) {
+        console.log('');
+        console.log(chalk.cyan.bold('🤖 AI-Powered Auto-Fix Available'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log('');
+        console.log(chalk.white(`Found ${totalVulns} ${totalVulns === 1 ? 'vulnerability' : 'vulnerabilities'} that can be fixed with AI.`));
+        console.log('');
+        console.log(chalk.yellow('Auto-fix is available through:'));
+        console.log('');
+        console.log(chalk.green('  1. WebTool:') + chalk.gray(' https://codeslick.dev/analyze'));
+        console.log(chalk.gray('     → Paste your code and click "Generate Fix"'));
+        console.log('');
+        console.log(chalk.green('  2. GitHub App:') + chalk.gray(' Automated PR fixes'));
+        console.log(chalk.gray('     → Install: https://github.com/settings/apps/codeslick-security-scanner'));
+        console.log('');
+        console.log(chalk.gray('CLI auto-fix coming soon'));
+        console.log('');
+      }
+    }
+
+    // Check if results exceed threshold
+    const threshold = scannerConfig.severityThreshold || 'critical';
+    const shouldBlock = exceedsThreshold(results, threshold);
+
+    if (shouldBlock) {
+      // Calculate totals for display
+      const totalCritical = results.reduce((sum, r) => sum + r.critical, 0);
+      const totalHigh = results.reduce((sum, r) => sum + r.high, 0);
+      const totalMedium = results.reduce((sum, r) => sum + r.medium, 0);
+      const totalLow = results.reduce((sum, r) => sum + r.low, 0);
+
+      if (!args.json) {
+        printCommitBlocked(threshold, totalCritical, totalHigh, totalMedium, totalLow);
+      }
+
+      process.exit(1); // Exit with failure
+    } else {
+      if (!args.json) {
+        printCommitAllowed();
+      }
+
+      process.exit(0); // Exit with success
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+    } else {
+      printError('An unknown error occurred');
+    }
+    process.exit(1);
+  }
+}

package/src/config/config-loader.ts

@@ -0,0 +1,175 @@
+/**
+ * Configuration Loader - .codeslick.json Parser
+ *
+ * This module loads and validates the .codeslick.json configuration file.
+ * It provides sensible defaults if the file doesn't exist.
+ *
+ * Configuration Structure:
+ * ```json
+ * {
+ *   "version": "1.0",
+ *   "severity": "critical",
+ *   "autofix": false,
+ *   "exclude": ["node_modules/**", "dist/**"],
+ *   "languages": ["javascript", "typescript", "python", "java"]
+ * }
+ * ```
+ *
+ * @module packages/cli/src/config/config-loader
+ */
+
+import { readFile, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { existsSync } from 'fs';
+
+/**
+ * CodeSlick configuration interface
+ */
+export interface CodeSlickConfig {
+  version: string;
+  severity: 'critical' | 'high' | 'medium' | 'low';
+  autofix: boolean;
+  exclude: string[];
+  languages: ('javascript' | 'typescript' | 'python' | 'java')[];
+}
+
+/**
+ * Default configuration
+ */
+export const DEFAULT_CONFIG: CodeSlickConfig = {
+  version: '1.0',
+  severity: 'critical',
+  autofix: false,
+  exclude: [
+    'node_modules/**',
+    'dist/**',
+    'build/**',
+    'coverage/**',
+    '**/*.test.{js,ts}',
+    '**/*.spec.{js,ts}',
+    '**/test/**',
+    '**/tests/**',
+  ],
+  languages: ['javascript', 'typescript', 'python', 'java'],
+};
+
+/**
+ * Get configuration file path
+ */
+export function getConfigPath(cwd: string = process.cwd()): string {
+  return resolve(cwd, '.codeslick.json');
+}
+
+/**
+ * Check if configuration file exists
+ */
+export function configExists(cwd: string = process.cwd()): boolean {
+  return existsSync(getConfigPath(cwd));
+}
+
+/**
+ * Load configuration from .codeslick.json
+ *
+ * If the file doesn't exist, returns default configuration.
+ * If the file exists but is invalid, throws an error.
+ *
+ * @param cwd - Current working directory (default: process.cwd())
+ * @returns Parsed configuration
+ */
+export async function loadConfig(cwd: string = process.cwd()): Promise<CodeSlickConfig> {
+  const configPath = getConfigPath(cwd);
+
+  if (!existsSync(configPath)) {
+    // Return default config if file doesn't exist
+    return DEFAULT_CONFIG;
+  }
+
+  try {
+    const content = await readFile(configPath, 'utf-8');
+    const parsed = JSON.parse(content);
+
+    // Merge with defaults to handle missing fields
+    return {
+      ...DEFAULT_CONFIG,
+      ...parsed,
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse .codeslick.json: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Save configuration to .codeslick.json
+ *
+ * @param config - Configuration to save
+ * @param cwd - Current working directory (default: process.cwd())
+ */
+export async function saveConfig(
+  config: CodeSlickConfig,
+  cwd: string = process.cwd()
+): Promise<void> {
+  const configPath = getConfigPath(cwd);
+  const content = JSON.stringify(config, null, 2);
+
+  await writeFile(configPath, content, 'utf-8');
+}
+
+/**
+ * Update a specific configuration value
+ *
+ * @param key - Configuration key
+ * @param value - Configuration value
+ * @param cwd - Current working directory (default: process.cwd())
+ */
+export async function updateConfig(
+  key: keyof CodeSlickConfig,
+  value: unknown,
+  cwd: string = process.cwd()
+): Promise<void> {
+  const config = await loadConfig(cwd);
+
+  // Validate and update based on key
+  switch (key) {
+    case 'severity':
+      if (!['critical', 'high', 'medium', 'low'].includes(value as string)) {
+        throw new Error(
+          `Invalid severity value: ${value}. Must be one of: critical, high, medium, low`
+        );
+      }
+      config.severity = value as 'critical' | 'high' | 'medium' | 'low';
+      break;
+
+    case 'autofix':
+      if (typeof value !== 'boolean') {
+        throw new Error(`Invalid autofix value: ${value}. Must be true or false`);
+      }
+      config.autofix = value;
+      break;
+
+    case 'exclude':
+      if (!Array.isArray(value)) {
+        throw new Error(`Invalid exclude value: ${value}. Must be an array of patterns`);
+      }
+      config.exclude = value;
+      break;
+
+    case 'languages':
+      if (!Array.isArray(value)) {
+        throw new Error(`Invalid languages value: ${value}. Must be an array`);
+      }
+      const validLanguages = ['javascript', 'typescript', 'python', 'java'];
+      const invalid = (value as string[]).filter((lang) => !validLanguages.includes(lang));
+      if (invalid.length > 0) {
+        throw new Error(
+          `Invalid language(s): ${invalid.join(', ')}. Must be one of: ${validLanguages.join(', ')}`
+        );
+      }
+      config.languages = value as ('javascript' | 'typescript' | 'python' | 'java')[];
+      break;
+
+    default:
+      throw new Error(`Unknown configuration key: ${key}`);
+  }
+
+  await saveConfig(config, cwd);
+}