bit-cli-ai 1.0.0

package/.env.example

@@ -0,0 +1,15 @@
+# Bit CLI Environment Variables
+# Copy this file to .env and fill in your values
+
+# AI Provider API Keys
+OPENAI_API_KEY=sk-your-openai-key-here
+ANTHROPIC_API_KEY=sk-ant-your-anthropic-key-here
+
+# AI Configuration (optional)
+BIT_AI_PROVIDER=openai
+BIT_AI_MODEL=gpt-4o-mini
+
+# Debug Mode (optional)
+BIT_DEBUG=false
+BIT_LOG_LEVEL=info
+BIT_VERBOSE=false

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,178 @@
+# Bit CLI
+
+> Git with a brain - An intelligent Git wrapper with AI-powered commits, ghost branches, and predictive merge analysis.
+
+[![CI](https://github.com/yourusername/bit-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/yourusername/bit-cli/actions/workflows/ci.yml)
+[![npm version](https://badge.fury.io/js/bit-cli.svg)](https://badge.fury.io/js/bit-cli)
+[![Node.js Version](https://img.shields.io/node/v/bit-cli.svg)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+### Level 1: Foundation
+- **Transparent Passthrough** - All git commands work through bit (`bit status` = `git status`)
+- **Smart Init** - Auto-detects project type and generates appropriate `.gitignore`
+- **AI Commits** - Generates meaningful commit messages using AI or rule-based analysis
+
+### Level 2: Architect
+- **Ghost Branches** - Hidden experimental branches that don't clutter your branch list
+- **Virtual Merge** - Preview merge conflicts before actually merging
+- **`.bit` Directory** - Intelligent metadata storage separate from `.git`
+
+### Level 3: Visionary
+- **Symbol Tracking** - Track function-level changes, not just file-level
+- **Hot Zone Detection** - Warns when teammates are editing the same functions
+
+## Installation
+
+```bash
+# Install globally
+npm install -g bit-cli
+
+# Or use npx
+npx bit-cli <command>
+```
+
+## Quick Start
+
+```bash
+# Initialize a new repository with smart defaults
+bit init
+
+# Make some changes, then commit with AI
+git add .
+bit commit
+
+# Create a ghost branch for experiments
+bit branch --ghost experiment
+
+# Preview merge conflicts before merging
+bit merge --preview feature-branch
+
+# Check for team conflicts
+bit hotzone
+
+# Analyze code changes
+bit analyze
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `bit init` | Initialize repo with smart .gitignore and .bit directory |
+| `bit commit` | AI-powered commit message generation |
+| `bit commit -m "msg"` | Manual commit message |
+| `bit branch --ghost <name>` | Create a ghost (hidden) branch |
+| `bit branch` | List all branches including ghost branches |
+| `bit checkout <branch> --ghost` | Checkout a ghost branch |
+| `bit merge --preview <branch>` | Preview merge conflicts |
+| `bit merge <branch>` | Smart merge with conflict preview |
+| `bit hotzone` | Detect overlapping work with team |
+| `bit analyze` | Analyze code at function/symbol level |
+| `bit <any-git-cmd>` | Passthrough to git |
+
+## Configuration
+
+### Environment Variables
+
+```bash
+# Required for AI features
+OPENAI_API_KEY=sk-your-key-here
+
+# Optional
+BIT_AI_MODEL=gpt-4o-mini
+BIT_DEBUG=true
+BIT_LOG_LEVEL=debug
+BIT_VERBOSE=true
+```
+
+### Global Configuration
+
+Config stored in `~/.bit/config.json`:
+
+```json
+{
+  "ai": {
+    "provider": "openai",
+    "model": "gpt-4o-mini",
+    "maxTokens": 500,
+    "temperature": 0.7
+  },
+  "git": {
+    "ghostPrefix": "ghost/",
+    "autoStage": false
+  },
+  "ui": {
+    "colors": true,
+    "spinners": true
+  }
+}
+```
+
+### Project Configuration
+
+Project-specific config in `.bit/config.json` overrides global settings.
+
+## Architecture
+
+```
+bit-cli/
+├── src/
+│   ├── index.js              # CLI entry point
+│   ├── commands/             # Command implementations
+│   │   ├── init.js
+│   │   ├── commit.js
+│   │   ├── branch.js
+│   │   ├── merge.js
+│   │   ├── hotzone.js
+│   │   └── analyze.js
+│   └── utils/                # Shared utilities
+│       ├── ai.js             # AI service
+│       ├── config.js         # Configuration management
+│       ├── errors.js         # Error handling
+│       ├── git.js            # Git operations
+│       ├── logger.js         # Logging
+│       └── validation.js     # Input validation
+├── tests/                    # Test files
+└── .github/workflows/        # CI/CD
+```
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/yourusername/bit-cli.git
+cd bit-cli
+
+# Install dependencies
+npm install
+
+# Run in development
+npm run dev
+
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing`)
+3. Commit your changes (`bit commit`)
+4. Push to the branch (`git push origin feature/amazing`)
+5. Open a Pull Request
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "bit-cli-ai",
+  "version": "1.0.0",
+  "description": "Git with a brain - intelligent Git wrapper with AI-powered commits, ghost branches, and predictive merge",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "bit": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js",
+    "test": "node --test tests/**/*.test.js",
+    "test:watch": "node --test --watch tests/**/*.test.js",
+    "test:coverage": "c8 node --test tests/**/*.test.js",
+    "lint": "eslint src/**/*.js",
+    "lint:fix": "eslint src/**/*.js --fix",
+    "format": "prettier --write \"src/**/*.js\"",
+    "validate": "npm run lint && npm run test",
+    "prepublishOnly": "npm run validate"
+  },
+  "keywords": [
+    "git",
+    "cli",
+    "ai",
+    "developer-tools",
+    "productivity",
+    "version-control"
+  ],
+  "author": "Shubhashis Baral <shubhashis9556@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shubhashis9556/bit-cli.git"
+  },
+  "homepage": "https://github.com/shubhashis9556/bit-cli#readme",
+  "bugs": {
+    "url": "https://github.com/shubhashis9556/bit-cli/issues"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/shubhashis9556"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.0.1",
+    "openai": "^4.52.0",
+    "dotenv": "^16.4.5",
+    "winston": "^3.13.0",
+    "conf": "^12.0.0",
+    "zod": "^3.23.8",
+    "simple-git": "^3.25.0",
+    "inquirer": "^9.2.23"
+  },
+  "devDependencies": {
+    "c8": "^9.1.0",
+    "eslint": "^9.5.0",
+    "prettier": "^3.3.2"
+  }
+}

package/src/commands/analyze.js

@@ -0,0 +1,230 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import chalk from 'chalk';
+import ora from 'ora';
+
+const SYMBOLS_PATH = '.bit/symbols.json';
+
+
+
+// Analyze diff to find changed symbols
+function analyzeChangedSymbols(diff) {
+  const changedSymbols = {
+    added: [],
+    modified: [],
+    removed: []
+  };
+  
+  const lines = diff.split('\n');
+  let currentFile = null;
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    
+    // Track current file
+    if (line.startsWith('diff --git')) {
+      const match = line.match(/b\/(.+)$/);
+      if (match) {
+        currentFile = match[1];
+      }
+      continue;
+    }
+    
+    // Added lines
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      const functionMatch = line.match(/(?:function|const|let|var)\s+(\w+)/);
+      const classMatch = line.match(/class\s+(\w+)/);
+      
+      if (functionMatch) {
+        changedSymbols.added.push({
+          name: functionMatch[1],
+          type: 'function',
+          file: currentFile
+        });
+      }
+      if (classMatch) {
+        changedSymbols.added.push({
+          name: classMatch[1],
+          type: 'class',
+          file: currentFile
+        });
+      }
+    }
+    
+    // Removed lines
+    if (line.startsWith('-') && !line.startsWith('---')) {
+      const functionMatch = line.match(/(?:function|const|let|var)\s+(\w+)/);
+      const classMatch = line.match(/class\s+(\w+)/);
+      
+      if (functionMatch) {
+        changedSymbols.removed.push({
+          name: functionMatch[1],
+          type: 'function',
+          file: currentFile
+        });
+      }
+      if (classMatch) {
+        changedSymbols.removed.push({
+          name: classMatch[1],
+          type: 'class',
+          file: currentFile
+        });
+      }
+    }
+  }
+  
+  // Modified = appears in both added and removed
+  const addedNames = changedSymbols.added.map(s => s.name);
+  const removedNames = changedSymbols.removed.map(s => s.name);
+  
+  for (const name of addedNames) {
+    if (removedNames.includes(name)) {
+      changedSymbols.modified.push({
+        name,
+        file: changedSymbols.added.find(s => s.name === name)?.file
+      });
+    }
+  }
+  
+  // Clean up: remove modified from added/removed
+  const modifiedNames = changedSymbols.modified.map(s => s.name);
+  changedSymbols.added = changedSymbols.added.filter(s => !modifiedNames.includes(s.name));
+  changedSymbols.removed = changedSymbols.removed.filter(s => !modifiedNames.includes(s.name));
+  
+  return changedSymbols;
+}
+
+// Load symbol database
+function loadSymbols() {
+  if (!fs.existsSync(SYMBOLS_PATH)) {
+    return { functions: {}, classes: {}, lastAnalyzed: null };
+  }
+  return JSON.parse(fs.readFileSync(SYMBOLS_PATH, 'utf-8'));
+}
+
+// Save symbol database
+function saveSymbols(data) {
+  if (!fs.existsSync('.bit')) {
+    fs.mkdirSync('.bit');
+  }
+  fs.writeFileSync(SYMBOLS_PATH, JSON.stringify(data, null, 2));
+}
+
+// Get frequently changed symbols
+function getHotSymbols(symbolDb) {
+  const all = [];
+  
+  for (const [name, data] of Object.entries(symbolDb.functions)) {
+    all.push({ name, type: 'function', ...data });
+  }
+  for (const [name, data] of Object.entries(symbolDb.classes)) {
+    all.push({ name, type: 'class', ...data });
+  }
+  
+  return all.sort((a, b) => b.changes - a.changes).slice(0, 10);
+}
+
+export async function analyzeSymbols() {
+  const spinner = ora('Analyzing code symbols...').start();
+  
+  try {
+    // Check if in git repo
+    try {
+      execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+    } catch {
+      spinner.fail('Not a git repository');
+      return;
+    }
+    
+    // Get staged diff
+    let diff = execSync('git diff --cached', { encoding: 'utf-8' });
+    
+    // If no staged changes, get unstaged
+    if (!diff.trim()) {
+      diff = execSync('git diff', { encoding: 'utf-8' });
+    }
+    
+    if (!diff.trim()) {
+      spinner.info('No changes to analyze');
+      console.log(chalk.gray('\nMake some changes or stage files first.'));
+      return;
+    }
+    
+    // Analyze changed symbols
+    const changedSymbols = analyzeChangedSymbols(diff);
+    
+    // Update symbol database
+    const symbolDb = loadSymbols();
+    
+    for (const symbol of [...changedSymbols.added, ...changedSymbols.modified]) {
+      const db = symbol.type === 'class' ? symbolDb.classes : symbolDb.functions;
+      db[symbol.name] = db[symbol.name] || { changes: 0, files: [] };
+      db[symbol.name].changes++;
+      db[symbol.name].lastModified = new Date().toISOString();
+      if (symbol.file && !db[symbol.name].files.includes(symbol.file)) {
+        db[symbol.name].files.push(symbol.file);
+      }
+    }
+    
+    symbolDb.lastAnalyzed = new Date().toISOString();
+    saveSymbols(symbolDb);
+    
+    spinner.stop();
+    
+    // Display results
+    console.log(chalk.cyan('\n--- Symbol Analysis ---\n'));
+    
+    // Changed symbols in current diff
+    const totalChanges = changedSymbols.added.length + changedSymbols.modified.length + changedSymbols.removed.length;
+    
+    if (totalChanges === 0) {
+      console.log(chalk.gray('No function/class changes detected in diff.'));
+      console.log(chalk.gray('(Only structural changes like functions/classes are tracked)'));
+    } else {
+      if (changedSymbols.added.length > 0) {
+        console.log(chalk.green(`Added (${changedSymbols.added.length}):`));
+        changedSymbols.added.forEach(s => {
+          console.log(chalk.green(`  + ${s.name}() in ${s.file || 'unknown'}`));
+        });
+        console.log('');
+      }
+      
+      if (changedSymbols.modified.length > 0) {
+        console.log(chalk.yellow(`Modified (${changedSymbols.modified.length}):`));
+        changedSymbols.modified.forEach(s => {
+          console.log(chalk.yellow(`  ~ ${s.name}() in ${s.file || 'unknown'}`));
+        });
+        console.log('');
+      }
+      
+      if (changedSymbols.removed.length > 0) {
+        console.log(chalk.red(`Removed (${changedSymbols.removed.length}):`));
+        changedSymbols.removed.forEach(s => {
+          console.log(chalk.red(`  - ${s.name}() in ${s.file || 'unknown'}`));
+        });
+        console.log('');
+      }
+    }
+    
+    // Show hot symbols (most frequently changed)
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(chalk.cyan('\nMost Changed Symbols (all time):'));
+    
+    const hotSymbols = getHotSymbols(symbolDb);
+    
+    if (hotSymbols.length === 0) {
+      console.log(chalk.gray('  No symbol history yet. Make more commits!'));
+    } else {
+      hotSymbols.slice(0, 5).forEach((s, i) => {
+        const bar = '█'.repeat(Math.min(s.changes, 10));
+        console.log(chalk.gray(`  ${i + 1}. ${s.name}() - ${s.changes} changes ${chalk.blue(bar)}`));
+      });
+    }
+    
+    console.log('');
+    
+  } catch (error) {
+    spinner.fail('Analysis failed');
+    console.error(chalk.red(error.message));
+  }
+}