@misaelabanto/commita 0.1.2

package/src/cli/set-handler.ts

@@ -0,0 +1,134 @@
+import { ConfigWriter } from '@/config/config.writer.ts';
+import chalk from 'chalk';
+import { createInterface } from 'readline';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface SetOptions {
+  local?: boolean;
+}
+
+const SENSITIVE_KEYS = ['OPENAI_API_KEY', 'GEMINI_API_KEY'];
+
+export class SetHandler {
+  private configWriter: ConfigWriter;
+
+  constructor() {
+    this.configWriter = new ConfigWriter();
+  }
+
+  async execute(keyValue: string, options: SetOptions): Promise<void> {
+    const { key, value } = this.parseKeyValue(keyValue);
+
+    let finalValue = value;
+    if (!finalValue) {
+      finalValue = await this.promptForValue(key);
+    }
+
+    const configPath = this.getConfigPath(options.local || false);
+    await this.configWriter.set(key, finalValue, configPath);
+
+    console.log(chalk.green('\n✓ Configuration updated successfully'));
+    console.log(`  ${chalk.cyan(key)}=${chalk.green(this.maskSensitiveValue(key, finalValue))} set in ${chalk.gray(configPath)}\n`);
+  }
+
+  private parseKeyValue(keyValue: string): { key: string; value?: string } {
+    const eqIndex = keyValue.indexOf('=');
+
+    if (eqIndex === -1) {
+      // No value provided, will prompt interactively
+      return {
+        key: keyValue.trim(),
+        value: undefined,
+      };
+    }
+
+    const key = keyValue.substring(0, eqIndex).trim();
+    const value = keyValue.substring(eqIndex + 1).trim();
+
+    if (!key) {
+      throw new Error('Key cannot be empty');
+    }
+
+    return { key, value };
+  }
+
+  private getConfigPath(isLocal: boolean): string {
+    if (isLocal) {
+      return join(process.cwd(), '.commita');
+    }
+    return join(homedir(), '.commita');
+  }
+
+  private async promptForValue(key: string): Promise<string> {
+    if (!process.stdin.isTTY) {
+      throw new Error(`Value required for key '${key}'. Use format: commita set KEY=value`);
+    }
+
+    const isSensitive = this.isSensitiveKey(key);
+    const prompt = `Enter value for ${chalk.cyan(key)}${isSensitive ? ' (hidden)' : ''}: `;
+
+    return new Promise((resolve, reject) => {
+      const readline = createInterface({
+        input: process.stdin,
+        output: isSensitive ? process.stderr : process.stdout,
+        terminal: true,
+      });
+
+      if (isSensitive) {
+        // Hide input for sensitive keys
+        process.stdin.setRawMode?.(true);
+        process.stderr.write(prompt);
+      } else {
+        readline.question(prompt, () => {});
+      }
+
+      let value = '';
+
+      process.stdin.on('data', (buffer) => {
+        const char = buffer.toString();
+
+        if (char === '\n' || char === '\r') {
+          if (isSensitive) {
+            process.stdin.setRawMode?.(false);
+            process.stderr.write('\n');
+          }
+          readline.close();
+          resolve(value);
+        } else if (char === '\u0003') {
+          // Handle Ctrl+C
+          if (isSensitive) {
+            process.stdin.setRawMode?.(false);
+          }
+          readline.close();
+          reject(new Error('Input cancelled'));
+        } else if (char === '\u007f') {
+          // Handle backspace
+          value = value.slice(0, -1);
+        } else {
+          value += char;
+        }
+      });
+
+      readline.once('close', () => {
+        if (!value) {
+          reject(new Error('No value provided'));
+        }
+      });
+    });
+  }
+
+  private isSensitiveKey(key: string): boolean {
+    return SENSITIVE_KEYS.includes(key.toUpperCase());
+  }
+
+  private maskSensitiveValue(key: string, value: string): string {
+    if (!this.isSensitiveKey(key)) {
+      return value;
+    }
+    if (value.length <= 4) {
+      return '*'.repeat(value.length);
+    }
+    return value.substring(0, 2) + '*'.repeat(value.length - 4) + value.substring(value.length - 2);
+  }
+}

package/src/config/config.loader.ts

@@ -0,0 +1,151 @@
+import type { CommitaConfig, CommitStyle, PromptStyle, Provider } from '@/config/config.types.ts';
+import { DEFAULT_CONFIG } from '@/config/config.types.ts';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import simpleGit from 'simple-git';
+
+export class ConfigLoader {
+  async load(configPath?: string): Promise<CommitaConfig> {
+    const globalConfig = await this.loadFromFile(this.getGlobalConfigPath());
+    const fileConfig = await this.loadFromFile(configPath);
+    const envConfig = this.loadFromEnv();
+
+    return {
+      ...DEFAULT_CONFIG,
+      ...globalConfig,
+      ...fileConfig,
+      ...envConfig,
+    };
+  }
+
+  private getGlobalConfigPath(): string {
+    return join(homedir(), '.commita');
+  }
+
+  private async loadFromFile(configPath?: string): Promise<Partial<CommitaConfig>> {
+    let path = configPath;
+
+    if (!path) {
+      const cwdPath = join(process.cwd(), '.commita');
+      if (existsSync(cwdPath)) {
+        path = cwdPath;
+      } else {
+        const gitRoot = await this.findGitRoot();
+        if (gitRoot) {
+          const rootPath = join(gitRoot, '.commita');
+          if (existsSync(rootPath)) {
+            path = rootPath;
+          }
+        }
+      }
+    }
+
+    // Fallback to default check if we still haven't found it or if it was explicitly provided
+    if (!path) {
+      path = join(process.cwd(), '.commita');
+    }
+
+    if (!existsSync(path)) {
+      return {};
+    }
+
+    try {
+      const content = await readFile(path, 'utf-8');
+      return this.parseKeyValue(content);
+    } catch (error) {
+      console.warn(`Warning: Could not read config file at ${path}`);
+      return {};
+    }
+  }
+
+  private async findGitRoot(): Promise<string | null> {
+    try {
+      const git = simpleGit();
+      const root = await git.revparse(['--show-toplevel']);
+      return root.trim();
+    } catch {
+      return null;
+    }
+  }
+
+  private parseKeyValue(content: string): Partial<CommitaConfig> {
+    const config: Partial<CommitaConfig> = {};
+    const lines = content.split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const [key, ...valueParts] = trimmed.split('=');
+      if (!key || valueParts.length === 0) continue;
+
+      const value = valueParts.join('=').trim();
+      const normalizedKey = key.trim().toUpperCase();
+
+      switch (normalizedKey) {
+        case 'PROVIDER':
+          config.provider = value as Provider;
+          break;
+        case 'MODEL':
+          config.model = value;
+          break;
+        case 'PROMPT_STYLE':
+          config.promptStyle = value as PromptStyle;
+          break;
+        case 'PROMPT_TEMPLATE':
+          config.promptTemplate = value;
+          break;
+        case 'CUSTOM_PROMPT':
+          config.customPrompt = value;
+          break;
+        case 'COMMIT_STYLE':
+          config.commitStyle = value as CommitStyle;
+          break;
+        case 'OPENAI_API_KEY':
+          config.openaiApiKey = value;
+          break;
+        case 'GEMINI_API_KEY':
+          config.geminiApiKey = value;
+          break;
+      }
+    }
+
+    return config;
+  }
+
+  private loadFromEnv(): Partial<CommitaConfig> {
+    const config: Partial<CommitaConfig> = {};
+
+    if (process.env.COMMITA_PROVIDER) {
+      config.provider = process.env.COMMITA_PROVIDER as Provider;
+    }
+    if (process.env.COMMITA_MODEL) {
+      config.model = process.env.COMMITA_MODEL;
+    }
+    if (process.env.COMMITA_PROMPT_STYLE) {
+      config.promptStyle = process.env.COMMITA_PROMPT_STYLE as PromptStyle;
+    }
+    if (process.env.COMMITA_PROMPT_TEMPLATE) {
+      config.promptTemplate = process.env.COMMITA_PROMPT_TEMPLATE;
+    }
+    if (process.env.COMMITA_CUSTOM_PROMPT) {
+      config.customPrompt = process.env.COMMITA_CUSTOM_PROMPT;
+    }
+    if (process.env.COMMITA_COMMIT_STYLE) {
+      config.commitStyle = process.env.COMMITA_COMMIT_STYLE as CommitStyle;
+    }
+    if (process.env.OPENAI_API_KEY) {
+      config.openaiApiKey = process.env.OPENAI_API_KEY;
+    }
+    if (process.env.GEMINI_API_KEY) {
+      config.geminiApiKey = process.env.GEMINI_API_KEY;
+    }
+    if (process.env.GOOGLE_GENERATIVE_AI_API_KEY && !config.geminiApiKey) {
+      config.geminiApiKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+    }
+
+    return config;
+  }
+}

package/src/config/config.types.ts

@@ -0,0 +1,22 @@
+export type CommitStyle = 'conventional' | 'emoji';
+export type PromptStyle = 'default' | 'detailed' | 'minimal' | 'custom';
+export type Provider = 'openai' | 'gemini';
+
+export interface CommitaConfig {
+  provider: Provider;
+  model: string;
+  promptStyle: PromptStyle;
+  promptTemplate?: string;
+  customPrompt?: string;
+  commitStyle: CommitStyle;
+  openaiApiKey?: string;
+  geminiApiKey?: string;
+}
+
+export const DEFAULT_CONFIG: CommitaConfig = {
+  provider: 'openai',
+  model: 'gpt-4o-mini',
+  promptStyle: 'default',
+  commitStyle: 'conventional',
+};
+

package/src/config/config.writer.ts

@@ -0,0 +1,204 @@
+import type { CommitStyle, PromptStyle, Provider } from '@/config/config.types.ts';
+import { existsSync } from 'fs';
+import { readFile, writeFile, chmod } from 'fs/promises';
+import { join } from 'path';
+
+interface ConfigLine {
+  type: 'comment' | 'blank' | 'config';
+  content: string;
+  key?: string;
+  value?: string;
+}
+
+const VALID_KEYS = [
+  'PROVIDER',
+  'MODEL',
+  'OPENAI_API_KEY',
+  'GEMINI_API_KEY',
+  'COMMIT_STYLE',
+  'PROMPT_STYLE',
+  'PROMPT_TEMPLATE',
+  'CUSTOM_PROMPT',
+];
+
+const VALID_PROVIDERS: Provider[] = ['openai', 'gemini'];
+const VALID_COMMIT_STYLES: CommitStyle[] = ['conventional', 'emoji'];
+const VALID_PROMPT_STYLES: PromptStyle[] = ['default', 'detailed', 'minimal', 'custom'];
+
+export class ConfigWriter {
+  async set(key: string, value: string, filePath: string): Promise<void> {
+    this.validateKey(key);
+    this.validateValue(key, value);
+
+    const lines = await this.readConfigFile(filePath);
+    const updatedLines = this.updateOrAddConfigLine(lines, key, value);
+    await this.writeConfigFile(filePath, updatedLines);
+  }
+
+  private validateKey(key: string): void {
+    const normalizedKey = key.toUpperCase();
+    if (!VALID_KEYS.includes(normalizedKey)) {
+      const availableKeys = VALID_KEYS.join(', ');
+      throw new Error(`Unknown configuration key '${key}'\n\nAvailable keys: ${availableKeys}`);
+    }
+  }
+
+  private validateValue(key: string, value: string): void {
+    const normalizedKey = key.toUpperCase();
+
+    switch (normalizedKey) {
+      case 'PROVIDER':
+        if (!VALID_PROVIDERS.includes(value as Provider)) {
+          throw new Error(
+            `Invalid value for PROVIDER\n  Expected: ${VALID_PROVIDERS.join(' or ')}\n  Received: ${value}`
+          );
+        }
+        break;
+      case 'COMMIT_STYLE':
+        if (!VALID_COMMIT_STYLES.includes(value as CommitStyle)) {
+          throw new Error(
+            `Invalid value for COMMIT_STYLE\n  Expected: ${VALID_COMMIT_STYLES.join(' or ')}\n  Received: ${value}`
+          );
+        }
+        break;
+      case 'PROMPT_STYLE':
+        if (!VALID_PROMPT_STYLES.includes(value as PromptStyle)) {
+          throw new Error(
+            `Invalid value for PROMPT_STYLE\n  Expected: ${VALID_PROMPT_STYLES.join(', ')}\n  Received: ${value}`
+          );
+        }
+        break;
+      case 'OPENAI_API_KEY':
+        if (value.length < 10) {
+          throw new Error(
+            `API key for OPENAI_API_KEY appears to be invalid (too short: ${value.length} characters)`
+          );
+        }
+        break;
+      case 'GEMINI_API_KEY':
+        if (value.length < 10) {
+          throw new Error(
+            `API key for GEMINI_API_KEY appears to be invalid (too short: ${value.length} characters)`
+          );
+        }
+        break;
+    }
+  }
+
+  private async readConfigFile(filePath: string): Promise<ConfigLine[]> {
+    if (!existsSync(filePath)) {
+      return [];
+    }
+
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      return this.parseConfigLines(content);
+    } catch (error) {
+      throw new Error(`Could not read config file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  private parseConfigLines(content: string): ConfigLine[] {
+    const lines: ConfigLine[] = [];
+    const contentLines = content.split('\n');
+
+    for (const line of contentLines) {
+      if (line.trim().startsWith('#')) {
+        lines.push({
+          type: 'comment',
+          content: line,
+        });
+      } else if (line.trim() === '') {
+        lines.push({
+          type: 'blank',
+          content: line,
+        });
+      } else {
+        const trimmed = line.trim();
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex > 0) {
+          const key = trimmed.substring(0, eqIndex).trim().toUpperCase();
+          const value = trimmed.substring(eqIndex + 1).trim();
+          lines.push({
+            type: 'config',
+            content: line,
+            key,
+            value,
+          });
+        }
+      }
+    }
+
+    return lines;
+  }
+
+  private updateOrAddConfigLine(lines: ConfigLine[], key: string, value: string): ConfigLine[] {
+    const normalizedKey = key.toUpperCase();
+    const existingIndex = lines.findIndex(
+      (line) => line.type === 'config' && line.key === normalizedKey
+    );
+
+    if (existingIndex >= 0) {
+      lines[existingIndex] = {
+        type: 'config',
+        content: `${normalizedKey}=${value}`,
+        key: normalizedKey,
+        value,
+      };
+    } else {
+      lines.push({
+        type: 'config',
+        content: `${normalizedKey}=${value}`,
+        key: normalizedKey,
+        value,
+      });
+    }
+
+    return lines;
+  }
+
+  private async writeConfigFile(filePath: string, lines: ConfigLine[]): Promise<void> {
+    let content: string;
+
+    if (lines.length === 0) {
+      content = this.createDefaultConfig();
+    } else {
+      content = lines.map((line) => line.content).join('\n');
+      if (content && !content.endsWith('\n')) {
+        content += '\n';
+      }
+    }
+
+    try {
+      await writeFile(filePath, content, 'utf-8');
+      // Set file permissions to 0600 (owner read/write only)
+      await chmod(filePath, 0o600);
+    } catch (error) {
+      throw new Error(
+        `Could not write config file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  private createDefaultConfig(): string {
+    return `# Commita Configuration
+# https://github.com/misaelabanto/commita
+
+# AI Provider: openai or gemini
+# PROVIDER=openai
+
+# Model name (provider-specific)
+# MODEL=gpt-4o-mini
+
+# Prompt style: default, detailed, minimal, or custom
+# PROMPT_STYLE=default
+
+# Commit message style: conventional or emoji
+# COMMIT_STYLE=conventional
+
+# API Keys - set the key for your chosen provider
+# OPENAI_API_KEY=your-openai-api-key-here
+# GEMINI_API_KEY=your-gemini-api-key-here
+`;
+  }
+}

package/src/config/prompt-templates.ts

@@ -0,0 +1,55 @@
+export const PROMPT_TEMPLATES = {
+  default: `You are a helpful assistant that generates git commit messages.
+
+Analyze the following git diff and generate a commit message following this format:
+<type>(<scope>): <short description>
+
+- Change 1
+- Change 2
+- Change 3
+
+Rules:
+1. Determine the commit type from: feat, fix, refactor, chore, docs, style, test, perf
+2. The scope should be extracted from the common path (e.g., "components", "utils", "services")
+3. Keep the short description under 50 characters
+4. List 2-5 key changes as bullet points
+5. Be concise and clear
+
+Git diff:
+{diff}`,
+
+  detailed: `You are an expert developer analyzing code changes for commit message generation.
+
+Your task is to deeply analyze the following git diff and create a comprehensive commit message.
+
+Context Analysis:
+- Identify what problem is being solved or feature being added
+- Understand the broader context of changes
+- Note any patterns, architectural decisions, or technical debt addressed
+
+Format your commit message as:
+<type>(<scope>): <short description>
+
+- Detailed change 1 with context
+- Detailed change 2 with context
+- Detailed change 3 with context
+
+Commit types: feat, fix, refactor, chore, docs, style, test, perf
+The scope should reflect the affected module/area.
+
+Git diff:
+{diff}`,
+
+  minimal: `Generate a short commit message for this diff.
+
+Format: <type>(<scope>): <description>
+
+- Key change 1
+- Key change 2
+
+Types: feat, fix, refactor, chore, docs, style, test, perf
+
+Diff:
+{diff}`,
+};
+

package/src/git/file-grouper.ts

@@ -0,0 +1,142 @@
+import type { FileChange } from '@/git/git.service.ts';
+import type { ProjectBoundary } from '@/git/project-detector.ts';
+
+export interface FileGroup {
+  scope: string;
+  files: FileChange[];
+}
+
+export class FileGrouper {
+  private boundaries: ProjectBoundary[];
+
+  constructor(boundaries: ProjectBoundary[] = []) {
+    // Sort longest path first so the most specific project matches first
+    this.boundaries = [...boundaries].sort(
+      (a, b) => b.path.length - a.path.length,
+    );
+  }
+
+  groupByPath(files: FileChange[]): FileGroup[] {
+    if (files.length === 0) {
+      return [];
+    }
+
+    const groups = new Map<string, FileChange[]>();
+
+    for (const file of files) {
+      const scope = this.extractScope(file.path);
+      const existing = groups.get(scope) || [];
+      existing.push(file);
+      groups.set(scope, existing);
+    }
+
+    return Array.from(groups.entries()).map(([scope, files]) => ({
+      scope,
+      files,
+    }));
+  }
+
+  private extractScope(filePath: string): string {
+    const parts = filePath.split('/');
+
+    if (parts.length === 1) {
+      return 'root';
+    }
+
+    const project = this.findProjectForFile(filePath);
+
+    if (project) {
+      const relativePath = filePath.slice(project.path.length + 1);
+      const relativeParts = relativePath.split('/');
+
+      if (relativeParts.length <= 1) {
+        return project.path;
+      }
+
+      const meaningfulParts = this.findMeaningfulPath(relativeParts);
+      return `${project.path}/${meaningfulParts.join('/')}`;
+    }
+
+    if (this.boundaries.length > 0) {
+      // In a monorepo, root-level files that don't belong to any project
+      return 'root';
+    }
+
+    const meaningfulParts = this.findMeaningfulPath(parts);
+    return meaningfulParts.join('/');
+  }
+
+  private findProjectForFile(filePath: string): ProjectBoundary | undefined {
+    return this.boundaries.find(
+      b => filePath === b.path || filePath.startsWith(`${b.path}/`),
+    );
+  }
+
+  private findMeaningfulPath(parts: string[]): string[] {
+    const commonDirs = ['src', 'lib', 'app', 'pages'];
+    const startIdx = parts.findIndex(p => commonDirs.includes(p));
+
+    if (startIdx === -1) {
+      return parts.slice(0, Math.min(2, parts.length - 1));
+    }
+
+    const relevantParts = parts.slice(startIdx);
+
+    if (relevantParts.length === 1) {
+      return relevantParts;
+    }
+
+    return relevantParts.slice(0, 2);
+  }
+
+  optimizeGroups(groups: FileGroup[]): FileGroup[] {
+    const scopeMap = new Map<string, FileChange[]>();
+
+    for (const group of groups) {
+      const normalizedScope = this.normalizeScope(group.scope);
+      const existing = scopeMap.get(normalizedScope) || [];
+      existing.push(...group.files);
+      scopeMap.set(normalizedScope, existing);
+    }
+
+    const optimized: FileGroup[] = [];
+    for (const [scope, files] of scopeMap.entries()) {
+      optimized.push({ scope, files });
+    }
+
+    return optimized.sort((a, b) => {
+      if (a.scope === 'root') return 1;
+      if (b.scope === 'root') return -1;
+      return a.scope.localeCompare(b.scope);
+    });
+  }
+
+  private normalizeScope(scope: string): string {
+    const project = this.findProjectForScope(scope);
+
+    if (project) {
+      const subScope = scope.slice(project.path.length + 1);
+      const parts = subScope.split('/');
+
+      if (parts.length > 2 && parts[0] === 'src') {
+        return `${project.path}/${parts.slice(0, 2).join('/')}`;
+      }
+
+      return scope;
+    }
+
+    const parts = scope.split('/');
+
+    if (parts.length > 2 && parts[0] === 'src') {
+      return parts.slice(0, 2).join('/');
+    }
+
+    return scope;
+  }
+
+  private findProjectForScope(scope: string): ProjectBoundary | undefined {
+    return this.boundaries.find(
+      b => scope === b.path || scope.startsWith(`${b.path}/`),
+    );
+  }
+}