bit-cli-ai 1.0.0

package/src/utils/git.js

@@ -0,0 +1,241 @@
+/**
+ * Git utilities and helpers
+ * Wrapper around git commands with error handling and logging
+ */
+
+import { execSync, exec } from 'child_process';
+import { promisify } from 'util';
+import { log } from './logger.js';
+import { NotARepositoryError, GitError, MergeConflictError } from './errors.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Execute a git command synchronously
+ */
+export function gitSync(command, options = {}) {
+  const { silent = false, throwOnError = true } = options;
+  
+  try {
+    log.git('sync', { command });
+    const result = execSync(`git ${command}`, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : undefined,
+    });
+    return result?.trim() || '';
+  } catch (error) {
+    log.exception(error, { command: `git ${command}` });
+    
+    if (error.message?.includes('not a git repository')) {
+      throw new NotARepositoryError();
+    }
+    
+    if (throwOnError) {
+      throw new GitError(`Git command failed: ${command}`, {
+        stderr: error.stderr?.toString(),
+      });
+    }
+    
+    return null;
+  }
+}
+
+/**
+ * Execute a git command asynchronously
+ */
+export async function gitAsync(command, options = {}) {
+  const { silent = false, throwOnError = true } = options;
+  
+  try {
+    log.git('async', { command });
+    const { stdout, stderr } = await execAsync(`git ${command}`);
+    return stdout?.trim() || '';
+  } catch (error) {
+    log.exception(error, { command: `git ${command}` });
+    
+    if (error.message?.includes('not a git repository')) {
+      throw new NotARepositoryError();
+    }
+    
+    if (throwOnError) {
+      throw new GitError(`Git command failed: ${command}`, {
+        stderr: error.stderr?.toString(),
+      });
+    }
+    
+    return null;
+  }
+}
+
+/**
+ * Check if current directory is a git repository
+ */
+export function isGitRepository() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get current branch name
+ */
+export function getCurrentBranch() {
+  return gitSync('rev-parse --abbrev-ref HEAD', { silent: true });
+}
+
+/**
+ * Get list of all branches
+ */
+export function getBranches(options = {}) {
+  const { all = false, remote = false } = options;
+  
+  let command = 'branch';
+  if (all) command += ' -a';
+  else if (remote) command += ' -r';
+  
+  const output = gitSync(command, { silent: true });
+  return output
+    .split('\n')
+    .map((b) => b.trim().replace(/^\* /, ''))
+    .filter(Boolean);
+}
+
+/**
+ * Get staged files
+ */
+export function getStagedFiles() {
+  const output = gitSync('diff --cached --name-only', { silent: true });
+  return output ? output.split('\n').filter(Boolean) : [];
+}
+
+/**
+ * Get modified files (not staged)
+ */
+export function getModifiedFiles() {
+  const output = gitSync('diff --name-only', { silent: true });
+  return output ? output.split('\n').filter(Boolean) : [];
+}
+
+/**
+ * Get untracked files
+ */
+export function getUntrackedFiles() {
+  const output = gitSync('ls-files --others --exclude-standard', { silent: true });
+  return output ? output.split('\n').filter(Boolean) : [];
+}
+
+/**
+ * Get diff of staged changes
+ */
+export function getStagedDiff() {
+  return gitSync('diff --cached', { silent: true });
+}
+
+/**
+ * Get commit history
+ */
+export function getCommitHistory(options = {}) {
+  const { limit = 10, format = '%H|%s|%an|%ar' } = options;
+  
+  const output = gitSync(`log -${limit} --format="${format}"`, { silent: true });
+  
+  return output.split('\n').filter(Boolean).map((line) => {
+    const [hash, message, author, date] = line.split('|');
+    return { hash, message, author, date };
+  });
+}
+
+/**
+ * Get repository root directory
+ */
+export function getRepoRoot() {
+  return gitSync('rev-parse --show-toplevel', { silent: true });
+}
+
+/**
+ * Check for merge conflicts
+ */
+export function hasConflicts() {
+  try {
+    const output = gitSync('diff --name-only --diff-filter=U', { silent: true });
+    return output.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get conflicting files
+ */
+export function getConflictingFiles() {
+  const output = gitSync('diff --name-only --diff-filter=U', { silent: true });
+  return output ? output.split('\n').filter(Boolean) : [];
+}
+
+/**
+ * Preview merge using merge-tree
+ */
+export function previewMerge(branch) {
+  try {
+    const currentBranch = getCurrentBranch();
+    const baseCommit = gitSync(`merge-base ${currentBranch} ${branch}`, { silent: true });
+    const output = gitSync(`merge-tree ${baseCommit} ${currentBranch} ${branch}`, { silent: true });
+    
+    // Check for conflict markers
+    const hasConflicts = output.includes('<<<<<<<') || output.includes('>>>>>>>');
+    
+    return {
+      hasConflicts,
+      output,
+      baseCommit,
+    };
+  } catch (error) {
+    throw new GitError(`Failed to preview merge with ${branch}`, {
+      originalError: error.message,
+    });
+  }
+}
+
+/**
+ * Get file content at specific commit
+ */
+export function getFileAtCommit(file, commit = 'HEAD') {
+  try {
+    return gitSync(`show ${commit}:${file}`, { silent: true });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get remote URL
+ */
+export function getRemoteUrl(remote = 'origin') {
+  try {
+    return gitSync(`remote get-url ${remote}`, { silent: true });
+  } catch {
+    return null;
+  }
+}
+
+export default {
+  gitSync,
+  gitAsync,
+  isGitRepository,
+  getCurrentBranch,
+  getBranches,
+  getStagedFiles,
+  getModifiedFiles,
+  getUntrackedFiles,
+  getStagedDiff,
+  getCommitHistory,
+  getRepoRoot,
+  hasConflicts,
+  getConflictingFiles,
+  previewMerge,
+  getFileAtCommit,
+  getRemoteUrl,
+};

package/src/utils/logger.js

@@ -0,0 +1,94 @@
+/**
+ * Centralized logging utility for Bit CLI
+ * Supports multiple log levels, file output, and structured logging
+ */
+
+import winston from 'winston';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+// Ensure log directory exists
+const LOG_DIR = path.join(os.homedir(), '.bit', 'logs');
+if (!fs.existsSync(LOG_DIR)) {
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+// Custom format for console output
+const consoleFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'HH:mm:ss' }),
+  winston.format.printf(({ level, message, timestamp, ...meta }) => {
+    const metaStr = Object.keys(meta).length ? JSON.stringify(meta) : '';
+    return `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaStr}`;
+  })
+);
+
+// Custom format for file output
+const fileFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.json()
+);
+
+// Create logger instance
+const logger = winston.createLogger({
+  level: process.env.BIT_LOG_LEVEL || 'info',
+  transports: [
+    // File transport for all logs
+    new winston.transports.File({
+      filename: path.join(LOG_DIR, 'bit-error.log'),
+      level: 'error',
+      format: fileFormat,
+      maxsize: 5242880, // 5MB
+      maxFiles: 5,
+    }),
+    new winston.transports.File({
+      filename: path.join(LOG_DIR, 'bit-combined.log'),
+      format: fileFormat,
+      maxsize: 5242880, // 5MB
+      maxFiles: 5,
+    }),
+  ],
+});
+
+// Add console transport in development
+if (process.env.BIT_DEBUG === 'true') {
+  logger.add(
+    new winston.transports.Console({
+      format: consoleFormat,
+    })
+  );
+}
+
+// Helper methods for common logging patterns
+export const log = {
+  info: (message, meta = {}) => logger.info(message, meta),
+  error: (message, meta = {}) => logger.error(message, meta),
+  warn: (message, meta = {}) => logger.warn(message, meta),
+  debug: (message, meta = {}) => logger.debug(message, meta),
+  
+  // Log command execution
+  command: (cmd, args = []) => {
+    logger.info('Command executed', { command: cmd, arguments: args });
+  },
+  
+  // Log git operations
+  git: (operation, details = {}) => {
+    logger.info('Git operation', { operation, ...details });
+  },
+  
+  // Log AI operations
+  ai: (operation, details = {}) => {
+    logger.info('AI operation', { operation, ...details });
+  },
+  
+  // Log errors with stack trace
+  exception: (error, context = {}) => {
+    logger.error('Exception occurred', {
+      message: error.message,
+      stack: error.stack,
+      ...context,
+    });
+  },
+};
+
+export default logger;

package/src/utils/validation.js

@@ -0,0 +1,108 @@
+/**
+ * Input validation using Zod schemas
+ * Ensures all user inputs and data are validated before processing
+ */
+
+import { z } from 'zod';
+
+// Branch name validation
+export const branchNameSchema = z
+  .string()
+  .min(1, 'Branch name cannot be empty')
+  .max(255, 'Branch name too long')
+  .regex(
+    /^(?!\/|.*(?:\/\.|\/\/|@\{|\\))[^\x00-\x1f\x7f ~^:?*\[]+(?<!\.lock|\/|\.|\/)$/,
+    'Invalid branch name. Cannot contain special characters or patterns forbidden by Git'
+  );
+
+// Commit message validation
+export const commitMessageSchema = z
+  .string()
+  .min(1, 'Commit message cannot be empty')
+  .max(500, 'Commit message too long (max 500 characters)')
+  .refine(
+    (msg) => !msg.startsWith(' '),
+    'Commit message cannot start with a space'
+  );
+
+// File path validation
+export const filePathSchema = z
+  .string()
+  .min(1, 'File path cannot be empty')
+  .refine(
+    (path) => !path.includes('\0'),
+    'File path cannot contain null bytes'
+  );
+
+// Configuration validation
+export const configSchema = z.object({
+  ai: z.object({
+    provider: z.enum(['openai', 'anthropic', 'local']).default('openai'),
+    model: z.string().default('gpt-4o-mini'),
+    maxTokens: z.number().min(100).max(4000).default(500),
+    temperature: z.number().min(0).max(2).default(0.7),
+  }).optional(),
+  git: z.object({
+    ghostPrefix: z.string().default('ghost/'),
+    autoStage: z.boolean().default(false),
+    signCommits: z.boolean().default(false),
+  }).optional(),
+  ui: z.object({
+    colors: z.boolean().default(true),
+    spinners: z.boolean().default(true),
+    verbose: z.boolean().default(false),
+  }).optional(),
+});
+
+// Remote URL validation
+export const remoteUrlSchema = z
+  .string()
+  .refine(
+    (url) => {
+      // Accept SSH or HTTPS Git URLs
+      const sshPattern = /^git@[\w.-]+:[\w./-]+\.git$/;
+      const httpsPattern = /^https?:\/\/[\w.-]+\/[\w./-]+\.git$/;
+      return sshPattern.test(url) || httpsPattern.test(url);
+    },
+    'Invalid Git remote URL'
+  );
+
+/**
+ * Validate input against a schema
+ * @param {z.ZodSchema} schema - Zod schema to validate against
+ * @param {any} data - Data to validate
+ * @returns {{ success: boolean, data?: any, error?: string }}
+ */
+export function validate(schema, data) {
+  try {
+    const result = schema.parse(data);
+    return { success: true, data: result };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const messages = error.errors.map((e) => e.message).join(', ');
+      return { success: false, error: messages };
+    }
+    return { success: false, error: 'Validation failed' };
+  }
+}
+
+/**
+ * Validate and throw on error
+ */
+export function validateOrThrow(schema, data) {
+  const result = validate(schema, data);
+  if (!result.success) {
+    throw new Error(result.error);
+  }
+  return result.data;
+}
+
+export default {
+  branchNameSchema,
+  commitMessageSchema,
+  filePathSchema,
+  configSchema,
+  remoteUrlSchema,
+  validate,
+  validateOrThrow,
+};