bit-cli-ai 1.0.0

package/src/utils/ai.js

@@ -0,0 +1,238 @@
+/**
+ * AI Service for generating commit messages and code analysis
+ * Supports multiple AI providers with fallback to rule-based generation
+ */
+
+import OpenAI from 'openai';
+import { config } from './config.js';
+import { log } from './logger.js';
+import { APIKeyError, RateLimitError, AIError } from './errors.js';
+
+/**
+ * Get OpenAI client instance
+ */
+function getOpenAIClient() {
+  const apiKey = config.get('apiKeys.openai');
+  
+  if (!apiKey) {
+    return null;
+  }
+  
+  return new OpenAI({ apiKey });
+}
+
+/**
+ * Generate commit message using AI
+ */
+export async function generateCommitMessage(diff, options = {}) {
+  const { maxLength = 72, style = 'conventional' } = options;
+  
+  const aiConfig = config.get('ai');
+  const client = getOpenAIClient();
+  
+  // Fallback to rule-based if no API key
+  if (!client) {
+    log.ai('fallback', { reason: 'no_api_key' });
+    return generateRuleBasedMessage(diff);
+  }
+  
+  try {
+    log.ai('generate_commit', { model: aiConfig.model, diffLength: diff.length });
+    
+    const systemPrompt = getCommitSystemPrompt(style, maxLength);
+    
+    const response = await client.chat.completions.create({
+      model: aiConfig.model,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: truncateDiff(diff, 4000) },
+      ],
+      max_tokens: aiConfig.maxTokens,
+      temperature: aiConfig.temperature,
+    });
+    
+    const message = response.choices[0]?.message?.content?.trim();
+    
+    log.ai('generate_commit_success', { message });
+    
+    return message || generateRuleBasedMessage(diff);
+  } catch (error) {
+    log.exception(error, { operation: 'generate_commit' });
+    
+    if (error.status === 429) {
+      throw new RateLimitError();
+    }
+    
+    if (error.status === 401) {
+      throw new APIKeyError('OpenAI');
+    }
+    
+    // Fallback to rule-based on any error
+    log.ai('fallback', { reason: error.message });
+    return generateRuleBasedMessage(diff);
+  }
+}
+
+/**
+ * Analyze code changes for summary
+ */
+export async function analyzeCodeChanges(diff, options = {}) {
+  const client = getOpenAIClient();
+  
+  if (!client) {
+    return null;
+  }
+  
+  try {
+    const response = await client.chat.completions.create({
+      model: config.get('ai.model'),
+      messages: [
+        {
+          role: 'system',
+          content: `Analyze the following git diff and provide:
+1. A brief summary of changes (1-2 sentences)
+2. List of modified functions/methods
+3. Potential risks or areas needing review
+4. Suggested reviewers based on code areas
+
+Format as JSON with keys: summary, modifiedFunctions, risks, suggestedAreas`,
+        },
+        { role: 'user', content: truncateDiff(diff, 4000) },
+      ],
+      max_tokens: 1000,
+      temperature: 0.3,
+    });
+    
+    const content = response.choices[0]?.message?.content;
+    
+    try {
+      return JSON.parse(content);
+    } catch {
+      return { summary: content };
+    }
+  } catch (error) {
+    log.exception(error, { operation: 'analyze_code' });
+    return null;
+  }
+}
+
+/**
+ * Get system prompt for commit message generation
+ */
+function getCommitSystemPrompt(style, maxLength) {
+  const basePrompt = `You are a helpful assistant that generates concise git commit messages.
+Analyze the diff and write a clear, descriptive commit message.
+Maximum length: ${maxLength} characters for the first line.`;
+
+  const stylePrompts = {
+    conventional: `${basePrompt}
+Use Conventional Commits format:
+- feat: new feature
+- fix: bug fix
+- docs: documentation changes
+- style: formatting, no code change
+- refactor: code restructuring
+- test: adding tests
+- chore: maintenance tasks
+
+Examples:
+- feat: add user authentication flow
+- fix: resolve null pointer in checkout
+- refactor: simplify payment processing logic`,
+
+    simple: `${basePrompt}
+Write simple, clear messages starting with a verb.
+Examples:
+- Add user authentication
+- Fix checkout bug
+- Update README`,
+
+    detailed: `${basePrompt}
+Provide a short summary line followed by bullet points of changes.
+Format:
+Summary line (max 50 chars)
+
+- Change 1
+- Change 2`,
+  };
+
+  return stylePrompts[style] || stylePrompts.conventional;
+}
+
+/**
+ * Rule-based commit message generation (fallback)
+ */
+export function generateRuleBasedMessage(diff) {
+  const lines = diff.split('\n');
+  const stats = {
+    additions: 0,
+    deletions: 0,
+    files: new Set(),
+    types: new Set(),
+  };
+  
+  // Parse diff
+  for (const line of lines) {
+    if (line.startsWith('+++ b/')) {
+      const file = line.replace('+++ b/', '');
+      stats.files.add(file);
+      
+      // Detect file type
+      if (file.endsWith('.test.js') || file.endsWith('.spec.js')) {
+        stats.types.add('test');
+      } else if (file.endsWith('.md')) {
+        stats.types.add('docs');
+      } else if (file.includes('config')) {
+        stats.types.add('chore');
+      }
+    } else if (line.startsWith('+') && !line.startsWith('+++')) {
+      stats.additions++;
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      stats.deletions++;
+    }
+  }
+  
+  // Determine commit type
+  let type = 'chore';
+  if (stats.types.has('test')) {
+    type = 'test';
+  } else if (stats.types.has('docs')) {
+    type = 'docs';
+  } else if (stats.additions > stats.deletions * 2) {
+    type = 'feat';
+  } else if (stats.deletions > stats.additions) {
+    type = 'refactor';
+  } else if (stats.files.size === 1) {
+    type = 'fix';
+  }
+  
+  // Generate message
+  const fileCount = stats.files.size;
+  const fileList = Array.from(stats.files).slice(0, 3);
+  
+  if (fileCount === 1) {
+    const fileName = fileList[0].split('/').pop();
+    return `${type}: update ${fileName}`;
+  } else if (fileCount <= 3) {
+    return `${type}: update ${fileList.map((f) => f.split('/').pop()).join(', ')}`;
+  } else {
+    return `${type}: update ${fileCount} files`;
+  }
+}
+
+/**
+ * Truncate diff to fit token limit
+ */
+function truncateDiff(diff, maxChars) {
+  if (diff.length <= maxChars) {
+    return diff;
+  }
+  
+  return diff.slice(0, maxChars) + '\n\n... (diff truncated)';
+}
+
+export default {
+  generateCommitMessage,
+  analyzeCodeChanges,
+  generateRuleBasedMessage,
+};

package/src/utils/config.js

@@ -0,0 +1,178 @@
+/**
+ * Configuration management for Bit CLI
+ * Handles global config, project config, and environment variables
+ */
+
+import Conf from 'conf';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+// Default configuration values
+const defaults = {
+  ai: {
+    provider: 'openai',
+    model: 'gpt-4o-mini',
+    maxTokens: 500,
+    temperature: 0.7,
+  },
+  git: {
+    ghostPrefix: 'ghost/',
+    autoStage: false,
+    signCommits: false,
+  },
+  ui: {
+    colors: true,
+    spinners: true,
+    verbose: false,
+  },
+  telemetry: {
+    enabled: false,
+    anonymousId: null,
+  },
+};
+
+// Schema for configuration validation
+const schema = {
+  ai: {
+    type: 'object',
+    properties: {
+      provider: { type: 'string', enum: ['openai', 'anthropic', 'local'] },
+      model: { type: 'string' },
+      maxTokens: { type: 'number', minimum: 100, maximum: 4000 },
+      temperature: { type: 'number', minimum: 0, maximum: 2 },
+    },
+  },
+  git: {
+    type: 'object',
+    properties: {
+      ghostPrefix: { type: 'string' },
+      autoStage: { type: 'boolean' },
+      signCommits: { type: 'boolean' },
+    },
+  },
+  ui: {
+    type: 'object',
+    properties: {
+      colors: { type: 'boolean' },
+      spinners: { type: 'boolean' },
+      verbose: { type: 'boolean' },
+    },
+  },
+};
+
+// Global configuration (stored in ~/.bit/config.json)
+const globalConfig = new Conf({
+  projectName: 'bit-cli',
+  defaults,
+  schema,
+});
+
+/**
+ * Get project-specific configuration from .bit/config.json
+ */
+function getProjectConfig() {
+  const projectConfigPath = path.join(process.cwd(), '.bit', 'config.json');
+  
+  if (fs.existsSync(projectConfigPath)) {
+    try {
+      const content = fs.readFileSync(projectConfigPath, 'utf-8');
+      return JSON.parse(content);
+    } catch (error) {
+      return {};
+    }
+  }
+  
+  return {};
+}
+
+/**
+ * Merge configurations with priority: env > project > global > defaults
+ */
+function getMergedConfig() {
+  const projectConfig = getProjectConfig();
+  
+  return {
+    ai: {
+      ...defaults.ai,
+      ...globalConfig.get('ai'),
+      ...projectConfig.ai,
+      // Environment overrides
+      provider: process.env.BIT_AI_PROVIDER || globalConfig.get('ai.provider'),
+      model: process.env.BIT_AI_MODEL || globalConfig.get('ai.model'),
+    },
+    git: {
+      ...defaults.git,
+      ...globalConfig.get('git'),
+      ...projectConfig.git,
+    },
+    ui: {
+      ...defaults.ui,
+      ...globalConfig.get('ui'),
+      ...projectConfig.ui,
+      verbose: process.env.BIT_VERBOSE === 'true' || globalConfig.get('ui.verbose'),
+    },
+    // API Keys from environment only (never stored in config)
+    apiKeys: {
+      openai: process.env.OPENAI_API_KEY,
+      anthropic: process.env.ANTHROPIC_API_KEY,
+    },
+  };
+}
+
+// Configuration API
+export const config = {
+  // Get merged configuration
+  get: (key) => {
+    const merged = getMergedConfig();
+    if (!key) return merged;
+    
+    return key.split('.').reduce((obj, k) => obj?.[k], merged);
+  },
+  
+  // Set global configuration
+  set: (key, value) => {
+    globalConfig.set(key, value);
+  },
+  
+  // Set project configuration
+  setProject: (key, value) => {
+    const projectConfigPath = path.join(process.cwd(), '.bit', 'config.json');
+    const projectConfig = getProjectConfig();
+    
+    // Set nested key
+    const keys = key.split('.');
+    let obj = projectConfig;
+    for (let i = 0; i < keys.length - 1; i++) {
+      obj[keys[i]] = obj[keys[i]] || {};
+      obj = obj[keys[i]];
+    }
+    obj[keys[keys.length - 1]] = value;
+    
+    fs.writeFileSync(projectConfigPath, JSON.stringify(projectConfig, null, 2));
+  },
+  
+  // Reset to defaults
+  reset: () => {
+    globalConfig.clear();
+  },
+  
+  // Check if API key is configured
+  hasApiKey: (provider = 'openai') => {
+    const keys = getMergedConfig().apiKeys;
+    return !!keys[provider];
+  },
+  
+  // Get config file paths
+  paths: {
+    global: globalConfig.path,
+    project: path.join(process.cwd(), '.bit', 'config.json'),
+    logs: path.join(os.homedir(), '.bit', 'logs'),
+  },
+};
+
+export default config;

package/src/utils/errors.js

@@ -0,0 +1,170 @@
+/**
+ * Custom error classes and error handling utilities
+ * Provides consistent error handling across the CLI
+ */
+
+import chalk from 'chalk';
+import { log } from './logger.js';
+
+// Base error class for Bit CLI
+export class BitError extends Error {
+  constructor(message, code = 'BIT_ERROR', details = {}) {
+    super(message);
+    this.name = 'BitError';
+    this.code = code;
+    this.details = details;
+    this.timestamp = new Date().toISOString();
+  }
+}
+
+// Git-related errors
+export class GitError extends BitError {
+  constructor(message, details = {}) {
+    super(message, 'GIT_ERROR', details);
+    this.name = 'GitError';
+  }
+}
+
+// Not in a git repository
+export class NotARepositoryError extends GitError {
+  constructor() {
+    super('Not a git repository. Run "bit init" to initialize.', {
+      suggestion: 'Run "bit init" to create a new repository',
+    });
+    this.name = 'NotARepositoryError';
+  }
+}
+
+// Merge conflict error
+export class MergeConflictError extends GitError {
+  constructor(files = []) {
+    super('Merge conflicts detected', { conflictingFiles: files });
+    this.name = 'MergeConflictError';
+  }
+}
+
+// AI-related errors
+export class AIError extends BitError {
+  constructor(message, details = {}) {
+    super(message, 'AI_ERROR', details);
+    this.name = 'AIError';
+  }
+}
+
+// API key not configured
+export class APIKeyError extends AIError {
+  constructor(provider = 'OpenAI') {
+    super(`${provider} API key not configured`, {
+      suggestion: `Set ${provider.toUpperCase()}_API_KEY environment variable`,
+    });
+    this.name = 'APIKeyError';
+  }
+}
+
+// Rate limit exceeded
+export class RateLimitError extends AIError {
+  constructor(retryAfter = null) {
+    super('API rate limit exceeded', {
+      retryAfter,
+      suggestion: 'Wait a moment and try again',
+    });
+    this.name = 'RateLimitError';
+  }
+}
+
+// Configuration errors
+export class ConfigError extends BitError {
+  constructor(message, details = {}) {
+    super(message, 'CONFIG_ERROR', details);
+    this.name = 'ConfigError';
+  }
+}
+
+// Validation errors
+export class ValidationError extends BitError {
+  constructor(message, details = {}) {
+    super(message, 'VALIDATION_ERROR', details);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Global error handler for CLI
+ */
+export function handleError(error, options = {}) {
+  const { exit = true, showStack = false } = options;
+  
+  // Log the error
+  log.exception(error, { command: process.argv.slice(2).join(' ') });
+  
+  // Format error output
+  console.error('');
+  
+  if (error instanceof BitError) {
+    console.error(chalk.red(`Error [${error.code}]: ${error.message}`));
+    
+    if (error.details?.suggestion) {
+      console.error(chalk.yellow(`Suggestion: ${error.details.suggestion}`));
+    }
+    
+    if (error.details?.conflictingFiles?.length) {
+      console.error(chalk.yellow('\nConflicting files:'));
+      error.details.conflictingFiles.forEach((file) => {
+        console.error(chalk.yellow(`  - ${file}`));
+      });
+    }
+  } else {
+    console.error(chalk.red(`Error: ${error.message}`));
+  }
+  
+  // Show stack trace in debug mode
+  if (showStack || process.env.BIT_DEBUG === 'true') {
+    console.error(chalk.gray('\nStack trace:'));
+    console.error(chalk.gray(error.stack));
+  }
+  
+  console.error('');
+  
+  if (exit) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Wrap async functions with error handling
+ */
+export function withErrorHandling(fn) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      handleError(error);
+    }
+  };
+}
+
+/**
+ * Try to execute a function, return default value on error
+ */
+export function tryOrDefault(fn, defaultValue = null) {
+  try {
+    return fn();
+  } catch {
+    return defaultValue;
+  }
+}
+
+export default {
+  BitError,
+  GitError,
+  NotARepositoryError,
+  MergeConflictError,
+  AIError,
+  APIKeyError,
+  RateLimitError,
+  ConfigError,
+  ValidationError,
+  handleError,
+  withErrorHandling,
+  tryOrDefault,
+};