@vibedx/vibekit 0.1.0

package/src/utils/cli.test.js

@@ -0,0 +1,9 @@
+import { describe, it, expect } from '@jest/globals';
+
+describe('cli utilities', () => {
+  it('should be a placeholder test file', () => {
+    // This is a placeholder test to prevent Jest from failing
+    // due to empty test suite
+    expect(true).toBe(true);
+  });
+});

package/src/utils/git.js

@@ -0,0 +1,146 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Check if the current directory is within a git repository
+ * @returns {boolean} True if in a git repository, false otherwise
+ */
+function isGitRepository() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore' });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get the current branch name
+ * @returns {string|null} The current branch name or null if not in a git repository
+ */
+function getCurrentBranch() {
+  try {
+    return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if a branch exists locally
+ * @param {string} branchName The branch name to check
+ * @returns {boolean} True if the branch exists locally, false otherwise
+ */
+function branchExistsLocally(branchName) {
+  try {
+    const result = execSync(`git show-ref --verify --quiet refs/heads/${branchName}`);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if a branch exists remotely
+ * @param {string} branchName The branch name to check
+ * @returns {boolean} True if the branch exists remotely, false otherwise
+ */
+function branchExistsRemotely(branchName) {
+  try {
+    const result = execSync(`git ls-remote --heads origin ${branchName}`, { encoding: 'utf-8' });
+    return result.trim() !== '';
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get the default base branch (usually main or master)
+ * @returns {string} The default base branch name
+ */
+function getDefaultBaseBranch() {
+  try {
+    // Try to determine if main or master is the default branch
+    const branches = execSync('git branch -r', { encoding: 'utf-8' }).trim().split('\n');
+    
+    // Check if origin/main exists
+    if (branches.some(branch => branch.trim() === 'origin/main')) {
+      return 'main';
+    }
+    
+    // Check if origin/master exists
+    if (branches.some(branch => branch.trim() === 'origin/master')) {
+      return 'master';
+    }
+    
+    // Default to main if we can't determine
+    return 'main';
+  } catch (error) {
+    return 'main'; // Default to main if there's an error
+  }
+}
+
+/**
+ * Create and checkout a new branch
+ * @param {string} branchName The name of the branch to create
+ * @param {string} baseBranch The base branch to create from (default: main)
+ * @returns {boolean} True if successful, false otherwise
+ */
+function createAndCheckoutBranch(branchName, baseBranch = null) {
+  try {
+    const base = baseBranch || getDefaultBaseBranch();
+    
+    // Make sure we have the latest from the base branch
+    try {
+      execSync(`git fetch origin ${base}`, { stdio: 'ignore' });
+    } catch (error) {
+      // Ignore fetch errors, we'll try to create the branch anyway
+    }
+    
+    // Create and checkout the new branch
+    execSync(`git checkout -b ${branchName} origin/${base} || git checkout -b ${branchName} ${base}`, { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to create branch: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Checkout an existing branch
+ * @param {string} branchName The name of the branch to checkout
+ * @returns {boolean} True if successful, false otherwise
+ */
+function checkoutBranch(branchName) {
+  try {
+    execSync(`git checkout ${branchName}`, { stdio: 'pipe' });
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to checkout branch: ${error.message}`);
+    return false;
+  }
+}
+
+/**
+ * Get the status of the working directory
+ * @returns {string} The git status output
+ */
+function getGitStatus() {
+  try {
+    return execSync('git status --porcelain', { encoding: 'utf-8' }).trim();
+  } catch (error) {
+    return '';
+  }
+}
+
+export {
+  isGitRepository,
+  getCurrentBranch,
+  branchExistsLocally,
+  branchExistsRemotely,
+  getDefaultBaseBranch,
+  createAndCheckoutBranch,
+  checkoutBranch,
+  getGitStatus
+};

package/src/utils/git.test.js

@@ -0,0 +1,330 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { 
+  createTempDir, 
+  cleanupTempDir, 
+  mockConsole,
+  createMockGitRepo
+} from './test-helpers.js';
+
+// Mock child_process
+const mockExecSync = jest.fn();
+jest.unstable_mockModule('child_process', () => ({
+  execSync: mockExecSync
+}));
+
+describe('git utilities', () => {
+  let tempDir;
+  let consoleMock;
+  let gitModule;
+
+  beforeEach(async () => {
+    tempDir = createTempDir('git-test');
+    consoleMock = mockConsole();
+    mockExecSync.mockReset();
+    
+    // Import after mocking
+    gitModule = await import('./git.js');
+  });
+
+  afterEach(() => {
+    consoleMock.restore();
+    cleanupTempDir(tempDir);
+    jest.clearAllMocks();
+  });
+
+  describe('isGitRepository', () => {
+    it('should return true when in git repository', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('true');
+
+      // Act
+      const result = gitModule.isGitRepository();
+
+      // Assert
+      expect(result).toBe(true);
+      expect(mockExecSync).toHaveBeenCalledWith('git rev-parse --is-inside-work-tree', { stdio: 'ignore' });
+    });
+
+    it('should return false when not in git repository', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+
+      // Act
+      const result = gitModule.isGitRepository();
+
+      // Assert
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getCurrentBranch', () => {
+    it('should return current branch name', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('feature/test-branch\n');
+
+      // Act
+      const result = gitModule.getCurrentBranch();
+
+      // Assert
+      expect(result).toBe('feature/test-branch');
+      expect(mockExecSync).toHaveBeenCalledWith('git branch --show-current', { encoding: 'utf-8' });
+    });
+
+    it('should return null when git command fails', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+
+      // Act
+      const result = gitModule.getCurrentBranch();
+
+      // Assert
+      expect(result).toBe(null);
+    });
+
+    it('should handle empty branch name', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('');
+
+      // Act
+      const result = gitModule.getCurrentBranch();
+
+      // Assert
+      expect(result).toBe('');
+    });
+  });
+
+  describe('branchExistsLocally', () => {
+    it('should return true when branch exists locally', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('');
+
+      // Act
+      const result = gitModule.branchExistsLocally('feature/test');
+
+      // Assert
+      expect(result).toBe(true);
+      expect(mockExecSync).toHaveBeenCalledWith('git show-ref --verify --quiet refs/heads/feature/test');
+    });
+
+    it('should return false when branch does not exist locally', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Branch not found');
+      });
+
+      // Act
+      const result = gitModule.branchExistsLocally('nonexistent');
+
+      // Assert
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('branchExistsRemotely', () => {
+    it('should return true when branch exists remotely', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('abc123\trefs/heads/feature/test\n');
+
+      // Act
+      const result = gitModule.branchExistsRemotely('feature/test');
+
+      // Assert
+      expect(result).toBe(true);
+      expect(mockExecSync).toHaveBeenCalledWith('git ls-remote --heads origin feature/test', { encoding: 'utf-8' });
+    });
+
+    it('should return false when branch does not exist remotely', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('');
+
+      // Act
+      const result = gitModule.branchExistsRemotely('nonexistent');
+
+      // Assert
+      expect(result).toBe(false);
+    });
+
+    it('should return false when git command fails', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Network error');
+      });
+
+      // Act
+      const result = gitModule.branchExistsRemotely('test');
+
+      // Assert
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getDefaultBaseBranch', () => {
+    it('should return main when origin/main exists', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('  origin/main\n  origin/develop\n');
+
+      // Act
+      const result = gitModule.getDefaultBaseBranch();
+
+      // Assert
+      expect(result).toBe('main');
+    });
+
+    it('should return master when origin/master exists but not main', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('  origin/master\n  origin/develop\n');
+
+      // Act
+      const result = gitModule.getDefaultBaseBranch();
+
+      // Assert
+      expect(result).toBe('master');
+    });
+
+    it('should default to main when neither exists', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('  origin/develop\n  origin/feature\n');
+
+      // Act
+      const result = gitModule.getDefaultBaseBranch();
+
+      // Assert
+      expect(result).toBe('main');
+    });
+
+    it('should handle git command failure', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Git error');
+      });
+
+      // Act
+      const result = gitModule.getDefaultBaseBranch();
+
+      // Assert
+      expect(result).toBe('main');
+    });
+  });
+
+  describe('createAndCheckoutBranch', () => {
+    it('should create and checkout new branch successfully', () => {
+      // Arrange
+      mockExecSync.mockImplementation((command) => {
+        if (command.includes('fetch')) return '';
+        if (command.includes('checkout -b')) return '';
+        return '';
+      });
+
+      // Act
+      const result = gitModule.createAndCheckoutBranch('feature/new-branch');
+
+      // Assert
+      expect(result).toBe(true);
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('checkout -b feature/new-branch'),
+        { stdio: 'pipe' }
+      );
+    });
+
+    it('should use custom base branch when provided', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => '');
+
+      // Act
+      const result = gitModule.createAndCheckoutBranch('feature/test', 'develop');
+
+      // Assert
+      expect(result).toBe(true);
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('develop'),
+        expect.any(Object)
+      );
+    });
+
+    it('should return false when branch creation fails', () => {
+      // Arrange
+      mockExecSync.mockImplementation((command) => {
+        if (command.includes('checkout -b')) {
+          throw new Error('Branch creation failed');
+        }
+        return '';
+      });
+
+      // Act
+      const result = gitModule.createAndCheckoutBranch('invalid/branch');
+
+      // Assert
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('checkoutBranch', () => {
+    it('should checkout existing branch successfully', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('');
+
+      // Act
+      const result = gitModule.checkoutBranch('existing-branch');
+
+      // Assert
+      expect(result).toBe(true);
+      expect(mockExecSync).toHaveBeenCalledWith('git checkout existing-branch', { stdio: 'pipe' });
+    });
+
+    it('should return false when checkout fails', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Branch not found');
+      });
+
+      // Act
+      const result = gitModule.checkoutBranch('nonexistent');
+
+      // Assert
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getGitStatus', () => {
+    it('should return git status output', () => {
+      // Arrange
+      const statusOutput = 'M file1.js\nA file2.js\n';
+      mockExecSync.mockReturnValue(statusOutput);
+
+      // Act
+      const result = gitModule.getGitStatus();
+
+      // Assert
+      expect(result).toBe('M file1.js\nA file2.js');
+      expect(mockExecSync).toHaveBeenCalledWith('git status --porcelain', { encoding: 'utf-8' });
+    });
+
+    it('should return empty string when no changes', () => {
+      // Arrange
+      mockExecSync.mockReturnValue('');
+
+      // Act
+      const result = gitModule.getGitStatus();
+
+      // Assert
+      expect(result).toBe('');
+    });
+
+    it('should return empty string when git command fails', () => {
+      // Arrange
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Not a git repository');
+      });
+
+      // Act
+      const result = gitModule.getGitStatus();
+
+      // Assert
+      expect(result).toBe('');
+    });
+  });
+});

package/src/utils/index.js

@@ -0,0 +1,193 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Get the path to the tickets directory from config or use default
+ * Reads the configuration file to determine the tickets directory path.
+ * Falls back to default path if config is missing or invalid.
+ * @returns {string} Absolute path to the tickets directory
+ * @throws {Error} Logs error but doesn't throw - returns default path
+ */
+function getTicketsDir() {
+  const configPath = path.join(process.cwd(), '.vibe', 'config.yml');
+  let ticketDir = path.join(process.cwd(), '.vibe', 'tickets');
+  
+  try {
+    if (fs.existsSync(configPath)) {
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      const config = yaml.load(configContent) || {};
+      
+      if (config.tickets?.path && typeof config.tickets.path === 'string') {
+        const customPath = path.resolve(process.cwd(), config.tickets.path);
+        ticketDir = customPath;
+      }
+    }
+  } catch (error) {
+    console.error(`❌ Error reading config: ${error.message}`);
+  }
+  
+  return ticketDir;
+}
+
+/**
+ * Get the configuration from .vibe/config.yml
+ * Loads and parses the YAML configuration file for VibeKit.
+ * Returns empty object if file doesn't exist or cannot be parsed.
+ * @returns {Object} The configuration object (empty if file missing/invalid)
+ * @example
+ * const config = getConfig();
+ * console.log(config.tickets?.path); // Access tickets path
+ */
+function getConfig() {
+  const configPath = path.join(process.cwd(), '.vibe', 'config.yml');
+  let config = {};
+  
+  try {
+    if (fs.existsSync(configPath)) {
+      const configContent = fs.readFileSync(configPath, 'utf-8');
+      const parsedConfig = yaml.load(configContent);
+      
+      // Ensure we have a valid object
+      if (parsedConfig && typeof parsedConfig === 'object') {
+        config = parsedConfig;
+      }
+    }
+  } catch (error) {
+    console.error(`❌ Error reading config: ${error.message}`);
+  }
+  
+  return config;
+}
+
+/**
+ * Generate the next ticket ID based on existing tickets
+ * Scans the tickets directory for existing ticket files and generates
+ * the next sequential ID in the format TKT-XXX (zero-padded to 3 digits).
+ * @returns {string} The next ticket ID (e.g., "TKT-004")
+ * @example
+ * const nextId = getNextTicketId();
+ * console.log(nextId); // "TKT-005"
+ */
+function getNextTicketId() {
+  const ticketDir = getTicketsDir();
+  
+  // If tickets directory doesn't exist, start with 001
+  if (!fs.existsSync(ticketDir)) {
+    return 'TKT-001';
+  }
+  
+  try {
+    const files = fs.readdirSync(ticketDir);
+    const ticketNumbers = files
+      .filter(f => f.endsWith('.md')) // Only consider markdown files
+      .map(f => f.match(/^TKT-(\d+)/))
+      .filter(Boolean)
+      .map(match => parseInt(match[1], 10))
+      .filter(num => !isNaN(num) && num > 0); // Filter out invalid numbers
+    
+    // Find the highest existing number and add 1
+    const nextId = Math.max(0, ...ticketNumbers) + 1;
+    const paddedId = String(nextId).padStart(3, '0');
+    
+    return `TKT-${paddedId}`;
+  } catch (error) {
+    console.error(`❌ Error scanning tickets directory: ${error.message}`);
+    return 'TKT-001'; // Fallback to first ticket
+  }
+}
+
+/**
+ * Create a slug from a title based on configuration
+ * Converts a human-readable title into a URL-friendly slug following
+ * configuration rules for maximum length and word limits.
+ * @param {string} title - The title to slugify
+ * @param {Object|null} config - Optional configuration object (defaults to getConfig())
+ * @returns {string} The slugified title (kebab-case, lowercase)
+ * @example
+ * createSlug('Fix User Authentication Bug'); // 'fix-user-authentication-bug'
+ * createSlug('Very Long Title That Exceeds Limits', { tickets: { slug: { max_length: 10 } } }); // 'very-long'
+ */
+function createSlug(title, config = null) {
+  if (!title || typeof title !== 'string') {
+    return '';
+  }
+  
+  // Get configuration with fallback defaults
+  const cfg = config || getConfig();
+  const maxLength = cfg.tickets?.slug?.max_length || 30;
+  const wordLimit = cfg.tickets?.slug?.word_limit || 5;
+  
+  // Validate configuration values
+  const safeMaxLength = Math.max(1, Math.min(100, maxLength)); // Clamp between 1-100
+  const safeWordLimit = Math.max(1, Math.min(20, wordLimit)); // Clamp between 1-20
+  
+  // Split into words and limit the number of words
+  const words = title.trim().split(/\s+/).filter(Boolean);
+  const limitedWords = words.slice(0, safeWordLimit).join(' ');
+  
+  // Create the basic slug
+  let slug = limitedWords.toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric chars with hyphens
+    .replace(/^-+|-+$/g, '');    // Remove leading/trailing hyphens
+  
+  // Limit the length and ensure we don't cut in the middle of a word
+  if (slug.length > safeMaxLength) {
+    slug = slug.substring(0, safeMaxLength);
+    // Remove trailing partial words (anything after the last hyphen)
+    const lastHyphen = slug.lastIndexOf('-');
+    if (lastHyphen > 0) {
+      slug = slug.substring(0, lastHyphen);
+    }
+  }
+  
+  return slug || 'untitled'; // Fallback if slug is empty
+}
+
+/**
+ * Create a full slug with ticket ID prefix
+ * Combines a ticket ID with a descriptive slug to create a complete
+ * filename-ready identifier.
+ * @param {string} ticketId - The ticket ID (e.g., "TKT-009")
+ * @param {string} slugText - The descriptive slug text part
+ * @returns {string} Full slug with ticket ID prefix (e.g., "TKT-009-fix-auth-bug")
+ * @example
+ * createFullSlug('TKT-001', 'user-login-fix'); // 'TKT-001-user-login-fix'
+ */
+function createFullSlug(ticketId, slugText) {
+  // Validate inputs
+  if (!ticketId || typeof ticketId !== 'string') {
+    return '';
+  }
+  
+  if (!slugText || typeof slugText !== 'string') {
+    return ticketId; // Return just the ticket ID if no slug text
+  }
+  
+  // Clean inputs
+  const cleanTicketId = ticketId.trim();
+  const cleanSlugText = slugText.trim();
+  
+  if (!cleanTicketId || !cleanSlugText) {
+    return cleanTicketId || '';
+  }
+  
+  return `${cleanTicketId}-${cleanSlugText}`;
+}
+
+/**
+ * Get the path to the config.yml file
+ * @returns {string} Absolute path to the config.yml file
+ */
+function getConfigPath() {
+  return path.join(process.cwd(), '.vibe', 'config.yml');
+}
+
+export {
+  getTicketsDir,
+  getConfig,
+  getConfigPath,
+  getNextTicketId,
+  createSlug,
+  createFullSlug
+};