@vibedx/vibekit 0.1.0

package/src/commands/review/index.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+import {
+  createTempDir,
+  cleanupTempDir,
+  mockConsole,
+  mockProcessCwd,
+  mockProcessExit,
+  createMockVibeProject
+} from '../../utils/test-helpers.js';
+import reviewCommand from './index.js';
+
+/** Creates a minimal valid ticket file in the tickets directory */
+function createMockTicket(ticketsDir, id = 'TKT-001', status = 'in_progress') {
+  const content = `---
+id: ${id}
+title: Test Ticket
+slug: ${id.toLowerCase()}-test-ticket
+status: ${status}
+priority: medium
+created_at: 2026-01-01T00:00:00.000Z
+updated_at: 2026-01-01T00:00:00.000Z
+---
+
+## Description
+
+Test ticket description.
+
+## Acceptance Criteria
+
+- [ ] Criterion one
+
+## Implementation Notes
+
+Some notes.
+
+## Testing & Test Cases
+
+Some tests.
+`;
+  fs.writeFileSync(path.join(ticketsDir, `${id}-test-ticket.md`), content, 'utf-8');
+}
+
+/** Runs a review command and swallows the process.exit() throw */
+async function runReview(args) {
+  try {
+    await reviewCommand(args);
+  } catch (err) {
+    if (!err.message.startsWith('process.exit(')) throw err;
+  }
+}
+
+describe('review command', () => {
+  let tempDir;
+  let consoleMock;
+  let restoreCwd;
+  let exitMock;
+  let ticketsDir;
+
+  beforeEach(() => {
+    tempDir = createTempDir('review-test');
+    consoleMock = mockConsole();
+    restoreCwd = mockProcessCwd(tempDir);
+    exitMock = mockProcessExit();
+
+    const { ticketsDir: td } = createMockVibeProject(tempDir);
+    ticketsDir = td;
+    createMockTicket(ticketsDir);
+  });
+
+  afterEach(() => {
+    consoleMock.restore();
+    restoreCwd();
+    exitMock.restore();
+    cleanupTempDir(tempDir);
+  });
+
+  describe('help', () => {
+    it('should display help with --help flag', async () => {
+      await reviewCommand(['--help']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('vibe review'))).toBe(true);
+      expect(consoleMock.logs.log.some(m => m.includes('Usage:'))).toBe(true);
+    });
+
+    it('should display help with -h flag', async () => {
+      await reviewCommand(['-h']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('vibe review'))).toBe(true);
+    });
+  });
+
+  describe('clean subcommand', () => {
+    it('should report no cache files when cache is empty', async () => {
+      await reviewCommand(['clean']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('No review cache files to clean'))).toBe(true);
+    });
+
+    it('should report no cache files for a specific ticket when base cache dir is missing', async () => {
+      await reviewCommand(['clean', 'TKT-001']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('No review cache files to clean'))).toBe(true);
+    });
+
+    it('should report no cache files for specific ticket when base cache exists but ticket dir missing', async () => {
+      // Create the base cache dir but not the TKT-001 subdirectory
+      fs.mkdirSync(path.join(tempDir, '.vibe/.cache/review/logs'), { recursive: true });
+
+      await reviewCommand(['clean', 'TKT-001']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('No cache files found for ticket TKT-001'))).toBe(true);
+    });
+
+    it('should clean existing cache files for a specific ticket', async () => {
+      const cacheDir = path.join(tempDir, '.vibe/.cache/review/logs/TKT-001');
+      fs.mkdirSync(cacheDir, { recursive: true });
+      fs.writeFileSync(path.join(cacheDir, 'review-2026-01-01T00-00-00.txt'), 'test content');
+
+      await reviewCommand(['clean', 'TKT-001']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('Cleaned'))).toBe(true);
+      expect(fs.existsSync(cacheDir)).toBe(false);
+    });
+
+    it('should normalise a numeric ticket ID for clean', async () => {
+      fs.mkdirSync(path.join(tempDir, '.vibe/.cache/review/logs'), { recursive: true });
+
+      await reviewCommand(['clean', '1']);
+
+      expect(consoleMock.logs.log.some(m => m.includes('No cache files found for ticket TKT-001'))).toBe(true);
+    });
+  });
+
+  describe('ticket ID validation', () => {
+    it('should reject an invalid ticket ID format', async () => {
+      await runReview(['invalid-id']);
+
+      expect(consoleMock.logs.error.some(m => m.includes('Invalid ticket ID format'))).toBe(true);
+      expect(exitMock.exitCalls).toContain(1);
+    });
+
+    it('should reject a ticket that does not exist', async () => {
+      await runReview(['TKT-999']);
+
+      expect(consoleMock.logs.error.some(m => m.includes('Ticket not found: TKT-999'))).toBe(true);
+      expect(exitMock.exitCalls).toContain(1);
+    });
+
+    it('should pass validation for an existing TKT-001', async () => {
+      await runReview(['TKT-001']);
+
+      const errors = consoleMock.logs.error.join(' ');
+      expect(errors).not.toContain('Invalid ticket ID format');
+      expect(errors).not.toContain('Ticket not found');
+    });
+
+    it('should accept a numeric shorthand and normalise it', async () => {
+      await runReview(['1']);
+
+      const errors = consoleMock.logs.error.join(' ');
+      expect(errors).not.toContain('Invalid ticket ID format');
+      expect(errors).not.toContain('Ticket not found');
+    });
+  });
+
+  describe('ticket ID normalisation logic', () => {
+    const normalize = (input) => {
+      if (!input || typeof input !== 'string') return null;
+      const s = input.trim().toUpperCase();
+      if (!s || s.length > 20) return null;
+      if (/^\d+$/.test(s)) {
+        const n = parseInt(s, 10);
+        if (n < 1 || n > 999) return null;
+        return `TKT-${s.padStart(3, '0')}`;
+      }
+      if (/^TKT-\d{3}$/.test(s)) {
+        const n = parseInt(s.substring(4), 10);
+        return n >= 1 && n <= 999 ? s : null;
+      }
+      return null;
+    };
+
+    it('normalises single digit to TKT-001', () => expect(normalize('1')).toBe('TKT-001'));
+    it('normalises two digits to TKT-011', () => expect(normalize('11')).toBe('TKT-011'));
+    it('normalises three digits to TKT-111', () => expect(normalize('111')).toBe('TKT-111'));
+    it('accepts already-valid TKT-XXX', () => expect(normalize('TKT-001')).toBe('TKT-001'));
+    it('rejects invalid strings', () => expect(normalize('invalid')).toBeNull());
+    it('rejects null input', () => expect(normalize(null)).toBeNull());
+    it('rejects out-of-range zero', () => expect(normalize('0')).toBeNull());
+  });
+});

package/src/commands/start/index.js

@@ -0,0 +1,180 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { getTicketsDir, getConfig, createSlug } from '../../utils/index.js';
+import { 
+  isGitRepository, 
+  getCurrentBranch, 
+  branchExistsLocally, 
+  branchExistsRemotely,
+  createAndCheckoutBranch,
+  checkoutBranch,
+  getGitStatus
+} from '../../utils/git.js';
+
+/**
+ * Start working on a ticket by checking out its branch
+ * @param {string[]} args Command arguments
+ */
+function startCommand(args) {
+  // Check if we're in a git repository
+  if (!isGitRepository()) {
+    console.error('❌ Not in a git repository. Please run this command from within a git repository.');
+    process.exit(1);
+  }
+  
+  // Parse arguments
+  if (args.length === 0) {
+    console.error('❌ Please provide a ticket ID (e.g., vibe start TKT-006)');
+    process.exit(1);
+  }
+  
+  // Extract ticket ID and options
+  let ticketId = args[0];
+  let baseBranch = null;
+  let updateStatus = true;
+  
+  // Process additional arguments
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--base' && i + 1 < args.length) {
+      baseBranch = args[i + 1];
+      i++; // Skip the next argument as it's the base branch
+    } else if (args[i] === '--update-status' || args[i] === '-u') {
+      updateStatus = true;
+    }
+  }
+  
+  // Normalize ticket ID format (add TKT- prefix if not present)
+  if (!ticketId.startsWith('TKT-')) {
+    // Check if it's just a number
+    if (/^\d+$/.test(ticketId)) {
+      ticketId = `TKT-${ticketId.padStart(3, '0')}`;
+    } else {
+      console.error('❌ Invalid ticket ID format. Expected TKT-XXX or just the number.');
+      process.exit(1);
+    }
+  }
+  
+  // Get configuration
+  const config = getConfig();
+  const ticketsDir = getTicketsDir();
+  
+  // Check if the ticket exists
+  const ticketFiles = fs.readdirSync(ticketsDir).filter(file => file.startsWith(`${ticketId}-`));
+  
+  if (ticketFiles.length === 0) {
+    console.error(`❌ Ticket ${ticketId} not found.`);
+    process.exit(1);
+  }
+  
+  const ticketFile = ticketFiles[0];
+  const ticketPath = path.join(ticketsDir, ticketFile);
+  
+  // Read the ticket content to get the title and slug
+  const ticketContent = fs.readFileSync(ticketPath, 'utf-8');
+  const titleMatch = ticketContent.match(/title: (.+)/);
+  const title = titleMatch ? titleMatch[1].trim() : '';
+  
+  // Look for the slug in the frontmatter
+  const slugMatch = ticketContent.match(/slug: (.+)/);
+  let slug;
+  
+  if (slugMatch && slugMatch[1].trim()) {
+    // Use the slug from the ticket file
+    slug = slugMatch[1].trim();
+  } else {
+    // Generate a slug from the title as fallback
+    slug = `${ticketId}-${createSlug(title)}`;
+    console.log(`⚠️  No slug found in ticket. Generated slug: ${slug}`);
+    
+    // Update the ticket with the generated slug
+    try {
+      let updatedContent = ticketContent;
+      if (updatedContent.includes('slug:')) {
+        updatedContent = updatedContent.replace(/slug:.*/, `slug: ${slug}`);
+      } else {
+        updatedContent = updatedContent.replace(/---/, `---\nslug: ${slug}`);
+      }
+      
+      fs.writeFileSync(ticketPath, updatedContent, 'utf-8');
+      console.log(`✅ Updated ticket with slug: ${slug}`);
+    } catch (error) {
+      console.error(`❌ Failed to update ticket with slug: ${error.message}`);
+    }
+  }
+  
+  // Get branch prefix from config or use default (empty)
+  const branchPrefix = config.git?.branch_prefix || '';
+  
+  // Create branch name - if slug already contains the ticket ID, don't add it again
+  const branchName = slug.includes(ticketId) 
+    ? `${branchPrefix}${slug}` 
+    : `${branchPrefix}${ticketId}-${slug}`;
+  
+  // Check if there are uncommitted changes
+  const gitStatus = getGitStatus();
+  if (gitStatus) {
+    console.warn('⚠️  You have uncommitted changes. Stash or commit them before switching branches.');
+    console.log('');
+  }
+  
+  // Check if the branch already exists
+  const branchExistsLocal = branchExistsLocally(branchName);
+  const branchExistsRemote = branchExistsRemotely(branchName);
+  
+  if (branchExistsLocal || branchExistsRemote) {
+    console.log(`🔍 Branch ${branchName} already exists.`);
+    
+    // Checkout the existing branch
+    if (checkoutBranch(branchName)) {
+      console.log(`✅ Switched to branch: ${branchName}`);
+    } else {
+      console.error(`❌ Failed to switch to branch: ${branchName}`);
+      process.exit(1);
+    }
+  } else {
+    console.log(`🔍 Creating new branch: ${branchName}`);
+    
+    // Create and checkout the new branch
+    if (createAndCheckoutBranch(branchName, baseBranch)) {
+      console.log(`✅ Created and switched to branch: ${branchName}`);
+    } else {
+      console.error(`❌ Failed to create branch: ${branchName}`);
+      process.exit(1);
+    }
+  }
+  
+  // Update ticket status if requested
+  if (updateStatus) {
+    try {
+      // Read the ticket file
+      const ticketContent = fs.readFileSync(ticketPath, 'utf-8');
+      
+      // Get current timestamp in ISO format
+      const now = new Date().toISOString();
+      
+      // Update the status to in_progress and update the timestamp
+      let updatedContent = ticketContent
+        .replace(/^status: (.+)$/m, 'status: in_progress')
+        .replace(/^updated_at: (.+)$/m, `updated_at: ${now}`);
+      
+      // Write the updated content back to the file
+      fs.writeFileSync(ticketPath, updatedContent, 'utf-8');
+      
+      console.log(`✅ Updated ticket status to: in_progress`);
+      console.log(`✅ Updated timestamp to: ${now}`);
+    } catch (error) {
+      console.error(`❌ Failed to update ticket status: ${error.message}`);
+    }
+  }
+  
+  // Summary
+  console.log('');
+  console.log(`🎯 Now working on: ${ticketId} - ${title}`);
+  console.log(`🌿 Branch: ${branchName}`);
+  console.log('');
+  console.log('To push this branch to remote:');
+  console.log(`  git push -u origin ${branchName}`);
+}
+
+export default startCommand;

package/src/commands/start/index.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+import { 
+  createTempDir, 
+  cleanupTempDir, 
+  mockConsole, 
+  mockProcessCwd, 
+  mockProcessExit,
+  createMockVibeProject
+} from '../../utils/test-helpers.js';
+import startCommand from './index.js';
+
+describe('start command', () => {
+  let tempDir;
+  let consoleMock;
+  let restoreCwd;
+  let exitMock;
+
+  beforeEach(() => {
+    tempDir = createTempDir('start-test');
+    consoleMock = mockConsole();
+    restoreCwd = mockProcessCwd(tempDir);
+    exitMock = mockProcessExit();
+  });
+
+  afterEach(() => {
+    consoleMock.restore();
+    restoreCwd();
+    exitMock.restore();
+    cleanupTempDir(tempDir);
+  });
+
+  describe('basic validation', () => {
+    it('should validate that start command exists and is callable', () => {
+      expect(typeof startCommand).toBe('function');
+    });
+
+    it('should accept arguments parameter', () => {
+      expect(startCommand.length).toBe(1); // Takes one parameter (args array)
+    });
+
+    it('should show error when no ticket ID provided', () => {
+      // Arrange
+      createMockVibeProject(tempDir);
+
+      // Act
+      expect(() => startCommand([])).toThrow('process.exit(1)');
+
+      // Assert
+      expect(exitMock.exitCalls).toContain(1);
+      expect(consoleMock.logs.error).toContain('❌ Please provide a ticket ID (e.g., vibe start TKT-006)');
+    });
+
+    it('should show error for invalid ticket ID format', () => {
+      // Arrange
+      createMockVibeProject(tempDir);
+
+      // Act
+      expect(() => startCommand(['invalid-format'])).toThrow('process.exit(1)');
+
+      // Assert
+      expect(exitMock.exitCalls).toContain(1);
+      expect(consoleMock.logs.error).toContain('❌ Invalid ticket ID format. Expected TKT-XXX or just the number.');
+    });
+  });
+
+  describe('ticket validation', () => {
+    it('should show error when ticket does not exist', () => {
+      // Arrange
+      createMockVibeProject(tempDir); // No tickets
+
+      // Act
+      expect(() => startCommand(['TKT-001'])).toThrow('process.exit(1)');
+
+      // Assert
+      expect(exitMock.exitCalls).toContain(1);
+      expect(consoleMock.logs.error).toContain('❌ Ticket TKT-001 not found.');
+    });
+  });
+
+  // Note: Full git integration testing would require:
+  // - Proper git repository setup
+  // - Mocking all git utility functions
+  // - Testing branch creation and checkout
+  // - Testing ticket status updates
+  // This is better handled in integration tests with proper git mocking
+});

package/src/commands/unlink/index.js

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import path from 'path';
+import { createInterface } from 'readline';
+import yaml from 'js-yaml';
+
+/**
+ * Create readline interface for user input
+ */
+function createReadlineInterface() {
+  return createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompt user for input with question
+ */
+function askQuestion(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Load existing config.yml
+ */
+function loadConfig() {
+  const configPath = path.join(process.cwd(), '.vibe', 'config.yml');
+  
+  if (!fs.existsSync(configPath)) {
+    console.error('❌ No .vibe/config.yml found. Run "vibe init" first.');
+    process.exit(1);
+  }
+  
+  try {
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    return yaml.load(configContent);
+  } catch (error) {
+    console.error('❌ Error reading config.yml:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Save updated config.yml
+ */
+function saveConfig(config) {
+  const configPath = path.join(process.cwd(), '.vibe', 'config.yml');
+  
+  try {
+    const yamlContent = yaml.dump(config, { 
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true
+    });
+    fs.writeFileSync(configPath, yamlContent, 'utf8');
+    return true;
+  } catch (error) {
+    console.error('❌ Error saving config.yml:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Main unlink command implementation
+ */
+async function unlinkCommand() {
+  console.log('🔓 VibeKit AI Provider Removal\n');
+  
+  const config = loadConfig();
+  const rl = createReadlineInterface();
+  
+  try {
+    // Check if AI is currently configured
+    if (!config.ai || !config.ai.enabled) {
+      console.log('ℹ️  No AI provider is currently configured.');
+      rl.close();
+      return;
+    }
+    
+    // Show current configuration
+    console.log('📝 Current AI configuration:');
+    console.log(`   Provider: ${config.ai.provider === 'claude-code' ? 'Claude Code (Anthropic API)' : config.ai.provider}`);
+    console.log(`   Model: ${config.ai.model || 'Not specified'}`);
+    console.log(`   Status: ${config.ai.enabled ? 'Enabled' : 'Disabled'}`);
+    console.log();
+    
+    // Confirm removal
+    const confirmRemoval = await askQuestion(rl, '? Are you sure you want to disable AI features? (y/n): ');
+    
+    if (confirmRemoval.toLowerCase() !== 'y' && confirmRemoval.toLowerCase() !== 'yes') {
+      console.log('🚫 Cancelled. AI configuration unchanged.');
+      rl.close();
+      return;
+    }
+    
+    // Simply disable AI in config (no credential storage to remove)
+    config.ai = {
+      ...config.ai,
+      enabled: false,
+      provider: 'none'
+    };
+    
+    if (saveConfig(config)) {
+      console.log('✅ AI features disabled successfully!');
+      console.log('🔓 AI provider has been unlinked.');
+      console.log('\n💡 Your API keys in environment variables or .env files remain unchanged.');
+      console.log('💡 Run "vibe link" anytime to re-enable AI features.');
+    } else {
+      console.log('❌ Failed to save configuration changes.');
+    }
+    
+  } catch (error) {
+    console.error('❌ Error during removal:', error.message);
+  } finally {
+    rl.close();
+  }
+}
+
+export default unlinkCommand;

package/src/commands/unlink/index.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from '@jest/globals';
+import unlinkCommand from './index.js';
+
+describe('unlink command', () => {
+  describe('basic validation', () => {
+    it('should validate that unlink command exists and is callable', () => {
+      // This test validates the command structure without executing interactive parts
+      expect(typeof unlinkCommand).toBe('function');
+    });
+
+    it('should be an async function', () => {
+      // Validates the command is properly structured as async
+      expect(unlinkCommand.constructor.name).toBe('AsyncFunction');
+    });
+  });
+
+  // Note: The unlink command is interactive and async, requiring:
+  // - Mocking readline.createInterface()
+  // - Mocking user input responses  
+  // - Testing actual config file modifications
+  // Full testing would require complex async/interactive mocking
+});