bit-cli-ai 1.0.0

package/src/commands/branch.js

@@ -0,0 +1,202 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import chalk from 'chalk';
+import ora from 'ora';
+
+const GHOST_PREFIX = 'ghost/';
+const METADATA_PATH = '.bit/metadata.json';
+
+// Load Bit metadata
+function loadMetadata() {
+  if (!fs.existsSync(METADATA_PATH)) {
+    return { ghostBranches: [] };
+  }
+  return JSON.parse(fs.readFileSync(METADATA_PATH, 'utf-8'));
+}
+
+// Save Bit metadata
+function saveMetadata(metadata) {
+  if (!fs.existsSync('.bit')) {
+    fs.mkdirSync('.bit');
+  }
+  fs.writeFileSync(METADATA_PATH, JSON.stringify(metadata, null, 2));
+}
+
+// Get current branch
+function getCurrentBranch() {
+  try {
+    return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// Create a ghost branch
+function createGhostBranch(name) {
+  const spinner = ora(`Creating ghost branch: ${name}`).start();
+  
+  try {
+    const fullName = `${GHOST_PREFIX}${name}`;
+
+    // Create the actual git branch
+    execSync(`git branch ${fullName}`, { stdio: 'pipe' });
+    
+    // Record in metadata
+    const metadata = loadMetadata();
+    metadata.ghostBranches = metadata.ghostBranches || [];
+    
+    if (!metadata.ghostBranches.find(b => b.name === fullName)) {
+      metadata.ghostBranches.push({
+        name: fullName,
+        createdFrom: currentBranch,
+        createdAt: new Date().toISOString(),
+        isGhost: true
+      });
+      saveMetadata(metadata);
+    }
+    
+    spinner.succeed(`Ghost branch created: ${chalk.magenta(fullName)}`);
+    console.log(chalk.gray(`  Created from: ${currentBranch}`));
+    console.log(chalk.gray(`  To checkout: bit checkout ${name} --ghost`));
+    
+  } catch (error) {
+    spinner.fail('Failed to create ghost branch');
+    console.error(chalk.red(error.message));
+  }
+}
+
+// List all branches (including ghost)
+function listAllBranches(showOnlyGhost = false) {
+  try {
+    // Get all git branches
+    const branches = execSync('git branch -a', { encoding: 'utf-8' })
+      .split('\n')
+      .map(b => b.trim())
+      .filter(b => b);
+    
+    const currentBranch = getCurrentBranch();
+    const metadata = loadMetadata();
+    const ghostBranches = metadata.ghostBranches || [];
+    
+    console.log(chalk.cyan('\n--- Branches ---\n'));
+    
+    // Regular branches
+    if (!showOnlyGhost) {
+      console.log(chalk.yellow('Regular branches:'));
+      branches
+        .filter(b => !b.includes(GHOST_PREFIX) && !b.startsWith('remotes/'))
+        .forEach(branch => {
+          const isCurrent = branch.startsWith('*');
+          const name = branch.replace('* ', '');
+          if (isCurrent) {
+            console.log(chalk.green(`  * ${name}`));
+          } else {
+            console.log(chalk.gray(`    ${name}`));
+          }
+        });
+      console.log('');
+    }
+    
+    // Ghost branches
+    console.log(chalk.magenta('Ghost branches:'));
+    const gitGhostBranches = branches.filter(b => b.includes(GHOST_PREFIX));
+    
+    if (gitGhostBranches.length === 0) {
+      console.log(chalk.gray('  No ghost branches'));
+    } else {
+      gitGhostBranches.forEach(branch => {
+        const isCurrent = branch.startsWith('*');
+        const name = branch.replace('* ', '').replace(GHOST_PREFIX, '');
+        const ghostMeta = ghostBranches.find(g => g.name.includes(name));
+        
+        if (isCurrent) {
+          console.log(chalk.green(`  * ${name}`));
+        } else {
+          console.log(chalk.magenta(`    ${name}`));
+        }
+        
+        if (ghostMeta) {
+          console.log(chalk.gray(`      Created from: ${ghostMeta.createdFrom}`));
+        }
+      });
+    }
+    
+    console.log('');
+    
+  } catch (error) {
+    console.error(chalk.red('Failed to list branches'));
+    console.error(chalk.red(error.message));
+  }
+}
+
+// Delete a ghost branch
+function deleteGhostBranch(name) {
+  const spinner = ora(`Deleting ghost branch: ${name}`).start();
+  
+  try {
+    const fullName = name.startsWith(GHOST_PREFIX) ? name : `${GHOST_PREFIX}${name}`;
+    
+    // Delete git branch
+    execSync(`git branch -D ${fullName}`, { stdio: 'pipe' });
+    
+    // Remove from metadata
+    const metadata = loadMetadata();
+    metadata.ghostBranches = (metadata.ghostBranches || []).filter(b => b.name !== fullName);
+    saveMetadata(metadata);
+    
+    spinner.succeed(`Ghost branch deleted: ${chalk.magenta(fullName)}`);
+    
+  } catch (error) {
+    spinner.fail('Failed to delete ghost branch');
+    console.error(chalk.red(error.message));
+  }
+}
+
+export function ghostBranch(options) {
+  if (options.ghost) {
+    // Create a ghost branch
+    createGhostBranch(options.ghost);
+  } else if (options.listGhost) {
+    // List only ghost branches
+    listAllBranches(true);
+  } else {
+    // List all branches including ghost
+    listAllBranches(false);
+  }
+}
+
+export function listBranches() {
+  listAllBranches(false);
+}
+
+export function checkoutGhost(branch, options) {
+  const spinner = ora(`Checking out: ${branch}`).start();
+  
+  try {
+    let targetBranch = branch;
+    
+    if (options.ghost) {
+      // It's a ghost branch
+      targetBranch = branch.startsWith(GHOST_PREFIX) ? branch : `${GHOST_PREFIX}${branch}`;
+    }
+    
+    execSync(`git checkout ${targetBranch}`, { stdio: 'pipe' });
+    spinner.succeed(`Switched to: ${chalk.cyan(targetBranch)}`);
+    
+    if (options.ghost) {
+      console.log(chalk.magenta('  (This is a ghost branch)'));
+    }
+    
+  } catch (error) {
+    spinner.fail('Checkout failed');
+    console.error(chalk.red(error.message));
+    
+    if (options.ghost) {
+      console.log(chalk.yellow('\nAvailable ghost branches:'));
+      const metadata = loadMetadata();
+      (metadata.ghostBranches || []).forEach(b => {
+        console.log(chalk.gray(`  ${b.name.replace(GHOST_PREFIX, '')}`));
+      });
+    }
+  }
+}

package/src/commands/commit.js

@@ -0,0 +1,211 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// Simple AI message generation (without external API)
+function generateSimpleMessage(diff) {
+  const lines = diff.split('\n');
+  const stats = {
+    additions: 0,
+    deletions: 0,
+    files: new Set(),
+    types: new Set()
+  };
+
+  for (const line of lines) {
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      stats.additions++;
+    } else if (line.startsWith('-') && !line.startsWith('---')) {
+      stats.deletions++;
+    } else if (line.startsWith('diff --git')) {
+      const match = line.match(/b\/(.+)$/);
+      if (match) {
+        stats.files.add(match[1]);
+        const ext = path.extname(match[1]);
+        if (ext) stats.types.add(ext);
+      }
+    }
+  }
+
+  // Detect change type
+  let type = 'chore';
+  const fileList = Array.from(stats.files);
+  
+  if (fileList.some(f => f.includes('test') || f.includes('spec'))) {
+    type = 'test';
+  } else if (fileList.some(f => f.includes('README') || f.includes('docs'))) {
+    type = 'docs';
+  } else if (fileList.some(f => f.includes('fix') || diff.includes('fix'))) {
+    type = 'fix';
+  } else if (stats.additions > stats.deletions * 2) {
+    type = 'feat';
+  } else if (stats.deletions > stats.additions) {
+    type = 'refactor';
+  }
+
+  // Generate scope from files
+  let scope = '';
+  if (fileList.length === 1) {
+    scope = path.basename(fileList[0], path.extname(fileList[0]));
+  } else if (fileList.length > 1) {
+    const dirs = fileList.map(f => path.dirname(f)).filter(d => d !== '.');
+    if (dirs.length > 0) {
+      scope = dirs[0].split('/')[0];
+    }
+  }
+
+  // Generate description
+  let description = '';
+  if (stats.additions > 0 && stats.deletions === 0) {
+    description = `add ${fileList.length} file${fileList.length > 1 ? 's' : ''}`;
+  } else if (stats.deletions > 0 && stats.additions === 0) {
+    description = `remove ${fileList.length} file${fileList.length > 1 ? 's' : ''}`;
+  } else {
+    description = `update ${fileList.length} file${fileList.length > 1 ? 's' : ''} (+${stats.additions}/-${stats.deletions})`;
+  }
+
+  // Format: type(scope): description
+  return scope ? `${type}(${scope}): ${description}` : `${type}: ${description}`;
+}
+
+// AI-powered message generation using OpenAI
+async function generateAIMessage(diff) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  
+  if (!apiKey) {
+    // Fall back to simple generation
+    return generateSimpleMessage(diff);
+  }
+
+  try {
+    const OpenAI = (await import('openai')).default;
+    const openai = new OpenAI({ apiKey });
+
+    const response = await openai.chat.completions.create({
+      model: 'gpt-4o-mini',
+      messages: [
+        {
+          role: 'system',
+          content: `You are a commit message generator. Generate a concise, meaningful commit message following Conventional Commits format.
+
+Format: type(scope): description
+
+Types: feat, fix, docs, style, refactor, test, chore
+- Keep description under 50 characters
+- Use imperative mood ("add" not "added")
+- No period at the end
+- Be specific about what changed
+
+Respond with ONLY the commit message, nothing else.`
+        },
+        {
+          role: 'user',
+          content: `Generate a commit message for this diff:\n\n${diff.slice(0, 4000)}`
+        }
+      ],
+      max_tokens: 100,
+      temperature: 0.3
+    });
+
+    return response.choices[0].message.content.trim();
+  } catch (error) {
+    // Fall back to simple generation on error
+    return generateSimpleMessage(diff);
+  }
+}
+
+// Update symbol tracking after commit
+function updateSymbolTracking(diff) {
+  const symbolsPath = '.bit/symbols.json';
+  
+  if (!fs.existsSync(symbolsPath)) return;
+
+  try {
+    const symbols = JSON.parse(fs.readFileSync(symbolsPath, 'utf-8'));
+    
+    // Extract function names from diff (simple regex)
+    const functionMatches = diff.match(/(?:function|const|let|var)\s+(\w+)/g) || [];
+    const classMatches = diff.match(/class\s+(\w+)/g) || [];
+
+    for (const match of functionMatches) {
+      const name = match.split(/\s+/)[1];
+      if (name) {
+        symbols.functions[name] = symbols.functions[name] || { changes: 0, lastModified: null };
+        symbols.functions[name].changes++;
+        symbols.functions[name].lastModified = new Date().toISOString();
+      }
+    }
+
+    for (const match of classMatches) {
+      const name = match.split(/\s+/)[1];
+      if (name) {
+        symbols.classes[name] = symbols.classes[name] || { changes: 0, lastModified: null };
+        symbols.classes[name].changes++;
+        symbols.classes[name].lastModified = new Date().toISOString();
+      }
+    }
+
+    symbols.lastAnalyzed = new Date().toISOString();
+    fs.writeFileSync(symbolsPath, JSON.stringify(symbols, null, 2));
+  } catch (error) {
+    // Silently fail - don't interrupt commit
+  }
+}
+
+export async function aiCommit(options) {
+  const spinner = ora('Analyzing changes...').start();
+
+  try {
+    // Check if there are staged changes
+    const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' }).trim();
+    
+    if (!staged) {
+      spinner.fail('No staged changes');
+      console.log(chalk.yellow('\nStage your changes first:'));
+      console.log(chalk.gray('  git add <files>'));
+      console.log(chalk.gray('  git add .'));
+      return;
+    }
+
+    // If manual message provided, use it
+    if (options.message) {
+      spinner.text = 'Committing...';
+      execSync(`git commit -m "${options.message}"`, { stdio: 'inherit' });
+      spinner.succeed('Committed with manual message');
+      return;
+    }
+
+    // Get the diff
+    const diff = execSync('git diff --cached', { encoding: 'utf-8' });
+
+    // Generate AI message
+    spinner.text = 'Generating commit message...';
+    const message = await generateAIMessage(diff);
+    spinner.succeed(`Generated: ${chalk.cyan(message)}`);
+
+    // Show preview and confirm
+    console.log('\n' + chalk.gray('─'.repeat(50)));
+    console.log(chalk.yellow('Staged files:'));
+    staged.split('\n').forEach(file => {
+      console.log(chalk.gray(`  ${file}`));
+    });
+    console.log(chalk.gray('─'.repeat(50)));
+
+    // Commit with generated message
+    spinner.start('Committing...');
+    execSync(`git commit -m "${message}"`, { stdio: 'pipe' });
+    
+    // Update symbol tracking
+    updateSymbolTracking(diff);
+    
+    spinner.succeed(chalk.green('Committed successfully!'));
+    console.log(chalk.gray(`\n  ${message}\n`));
+
+  } catch (error) {
+    spinner.fail('Commit failed');
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}

package/src/commands/hotzone.js

@@ -0,0 +1,235 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import chalk from 'chalk';
+import ora from 'ora';
+
+const HOTZONE_PATH = '.bit/hotzones.json';
+const SYMBOLS_PATH = '.bit/symbols.json';
+
+// Simulated team activity (in real world, this would sync across a team)
+function getSimulatedTeamActivity() {
+  // Simulate other developers working on files
+  // In production, this would pull from a shared server or git notes
+  return [
+    { developer: 'alice', file: 'src/auth.js', function: 'login', timestamp: Date.now() - 300000 },
+    { developer: 'bob', file: 'src/api.js', function: 'fetchData', timestamp: Date.now() - 600000 },
+    { developer: 'charlie', file: 'src/utils.js', function: 'formatDate', timestamp: Date.now() - 1800000 },
+  ];
+}
+
+// Get currently modified files
+function getCurrentlyModifiedFiles() {
+  try {
+    // Staged files
+    const staged = execSync('git diff --cached --name-only', { encoding: 'utf-8' })
+      .split('\n')
+      .filter(f => f.trim());
+    
+    // Unstaged modified files
+    const modified = execSync('git diff --name-only', { encoding: 'utf-8' })
+      .split('\n')
+      .filter(f => f.trim());
+    
+    return [...new Set([...staged, ...modified])];
+  } catch {
+    return [];
+  }
+}
+
+// Extract functions from a file (simple regex-based)
+function extractFunctions(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const functions = [];
+    
+    // Match various function patterns
+    const patterns = [
+      /function\s+(\w+)/g,                    // function name()
+      /const\s+(\w+)\s*=\s*(?:async\s*)?\(/g, // const name = () or const name = async (
+      /(\w+)\s*:\s*(?:async\s*)?\(/g,         // name: () or name: async (
+      /async\s+(\w+)\s*\(/g,                  // async name(
+    ];
+    
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        if (!functions.includes(match[1])) {
+          functions.push(match[1]);
+        }
+      }
+    }
+    
+    return functions;
+  } catch {
+    return [];
+  }
+}
+
+// Load hotzone data
+function loadHotzones() {
+  if (!fs.existsSync(HOTZONE_PATH)) {
+    return { zones: [], lastChecked: null };
+  }
+  return JSON.parse(fs.readFileSync(HOTZONE_PATH, 'utf-8'));
+}
+
+// Save hotzone data
+function saveHotzones(data) {
+  if (!fs.existsSync('.bit')) {
+    fs.mkdirSync('.bit');
+  }
+  fs.writeFileSync(HOTZONE_PATH, JSON.stringify(data, null, 2));
+}
+
+// Register current work for team awareness
+function registerCurrentWork(files) {
+  const hotzones = loadHotzones();
+  const username = process.env.USER || process.env.USERNAME || 'you';
+  
+  hotzones.zones = hotzones.zones.filter(z => z.developer !== username);
+  
+  for (const file of files) {
+    const functions = extractFunctions(file);
+    hotzones.zones.push({
+      developer: username,
+      file,
+      functions,
+      timestamp: Date.now()
+    });
+  }
+  
+  hotzones.lastChecked = new Date().toISOString();
+  saveHotzones(hotzones);
+}
+
+// Check for conflicts with team
+function detectHotZones(modifiedFiles, silent = false) {
+  const teamActivity = getSimulatedTeamActivity();
+  const hotzones = loadHotzones();
+  const conflicts = [];
+  
+  const username = process.env.USER || process.env.USERNAME || 'you';
+  
+  for (const file of modifiedFiles) {
+    const myFunctions = extractFunctions(file);
+    
+    // Check against simulated team activity
+    for (const activity of teamActivity) {
+      if (activity.file === file || file.includes(activity.file.split('/').pop())) {
+        // File-level conflict
+        conflicts.push({
+          type: 'file',
+          file,
+          developer: activity.developer,
+          function: activity.function,
+          age: Math.round((Date.now() - activity.timestamp) / 60000)
+        });
+      }
+      
+      // Function-level conflict
+      if (myFunctions.includes(activity.function)) {
+        conflicts.push({
+          type: 'function',
+          file,
+          developer: activity.developer,
+          function: activity.function,
+          age: Math.round((Date.now() - activity.timestamp) / 60000)
+        });
+      }
+    }
+    
+    // Check against recorded hotzones
+    for (const zone of hotzones.zones) {
+      if (zone.developer === username) continue;
+      
+      if (zone.file === file) {
+        const overlap = myFunctions.filter(f => zone.functions.includes(f));
+        if (overlap.length > 0) {
+          conflicts.push({
+            type: 'function',
+            file,
+            developer: zone.developer,
+            function: overlap[0],
+            age: Math.round((Date.now() - zone.timestamp) / 60000)
+          });
+        }
+      }
+    }
+  }
+  
+  return conflicts;
+}
+
+export function checkHotZones(silent = false) {
+  if (silent === true) {
+    // Silent mode - just check and show warnings
+    const modifiedFiles = getCurrentlyModifiedFiles();
+    if (modifiedFiles.length === 0) return;
+    
+    const conflicts = detectHotZones(modifiedFiles, true);
+    if (conflicts.length > 0) {
+      console.log(chalk.yellow('\nHot Zone Warning:'));
+      conflicts.slice(0, 2).forEach(c => {
+        console.log(chalk.yellow(`  ${c.developer} is working on ${c.function || c.file}`));
+      });
+    }
+    return;
+  }
+  
+  const spinner = ora('Scanning for hot zones...').start();
+  
+  try {
+    const modifiedFiles = getCurrentlyModifiedFiles();
+    
+    if (modifiedFiles.length === 0) {
+      spinner.info('No modified files to check');
+      return;
+    }
+    
+    // Register current work
+    registerCurrentWork(modifiedFiles);
+    
+    // Detect conflicts
+    const conflicts = detectHotZones(modifiedFiles);
+    
+    spinner.stop();
+    
+    console.log(chalk.cyan('\n--- Hot Zone Analysis ---\n'));
+    console.log(chalk.gray(`Files you're working on: ${modifiedFiles.length}`));
+    modifiedFiles.forEach(f => console.log(chalk.gray(`  ${f}`)));
+    
+    console.log(chalk.gray('\n' + '─'.repeat(50)));
+    
+    if (conflicts.length === 0) {
+      console.log(chalk.green('\nNo overlapping work detected!'));
+      console.log(chalk.gray('You have clear ownership of these changes.'));
+    } else {
+      console.log(chalk.yellow(`\nWarning: ${conflicts.length} potential conflict(s) detected!\n`));
+      
+      for (const conflict of conflicts) {
+        if (conflict.type === 'function') {
+          console.log(chalk.red(`  CAUTION: ${conflict.developer} is working on ${conflict.function}()`));
+          console.log(chalk.gray(`           in ${conflict.file}`));
+          console.log(chalk.gray(`           Last activity: ${conflict.age} minutes ago`));
+        } else {
+          console.log(chalk.yellow(`  NOTICE: ${conflict.developer} recently modified ${conflict.file}`));
+          console.log(chalk.gray(`          Last activity: ${conflict.age} minutes ago`));
+        }
+        console.log('');
+      }
+      
+      console.log(chalk.yellow('Recommendations:'));
+      console.log(chalk.gray('  - Coordinate with team members before pushing'));
+      console.log(chalk.gray('  - Use: bit merge --preview to check for conflicts'));
+      console.log(chalk.gray('  - Consider breaking work into smaller commits'));
+    }
+    
+    console.log('');
+    
+  } catch (error) {
+    spinner.fail('Hot zone check failed');
+    console.error(chalk.red(error.message));
+  }
+}