bit-cli-ai 1.0.0

package/src/commands/init.js

@@ -0,0 +1,233 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// Gitignore templates for different project types
+const gitignoreTemplates = {
+  node: `# Dependencies
+node_modules/
+package-lock.json
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Build
+dist/
+build/
+.next/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+`,
+  python: `# Byte-compiled
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Environment
+.env
+
+# IDE
+.vscode/
+.idea/
+
+# Distribution
+dist/
+build/
+*.egg-info/
+`,
+  rust: `# Build
+/target/
+Cargo.lock
+
+# IDE
+.vscode/
+.idea/
+
+# Environment
+.env
+`,
+  go: `# Binaries
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Build
+/bin/
+/pkg/
+
+# IDE
+.vscode/
+.idea/
+
+# Environment
+.env
+`,
+  generic: `# Environment
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+`
+};
+
+// Detect project type based on files present
+function detectProjectType() {
+  const detectors = [
+    { file: 'package.json', type: 'node' },
+    { file: 'requirements.txt', type: 'python' },
+    { file: 'Pipfile', type: 'python' },
+    { file: 'pyproject.toml', type: 'python' },
+    { file: 'Cargo.toml', type: 'rust' },
+    { file: 'go.mod', type: 'go' },
+  ];
+
+  for (const detector of detectors) {
+    if (fs.existsSync(detector.file)) {
+      return detector.type;
+    }
+  }
+
+  return 'generic';
+}
+
+// Initialize .bit directory for Bit's intelligence layer
+function initBitDirectory() {
+  const bitDir = '.bit';
+  
+  if (!fs.existsSync(bitDir)) {
+    fs.mkdirSync(bitDir);
+  }
+
+  // Create metadata files
+  const metadata = {
+    version: '1.0.0',
+    createdAt: new Date().toISOString(),
+    ghostBranches: [],
+    hotZones: [],
+    symbolHistory: []
+  };
+
+  fs.writeFileSync(
+    path.join(bitDir, 'metadata.json'),
+    JSON.stringify(metadata, null, 2)
+  );
+
+  // Create symbol tracking database
+  fs.writeFileSync(
+    path.join(bitDir, 'symbols.json'),
+    JSON.stringify({ functions: {}, classes: {}, lastAnalyzed: null }, null, 2)
+  );
+
+  // Create hot zones tracking
+  fs.writeFileSync(
+    path.join(bitDir, 'hotzones.json'),
+    JSON.stringify({ zones: [], lastChecked: null }, null, 2)
+  );
+
+  // Add .bit to .gitignore if not already there
+  const gitignorePath = '.gitignore';
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf-8');
+    if (!content.includes('.bit/')) {
+      fs.appendFileSync(gitignorePath, '\n# Bit intelligence layer\n.bit/\n');
+    }
+  }
+
+  return bitDir;
+}
+
+export async function smartInit() {
+  const spinner = ora('Initializing repository...').start();
+
+  try {
+    // Check if already a git repo
+    const isGitRepo = fs.existsSync('.git');
+    
+    if (!isGitRepo) {
+      // Initialize git repository
+      execSync('git init', { stdio: 'pipe' });
+      spinner.succeed('Git repository initialized');
+    } else {
+      spinner.info('Git repository already exists');
+    }
+
+    // Detect project type
+    spinner.start('Detecting project type...');
+    const projectType = detectProjectType();
+    spinner.succeed(`Detected project type: ${chalk.green(projectType)}`);
+
+    // Create or update .gitignore
+    spinner.start('Setting up .gitignore...');
+    const gitignoreContent = gitignoreTemplates[projectType];
+    
+    if (fs.existsSync('.gitignore')) {
+      // Append to existing .gitignore
+      const existing = fs.readFileSync('.gitignore', 'utf-8');
+      const newEntries = gitignoreContent
+        .split('\n')
+        .filter(line => line.trim() && !line.startsWith('#') && !existing.includes(line.trim()));
+      
+      if (newEntries.length > 0) {
+        fs.appendFileSync('.gitignore', '\n# Added by Bit\n' + newEntries.join('\n') + '\n');
+        spinner.succeed(`Updated .gitignore with ${newEntries.length} new entries`);
+      } else {
+        spinner.info('.gitignore already up to date');
+      }
+    } else {
+      fs.writeFileSync('.gitignore', gitignoreContent);
+      spinner.succeed('Created .gitignore');
+    }
+
+    // Initialize Bit directory
+    spinner.start('Initializing Bit intelligence layer...');
+    const bitDir = initBitDirectory();
+    spinner.succeed(`Bit intelligence layer created at ${chalk.cyan(bitDir)}/`);
+
+    // Summary
+    console.log('\n' + chalk.green('Bit initialized successfully!'));
+    console.log(chalk.gray('─'.repeat(40)));
+    console.log(`  Project type: ${chalk.cyan(projectType)}`);
+    console.log(`  Git repo: ${chalk.cyan('.git/')}`);
+    console.log(`  Bit brain: ${chalk.cyan('.bit/')}`);
+    console.log(chalk.gray('─'.repeat(40)));
+    console.log('\nNext steps:');
+    console.log(`  ${chalk.yellow('bit commit')}    - AI-powered commits`);
+    console.log(`  ${chalk.yellow('bit branch --ghost <name>')} - Create ghost branch`);
+    console.log(`  ${chalk.yellow('bit merge --preview <branch>')} - Preview merge`);
+
+  } catch (error) {
+    spinner.fail('Initialization failed');
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}

package/src/commands/merge.js

@@ -0,0 +1,191 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// Parse merge-tree output to find conflicts
+function parseConflicts(output) {
+  const conflicts = [];
+  const lines = output.split('\n');
+  
+  let currentFile = null;
+  let inConflict = false;
+  
+  for (const line of lines) {
+    // Detect file markers
+    if (line.includes('CONFLICT')) {
+      const match = line.match(/CONFLICT.*?: (.+)/);
+      if (match) {
+        conflicts.push({
+          file: match[1].trim(),
+          type: 'content conflict'
+        });
+      }
+    }
+    
+    // Detect merge conflicts in content
+    if (line.startsWith('<<<<<<< ')) {
+      inConflict = true;
+    }
+    if (line.startsWith('>>>>>>> ')) {
+      inConflict = false;
+    }
+  }
+  
+  return conflicts;
+}
+
+// Get files that will be modified in merge
+function getAffectedFiles(branch) {
+  try {
+    const currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+    
+    // Get diff between current and target branch
+    const diff = execSync(`git diff --name-only ${currentBranch}...${branch}`, { encoding: 'utf-8' });
+    
+    return diff.split('\n').filter(f => f.trim());
+  } catch {
+    return [];
+  }
+}
+
+// Perform virtual merge preview
+function virtualMerge(branch) {
+  const spinner = ora('Analyzing merge...').start();
+  
+  try {
+    const currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+    
+    // Use git merge-tree for conflict detection
+    let mergeResult;
+    let hasConflicts = false;
+    
+    try {
+      // Get merge base
+      const mergeBase = execSync(`git merge-base ${currentBranch} ${branch}`, { encoding: 'utf-8' }).trim();
+      
+      // Perform merge-tree (virtual merge)
+      mergeResult = execSync(`git merge-tree ${mergeBase} ${currentBranch} ${branch}`, { encoding: 'utf-8' });
+      
+      // Check for conflict markers
+      hasConflicts = mergeResult.includes('<<<<<<<') || mergeResult.includes('>>>>>>>');
+      
+    } catch (error) {
+      // merge-tree might fail or indicate conflicts
+      mergeResult = error.stdout || '';
+      hasConflicts = true;
+    }
+    
+    // Get affected files
+    const affectedFiles = getAffectedFiles(branch);
+    
+    spinner.stop();
+    
+    // Display results
+    console.log(chalk.cyan('\n--- Merge Preview ---\n'));
+    console.log(`Current branch: ${chalk.green(currentBranch)}`);
+    console.log(`Target branch:  ${chalk.yellow(branch)}`);
+    console.log(chalk.gray('─'.repeat(50)));
+    
+    // Show affected files
+    console.log(chalk.yellow(`\nFiles to be modified (${affectedFiles.length}):`));
+    if (affectedFiles.length === 0) {
+      console.log(chalk.gray('  No files will be modified'));
+    } else {
+      affectedFiles.forEach(file => {
+        console.log(chalk.gray(`  ${file}`));
+      });
+    }
+    
+    // Show conflict analysis
+    console.log(chalk.gray('\n' + '─'.repeat(50)));
+    
+    if (hasConflicts) {
+      console.log(chalk.red('\nPotential Conflicts Detected:'));
+      
+      const conflicts = parseConflicts(mergeResult);
+      if (conflicts.length > 0) {
+        conflicts.forEach(c => {
+          console.log(chalk.red(`  - ${c.file}: ${c.type}`));
+        });
+      } else {
+        console.log(chalk.yellow('  Content conflicts detected in merge'));
+        console.log(chalk.gray('  Review changes carefully before merging'));
+      }
+      
+      console.log(chalk.yellow('\nRecommendation: Review conflicts before merging'));
+      console.log(chalk.gray('  To proceed: git merge ' + branch));
+      
+    } else {
+      console.log(chalk.green('\nNo conflicts detected!'));
+      console.log(chalk.green('This merge should be clean.'));
+      console.log(chalk.gray('\n  To merge: bit merge ' + branch));
+    }
+    
+    console.log('');
+    
+    return { hasConflicts, affectedFiles };
+    
+  } catch (error) {
+    spinner.fail('Merge preview failed');
+    console.error(chalk.red(error.message));
+    return { hasConflicts: true, affectedFiles: [] };
+  }
+}
+
+// Perform actual merge
+function performMerge(branch) {
+  const spinner = ora(`Merging ${branch}...`).start();
+  
+  try {
+    execSync(`git merge ${branch}`, { stdio: 'pipe' });
+    spinner.succeed(chalk.green(`Successfully merged ${branch}`));
+  } catch (error) {
+    spinner.fail('Merge failed');
+    
+    // Check if it's a conflict
+    const status = execSync('git status', { encoding: 'utf-8' });
+    
+    if (status.includes('Unmerged')) {
+      console.log(chalk.yellow('\nMerge conflicts detected. Resolve them manually:'));
+      console.log(chalk.gray('  1. Edit conflicting files'));
+      console.log(chalk.gray('  2. git add <resolved-files>'));
+      console.log(chalk.gray('  3. git commit'));
+    } else {
+      console.error(chalk.red(error.message));
+    }
+  }
+}
+
+export function mergePreview(branch, options) {
+  // Check if branch exists
+  try {
+    execSync(`git rev-parse --verify ${branch}`, { stdio: 'pipe' });
+  } catch {
+    // Try with ghost prefix
+    try {
+      execSync(`git rev-parse --verify ghost/${branch}`, { stdio: 'pipe' });
+      branch = `ghost/${branch}`;
+    } catch {
+      console.error(chalk.red(`Branch not found: ${branch}`));
+      console.log(chalk.gray('\nAvailable branches:'));
+      execSync('git branch', { stdio: 'inherit' });
+      return;
+    }
+  }
+  
+  if (options.preview) {
+    // Just preview, don't merge
+    virtualMerge(branch);
+  } else {
+    // First show preview, then merge
+    const { hasConflicts } = virtualMerge(branch);
+    
+    if (!hasConflicts) {
+      console.log(chalk.gray('Proceeding with merge...\n'));
+      performMerge(branch);
+    } else {
+      console.log(chalk.yellow('Use --preview to see details without merging'));
+      console.log(chalk.gray('Or use: git merge ' + branch + ' to proceed anyway'));
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+import { smartInit } from './commands/init.js';
+import { aiCommit } from './commands/commit.js';
+import { ghostBranch, listBranches, checkoutGhost } from './commands/branch.js';
+import { mergePreview } from './commands/merge.js';
+import { checkHotZones } from './commands/hotzone.js';
+import { analyzeSymbols } from './commands/analyze.js';
+
+const program = new Command();
+
+program
+  .name('bit')
+  .description(chalk.cyan('Bit — Git with a brain'))
+  .version('1.0.0');
+
+// ============ SMART INIT ============
+program
+  .command('init')
+  .description('Initialize repo with smart .gitignore and .bit directory')
+  .action(smartInit);
+
+// ============ AI COMMIT ============
+program
+  .command('commit')
+  .description('AI-powered commit message generation')
+  .option('-m, --message <msg>', 'Manual commit message (skip AI)')
+  .action(aiCommit);
+
+// ============ GHOST BRANCHES ============
+program
+  .command('branch')
+  .description('List all branches including ghost branches')
+  .option('--ghost <name>', 'Create a ghost branch')
+  .option('--list-ghost', 'List only ghost branches')
+  .action(ghostBranch);
+
+program
+  .command('checkout')
+  .description('Checkout a branch')
+  .argument('<branch>', 'Branch name to checkout')
+  .option('--ghost', 'Checkout a ghost branch')
+  .action(checkoutGhost);
+
+// ============ MERGE PREVIEW ============
+program
+  .command('merge')
+  .description('Merge branches with optional preview')
+  .argument('<branch>', 'Branch to merge')
+  .option('--preview', 'Preview merge conflicts without merging')
+  .action(mergePreview);
+
+// ============ HOT ZONE DETECTION ============
+program
+  .command('hotzone')
+  .description('Detect overlapping work with other developers')
+  .action(checkHotZones);
+
+// ============ SYMBOL ANALYSIS ============
+program
+  .command('analyze')
+  .description('Analyze code changes at function/symbol level')
+  .action(analyzeSymbols);
+
+// ============ STATUS WITH INTELLIGENCE ============
+program
+  .command('status')
+  .description('Enhanced git status with Bit intelligence')
+  .action(() => {
+    try {
+      console.log(chalk.cyan('\n--- Bit Status ---\n'));
+      execSync('git status', { stdio: 'inherit' });
+      
+      // Add Bit intelligence
+      checkHotZones(true); // silent mode
+    } catch (error) {
+      console.error(chalk.red('Not a git repository'));
+    }
+  });
+
+// ============ GIT PASSTHROUGH ============
+// Any unknown command goes directly to git
+program
+  .arguments('<command> [args...]')
+  .action((command, args) => {
+    try {
+      const gitCmd = `git ${command} ${args.join(' ')}`;
+      execSync(gitCmd, { stdio: 'inherit' });
+    } catch (error) {
+      // Git will print its own error message
+      process.exit(1);
+    }
+  });
+
+// Handle no arguments
+if (process.argv.length === 2) {
+  program.outputHelp();
+}
+
+program.parse();