commic 1.0.0

package/src/errors/CustomErrors.ts

@@ -0,0 +1,176 @@
+/**
+ * Base error class for Commit CLI
+ * Provides consistent error structure with user-friendly messages and suggestions
+ */
+class CommitCLIError extends Error {
+  public readonly suggestion: string | null;
+
+  constructor(message: string, suggestion: string | null = null) {
+    super(message);
+    this.name = this.constructor.name;
+    this.suggestion = suggestion;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Git repository related errors
+ * Thrown when Git operations fail or repository is invalid
+ */
+export class GitRepositoryError extends CommitCLIError {
+  constructor(
+    message: string,
+    suggestion: string = 'Ensure you are in a valid Git repository or provide a correct path.'
+  ) {
+    super(message, suggestion);
+  }
+
+  static noRepositoryFound(path: string): GitRepositoryError {
+    return new GitRepositoryError(
+      `No Git repository found at: ${path}`,
+      'Initialize a Git repository with "git init" or provide a valid repository path.'
+    );
+  }
+
+  static noCommitsFound(): GitRepositoryError {
+    return new GitRepositoryError(
+      'Repository has no commits yet',
+      'Create an initial commit with "git add . && git commit -m \'Initial commit\'"'
+    );
+  }
+
+  static noChanges(): GitRepositoryError {
+    return new GitRepositoryError(
+      'No changes to commit',
+      'Make some changes to your files or check "git status" to see the current state.'
+    );
+  }
+
+  static commitFailed(gitError: string): GitRepositoryError {
+    return new GitRepositoryError(
+      `Git commit failed: ${gitError}`,
+      'Check the error message above and resolve any Git issues.'
+    );
+  }
+
+  static pathNotAccessible(path: string): GitRepositoryError {
+    return new GitRepositoryError(
+      `Path not accessible: ${path}`,
+      'Ensure the path exists and you have permission to access it.'
+    );
+  }
+}
+
+/**
+ * Configuration related errors
+ * Thrown when config file operations fail or configuration is invalid
+ */
+export class ConfigurationError extends CommitCLIError {
+  constructor(
+    message: string,
+    suggestion: string = 'Try reconfiguring with the --reconfigure flag.'
+  ) {
+    super(message, suggestion);
+  }
+
+  static noApiKey(): ConfigurationError {
+    return new ConfigurationError(
+      'No API key configured',
+      'Run the CLI to set up your Gemini API key, or use --reconfigure to update it.'
+    );
+  }
+
+  static invalidApiKey(): ConfigurationError {
+    return new ConfigurationError(
+      'Invalid API key format',
+      'Ensure your Gemini API key is correct. Get one at https://makersuite.google.com/app/apikey'
+    );
+  }
+
+  static configFileCorrupted(): ConfigurationError {
+    return new ConfigurationError(
+      'Configuration file is corrupted',
+      'Delete ~/.commic/config.json and run the CLI again to reconfigure.'
+    );
+  }
+
+  static configSaveFailed(error: Error): ConfigurationError {
+    return new ConfigurationError(
+      `Failed to save configuration: ${error.message}`,
+      'Check file system permissions for ~/.commic/ directory.'
+    );
+  }
+}
+
+/**
+ * Gemini API related errors
+ * Thrown when API requests fail or return invalid responses
+ */
+export class APIError extends CommitCLIError {
+  constructor(
+    message: string,
+    suggestion: string = 'Check your internet connection and try again.'
+  ) {
+    super(message, suggestion);
+  }
+
+  static requestFailed(error: Error): APIError {
+    return new APIError(
+      `Gemini API request failed: ${error.message}`,
+      'Verify your API key is valid and you have internet connectivity.'
+    );
+  }
+
+  static rateLimitExceeded(): APIError {
+    return new APIError(
+      'API rate limit exceeded',
+      'Wait a few moments before trying again, or check your API quota at https://makersuite.google.com/'
+    );
+  }
+
+  static invalidResponse(): APIError {
+    return new APIError(
+      'Received invalid response from Gemini API',
+      'Try again. If the problem persists, the API might be experiencing issues.'
+    );
+  }
+
+  static authenticationFailed(): APIError {
+    return new APIError(
+      'API authentication failed',
+      'Your API key may be invalid or expired. Use --reconfigure to update it.'
+    );
+  }
+
+  static timeout(): APIError {
+    return new APIError('API request timed out', 'Check your internet connection and try again.');
+  }
+}
+
+/**
+ * Commit message validation errors
+ * Thrown when generated messages don't meet Conventional Commits specification
+ */
+export class ValidationError extends CommitCLIError {
+  constructor(
+    message: string,
+    suggestion: string = 'This is likely an internal error. Please try again.'
+  ) {
+    super(message, suggestion);
+  }
+
+  static invalidConventionalCommit(errors: string[]): ValidationError {
+    const errorList = errors.join(', ');
+    return new ValidationError(
+      `Generated commit message doesn't meet Conventional Commits spec: ${errorList}`,
+      'Try generating new suggestions. If this persists, report it as a bug.'
+    );
+  }
+
+  static noValidSuggestions(): ValidationError {
+    return new ValidationError(
+      'Could not generate valid commit message suggestions',
+      'Try again with different changes, or check if your diff is too large.'
+    );
+  }
+}

package/src/git/GitService.ts

@@ -0,0 +1,246 @@
+import { promises as fs } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { type SimpleGit, simpleGit } from 'simple-git';
+import { GitRepositoryError } from '../errors/CustomErrors.js';
+import type { GitDiff, GitRepository } from '../types/index.js';
+
+/**
+ * Handles all Git operations including repository discovery, diff retrieval, and commits
+ */
+export class GitService {
+  /**
+   * Find Git repository by walking up the directory tree
+   * @param startPath Starting path to search from
+   * @returns GitRepository with path and root information
+   * @throws GitRepositoryError if no repository found or path not accessible
+   */
+  async findRepository(startPath: string): Promise<GitRepository> {
+    try {
+      // Normalize and resolve the path
+      const normalizedPath = this.normalizePath(startPath);
+      const resolvedPath = resolve(normalizedPath);
+
+      // Check if path exists and is accessible
+      try {
+        await fs.access(resolvedPath);
+      } catch {
+        throw GitRepositoryError.pathNotAccessible(resolvedPath);
+      }
+
+      // Walk up directory tree looking for .git folder
+      let currentPath = resolvedPath;
+      const root = '/';
+
+      while (currentPath !== root) {
+        const gitPath = join(currentPath, '.git');
+
+        try {
+          const stats = await fs.stat(gitPath);
+          if (stats.isDirectory()) {
+            // Found .git directory
+            return {
+              path: resolvedPath,
+              rootPath: currentPath,
+            };
+          }
+        } catch {
+          // .git not found at this level, continue up
+        }
+
+        // Move up one directory
+        const parentPath = dirname(currentPath);
+        if (parentPath === currentPath) {
+          // Reached root without finding .git
+          break;
+        }
+        currentPath = parentPath;
+      }
+
+      // No .git directory found
+      throw GitRepositoryError.noRepositoryFound(resolvedPath);
+    } catch (error) {
+      if (error instanceof GitRepositoryError) {
+        throw error;
+      }
+      throw GitRepositoryError.pathNotAccessible(startPath);
+    }
+  }
+
+  /**
+   * Normalize path by removing trailing slashes and resolving relative paths
+   * @param path Path to normalize
+   * @returns Normalized path
+   */
+  private normalizePath(path: string): string {
+    // Remove trailing slashes
+    let normalized = path.replace(/\/+$/, '');
+
+    // Handle empty string (current directory)
+    if (normalized === '') {
+      normalized = '.';
+    }
+
+    return normalized;
+  }
+
+  /**
+   * Check if repository has any commits
+   * @param repoPath Path to repository root
+   * @returns true if repository has commits, false if empty
+   * @throws GitRepositoryError if check fails
+   */
+  async hasCommits(repoPath: string): Promise<boolean> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+      const log = await git.log({ maxCount: 1 });
+      return log.total > 0;
+    } catch (_error) {
+      // If git log fails, repository likely has no commits
+      return false;
+    }
+  }
+
+  /**
+   * Get diff between HEAD and current working state
+   * @param repoPath Path to repository root
+   * @returns GitDiff with staged, unstaged changes and hasChanges flag
+   * @throws GitRepositoryError if diff retrieval fails
+   */
+  async getDiff(repoPath: string): Promise<GitDiff> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+
+      // Get staged changes (diff --cached)
+      const staged = await git.diff(['--cached']);
+
+      // Get unstaged changes (diff)
+      const unstaged = await git.diff();
+
+      const hasChanges = staged.length > 0 || unstaged.length > 0;
+
+      return {
+        staged,
+        unstaged,
+        hasChanges,
+      };
+    } catch (error) {
+      throw new GitRepositoryError(
+        `Failed to retrieve Git diff: ${(error as Error).message}`,
+        'Ensure you are in a valid Git repository with proper permissions.'
+      );
+    }
+  }
+
+  /**
+   * Stage all changes in the repository
+   * @param repoPath Path to repository root
+   * @throws GitRepositoryError if staging fails
+   */
+  async stageAll(repoPath: string): Promise<void> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+      await git.add('.');
+    } catch (error) {
+      throw new GitRepositoryError(
+        `Failed to stage changes: ${(error as Error).message}`,
+        'Check if you have permission to modify the repository.'
+      );
+    }
+  }
+
+  /**
+   * Execute git commit with the provided message
+   * @param repoPath Path to repository root
+   * @param message Commit message
+   * @returns Commit hash
+   * @throws GitRepositoryError if commit fails
+   */
+  async commit(repoPath: string, message: string): Promise<string> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+      const result = await git.commit(message);
+
+      // Extract commit hash from result
+      const commitHash = result.commit || 'unknown';
+
+      return commitHash;
+    } catch (error) {
+      throw GitRepositoryError.commitFailed((error as Error).message);
+    }
+  }
+
+  /**
+   * Get current branch name
+   * @param repoPath Path to repository root
+   * @returns Current branch name
+   */
+  async getCurrentBranch(repoPath: string): Promise<string> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+      const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+      return branch.trim();
+    } catch (_error) {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * Get repository name from path
+   * @param repoPath Path to repository root
+   * @returns Repository name (last directory in path)
+   */
+  getRepositoryName(repoPath: string): string {
+    const parts = repoPath.split('/').filter((p) => p.length > 0);
+    return parts[parts.length - 1] || 'unknown';
+  }
+
+  /**
+   * Get diff statistics (files changed, insertions, deletions)
+   * @param repoPath Path to repository root
+   * @returns Statistics object
+   */
+  async getDiffStats(repoPath: string): Promise<{
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+  }> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+      const diffSummary = await git.diffSummary();
+
+      return {
+        filesChanged: diffSummary.files.length,
+        insertions: diffSummary.insertions,
+        deletions: diffSummary.deletions,
+      };
+    } catch (_error) {
+      return {
+        filesChanged: 0,
+        insertions: 0,
+        deletions: 0,
+      };
+    }
+  }
+
+  /**
+   * Get remote repository URL
+   * @param repoPath Path to repository root
+   * @param remoteName Remote name (default: 'origin')
+   * @returns Remote URL or null if no remote configured
+   */
+  async getRemoteUrl(repoPath: string, remoteName: string = 'origin'): Promise<string | null> {
+    try {
+      const git: SimpleGit = simpleGit(repoPath);
+      const remotes = await git.getRemotes(true);
+      const remote = remotes.find((r) => r.name === remoteName);
+
+      if (remote?.refs?.fetch) {
+        return remote.refs.fetch;
+      }
+
+      return null;
+    } catch (_error) {
+      return null;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { ConfigManager } from './config/ConfigManager.js';
+import { GitService } from './git/GitService.js';
+import { MainOrchestrator } from './orchestrator/MainOrchestrator.js';
+import type { CLIOptions } from './types/index.js';
+import { UIManager } from './ui/UIManager.js';
+
+/**
+ * Main entry point for the Commit CLI
+ */
+async function main() {
+  const program = new Command();
+
+  program
+    .name('commic')
+    .description('AI-powered Git commit message generator with Conventional Commits support')
+    .version('1.0.0')
+    .argument('[path]', 'Path to Git repository', '.')
+    .option('-r, --reconfigure', 'Reconfigure API key and model settings')
+    .action(async (path: string, options: { reconfigure?: boolean }) => {
+      try {
+        // Create service instances
+        const configManager = new ConfigManager();
+        const gitService = new GitService();
+        const uiManager = new UIManager();
+
+        // Create orchestrator
+        const orchestrator = new MainOrchestrator(configManager, gitService, uiManager);
+
+        // Build CLI options
+        const cliOptions: CLIOptions = {
+          path,
+          reconfigure: options.reconfigure,
+        };
+
+        // Execute workflow
+        await orchestrator.execute(cliOptions);
+      } catch (_error) {
+        // Top-level error handler
+        // Orchestrator already handles and displays errors
+        // This is just to ensure we exit with error code
+        process.exit(1);
+      }
+    });
+
+  await program.parseAsync(process.argv);
+}
+
+// Run the CLI
+main().catch((error) => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});