@freetison/git-super 0.2.0

package/lib/cli/auth-commands.mjs

@@ -0,0 +1,327 @@
+/**
+ * CLI Authentication Commands
+ * Handles auth login, logout, status, and context management
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { getConfigPath, listOrganizations, loadConfig } from '../config/config-loader.mjs';
+import { ProviderRegistry } from '../providers/provider-registry.mjs';
+import { openBrowser } from '../auth/oauth-flows.mjs';
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+/**
+ * Handle 'auth login' command
+ */
+export async function handleAuthLogin(args) {
+  const providerName = args.provider || args.p;
+  const orgId = args.org || args.o;
+
+  if (!providerName) {
+    log('Usage: git super auth login --provider <name> [--org <org-id>]', 'yellow');
+    log('\nAvailable OAuth providers:', 'bright');
+    log('  • github-copilot     GitHub Copilot Enterprise', 'cyan');
+    log('  • azure-openai       Azure OpenAI with Azure AD', 'cyan');
+    log('  • generic-oidc       Generic OIDC provider', 'cyan');
+    return;
+  }
+
+  try {
+    // Load config for the specified org (if provided)
+    let config = loadConfig();
+    
+    if (orgId && config.organizations) {
+      const orgConfig = config.organizations[orgId];
+      if (!orgConfig) {
+        throw new Error(`Organization '${orgId}' not found in config`);
+      }
+      config = { ...config, ...orgConfig };
+      log(`\n🏢 Using organization: ${orgConfig.name || orgId}`, 'cyan');
+    }
+
+    // Get provider instance
+    const registry = new ProviderRegistry(config);
+    
+    // Create provider if not in registry (force initialization)
+    let provider;
+    try {
+      provider = registry.get(providerName);
+    } catch {
+      // Provider not auto-registered, try to create it manually
+      const { GitHubCopilotProvider } = await import('../providers/github-copilot-provider.mjs');
+      const { AzureOpenAIProvider } = await import('../providers/azure-openai-provider.mjs');
+      const { GenericOIDCProvider } = await import('../providers/generic-oidc-provider.mjs');
+      
+      switch (providerName) {
+        case 'github-copilot':
+          provider = new GitHubCopilotProvider(config);
+          break;
+        case 'azure-openai':
+          provider = new AzureOpenAIProvider(config);
+          break;
+        case 'generic-oidc':
+          provider = new GenericOIDCProvider(config);
+          break;
+        default:
+          throw new Error(`Provider '${providerName}' is not an OAuth provider or doesn't exist`);
+      }
+    }
+
+    if (!provider.initiateAuth) {
+      throw new Error(`Provider '${providerName}' does not support OAuth authentication`);
+    }
+
+    log(`\n🔐 Initiating OAuth authentication for ${providerName}...`, 'bright');
+    
+    // Step 1: Initiate device code flow
+    const deviceAuth = await provider.initiateAuth();
+    
+    // Step 2: Display code to user
+    log(`\n📝 User Code: ${colors.bright}${deviceAuth.userCode}${colors.reset}`, 'green');
+    log(`\n🌐 Verification URL: ${colors.cyan}${deviceAuth.verificationUri}${colors.reset}`);
+    
+    // Try to open browser
+    const opened = await openBrowser(deviceAuth.verificationUriComplete || deviceAuth.verificationUri);
+    
+    if (opened) {
+      log('\n✅ Browser opened. Please complete authentication in your browser.', 'green');
+    } else {
+      log('\n⚠️  Could not open browser automatically. Please open the URL above manually.', 'yellow');
+    }
+    
+    log(`\n⏳ Waiting for authorization (expires in ${Math.floor(deviceAuth.expiresIn / 60)} minutes)...`, 'cyan');
+    
+    // Step 3: Poll for token
+    await provider.completeAuth(deviceAuth.deviceCode, deviceAuth.interval);
+    
+    log('\n✅ Authentication successful!', 'green');
+    
+    // Show token info
+    const tokenInfo = await provider.tokenManager.getTokenInfo();
+    if (tokenInfo?.expiresAt) {
+      const expiresAt = new Date(tokenInfo.expiresAt);
+      log(`   Token valid until: ${expiresAt.toLocaleString()}`, 'cyan');
+    }
+    
+    log(`\n💡 You can now use: git super`, 'bright');
+    
+  } catch (error) {
+    log(`\n❌ Authentication failed: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle 'auth logout' command
+ */
+export async function handleAuthLogout(args) {
+  const providerName = args.provider || args.p;
+  const all = args.all || args.a;
+
+  const config = loadConfig();
+  const registry = new ProviderRegistry(config);
+
+  try {
+    if (all) {
+      // Logout from all OAuth providers
+      log('\n🔓 Logging out from all providers...', 'yellow');
+      
+      for (const [name, provider] of registry.providers) {
+        if (provider.tokenManager) {
+          try {
+            await provider.tokenManager.revokeToken();
+            log(`   ✅ ${name}`, 'green');
+          } catch (error) {
+            log(`   ⚠️  ${name}: ${error.message}`, 'yellow');
+          }
+        }
+      }
+      
+      log('\n✅ Logged out from all providers', 'green');
+    } else if (providerName) {
+      // Logout from specific provider
+      const provider = registry.get(providerName);
+      
+      if (!provider.tokenManager) {
+        throw new Error(`Provider '${providerName}' does not use OAuth authentication`);
+      }
+      
+      log(`\n🔓 Logging out from ${providerName}...`, 'yellow');
+      await provider.tokenManager.revokeToken();
+      log('✅ Successfully logged out', 'green');
+    } else {
+      // Logout from current provider
+      const currentProvider = registry.get(config.aiProvider);
+      
+      if (!currentProvider.tokenManager) {
+        throw new Error(`Current provider '${config.aiProvider}' does not use OAuth authentication`);
+      }
+      
+      log(`\n🔓 Logging out from ${config.aiProvider}...`, 'yellow');
+      await currentProvider.tokenManager.revokeToken();
+      log('✅ Successfully logged out', 'green');
+    }
+  } catch (error) {
+    log(`\n❌ Logout failed: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle 'auth status' command
+ */
+export async function handleAuthStatus() {
+  const config = loadConfig();
+  const registry = new ProviderRegistry(config);
+
+  log('\n📊 Authentication Status\n', 'bright');
+  
+  // Show active context
+  if (config.activeOrg) {
+    const orgConfig = config.organizations?.[config.activeOrg];
+    log(`Active Context: ${colors.cyan}${orgConfig?.name || config.activeOrg}${colors.reset}`);
+  }
+  
+  log(`Current Provider: ${colors.cyan}${config.aiProvider}${colors.reset}`);
+  log(`Model: ${colors.cyan}${config.aiModel}${colors.reset}\n`);
+
+  // Check each OAuth provider
+  for (const [name, provider] of registry.providers) {
+    if (provider.tokenManager) {
+      const tokenInfo = await provider.tokenManager.getTokenInfo();
+      
+      if (tokenInfo?.hasToken) {
+        const status = tokenInfo.isValid ? '✅' : '❌';
+        const statusText = tokenInfo.isValid ? 'Valid' : 'Expired';
+        const expiresAt = tokenInfo.expiresAt ? new Date(tokenInfo.expiresAt).toLocaleString() : 'N/A';
+        
+        log(`${status} ${colors.bright}${name}${colors.reset}: ${statusText}`, tokenInfo.isValid ? 'green' : 'red');
+        log(`   Expires: ${expiresAt}`, 'cyan');
+      } else {
+        log(`⚪ ${colors.bright}${name}${colors.reset}: Not authenticated`, 'yellow');
+      }
+    } else {
+      // API key provider
+      if (name === config.aiProvider) {
+        const hasKey = await provider.authStrategy?.isValid();
+        const status = hasKey ? '✅' : '❌';
+        const statusText = hasKey ? 'API key configured' : 'No API key';
+        log(`${status} ${colors.bright}${name}${colors.reset}: ${statusText}`, hasKey ? 'green' : 'red');
+      }
+    }
+  }
+  
+  console.log();
+}
+
+/**
+ * Handle 'context' commands
+ */
+export async function handleContext(args) {
+  const subcommand = args._[1]; // 'list', 'switch', 'create'
+  const config = loadConfig();
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      handleContextList();
+      break;
+      
+    case 'switch':
+    case 'sw':
+      handleContextSwitch(args);
+      break;
+      
+    case 'create':
+      log('Context creation wizard not yet implemented', 'yellow');
+      log('For now, edit ~/.gitsuperrc manually to add new contexts', 'cyan');
+      break;
+      
+    default:
+      // No subcommand: show current context
+      handleContextCurrent();
+  }
+}
+
+function handleContextList() {
+  const orgs = listOrganizations();
+  
+  if (orgs.length === 0) {
+    log('\n⚠️  No organizations configured', 'yellow');
+    log('Add organizations to ~/.gitsuperrc to use multi-context mode\n', 'cyan');
+    return;
+  }
+  
+  log('\n📋 Available Contexts:\n', 'bright');
+  
+  for (const org of orgs) {
+    const marker = org.isActive ? '* ' : '  ';
+    const color = org.isActive ? 'green' : 'cyan';
+    log(`${marker}${colors[color]}${org.id}${colors.reset} (${org.name})`, color);
+    log(`   Provider: ${org.aiProvider}/${org.aiModel}`, 'cyan');
+  }
+  
+  console.log();
+}
+
+function handleContextCurrent() {
+  const config = loadConfig();
+  
+  log('\n📍 Current Context\n', 'bright');
+  
+  if (config.activeOrg) {
+    const orgConfig = config.organizations?.[config.activeOrg];
+    log(`Organization: ${colors.cyan}${orgConfig?.name || config.activeOrg}${colors.reset}`);
+  } else {
+    log('Mode: Legacy (no organizations)', 'yellow');
+  }
+  
+  log(`Provider: ${colors.cyan}${config.aiProvider}${colors.reset}`);
+  log(`Model: ${colors.cyan}${config.aiModel}${colors.reset}`);
+  
+  console.log();
+}
+
+function handleContextSwitch(args) {
+  const targetOrg = args._[2] || args.org || args.o;
+  
+  if (!targetOrg) {
+    log('Usage: git super context switch <org-id>', 'yellow');
+    return;
+  }
+  
+  try {
+    const configPath = getConfigPath();
+    const content = readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    
+    if (!config.organizations || !config.organizations[targetOrg]) {
+      throw new Error(`Organization '${targetOrg}' not found`);
+    }
+    
+    // Update active org
+    config.activeOrg = targetOrg;
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    
+    const orgConfig = config.organizations[targetOrg];
+    log(`\n✅ Switched to: ${colors.green}${orgConfig.name || targetOrg}${colors.reset}`, 'green');
+    log(`   Provider: ${orgConfig.aiProvider}/${orgConfig.aiModel}`, 'cyan');
+    console.log();
+    
+  } catch (error) {
+    log(`\n❌ Failed to switch context: ${error.message}`, 'red');
+    process.exit(1);
+  }
+}

package/lib/config/config-loader.mjs

@@ -0,0 +1,167 @@
+/**
+ * Configuration loader with layered approach (no if-else chains)
+ * Layers: defaults → file config → environment variables
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+/**
+ * Map environment variables to config keys
+ */
+const ENV_MAPPINGS = {
+  aiProvider: 'AI_PROVIDER',
+  aiModel: 'AI_MODEL',
+  ollamaUrl: 'OLLAMA_URL',
+  anthropicKey: 'ANTHROPIC_API_KEY',
+  openaiKey: 'OPENAI_API_KEY',
+  
+  // OAuth / Enterprise configs
+  githubOrg: 'GITHUB_ORG',
+  githubClientId: 'GITHUB_CLIENT_ID',
+  azureTenantId: 'AZURE_TENANT_ID',
+  azureClientId: 'AZURE_CLIENT_ID',
+  azureResourceEndpoint: 'AZURE_OPENAI_ENDPOINT',
+  oidcIssuer: 'OIDC_ISSUER',
+  oidcClientId: 'OIDC_CLIENT_ID',
+  oidcApiEndpoint: 'OIDC_API_ENDPOINT',
+  
+  // Active organization context
+  activeOrg: 'GIT_SUPER_ACTIVE_ORG',
+};
+
+/**
+ * Default configuration values
+ */
+function getDefaults() {
+  return {
+    aiProvider: 'ollama',
+    aiModel: 'mistral:latest',
+    ollamaUrl: 'http://localhost:11434',
+    messageTemplate: null,
+    ticketNumber: '',
+    commitRules: {
+      types: ['feat', 'fix', 'docs', 'style', 'refactor', 'test', 'chore', 'perf', 'ci', 'build'],
+      maxLength: 72,
+      allowEmptyScope: true
+    }
+  };
+}
+
+/**
+ * Load configuration from file
+ */
+function loadFileConfig(configPath) {
+  if (!existsSync(configPath)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`⚠️  Error reading config file: ${error.message}`);
+    return {};
+  }
+}
+
+/**
+ * Apply environment variable overrides using object mapping
+ */
+function applyEnvOverrides(config) {
+  const overrides = {};
+  
+  Object.entries(ENV_MAPPINGS).forEach(([key, envVar]) => {
+    const value = process.env[envVar];
+    if (value !== undefined) {
+      overrides[key] = value;
+    }
+  });
+  
+  return { ...config, ...overrides };
+}
+
+/**
+ * Load configuration with layered approach
+ * Priority: ENV vars > file config > defaults
+ * 
+ * Supports two modes:
+ * 1. Legacy mode: flat config (backward compatible)
+ * 2. Multi-org mode: organizations with active context
+ */
+export function loadConfig() {
+  const configPath = join(homedir(), '.gitsuperrc');
+  
+  // Layer 1: Defaults
+  let config = getDefaults();
+  
+  // Layer 2: File config
+  const fileConfig = loadFileConfig(configPath);
+  
+  // Check if using multi-org configuration
+  if (fileConfig.organizations) {
+    // Multi-org mode: load active organization context
+    const activeOrg = fileConfig.activeOrg || Object.keys(fileConfig.organizations)[0];
+    const orgConfig = fileConfig.organizations[activeOrg];
+    
+    if (orgConfig) {
+      // Merge: defaults <- org config <- global fallbacks
+      config = {
+        ...config,
+        ...orgConfig,
+        activeOrg,
+        organizations: fileConfig.organizations, // Keep for context switching
+      };
+    } else {
+      console.warn(`⚠️  Active organization '${activeOrg}' not found in config, using defaults`);
+    }
+  } else {
+    // Legacy mode: flat config (backward compatible)
+    config = { ...config, ...fileConfig };
+  }
+  
+  // Layer 3: Environment variables (highest priority)
+  config = applyEnvOverrides(config);
+  
+  return config;
+}
+
+/**
+ * Get configuration path
+ * @returns {string}
+ */
+export function getConfigPath() {
+  return join(homedir(), '.gitsuperrc');
+}
+
+/**
+ * List all available organizations from config
+ * @returns {Array<Object>} Array of { id, name, aiProvider, aiModel }
+ */
+export function listOrganizations() {
+  const configPath = getConfigPath();
+  const fileConfig = loadFileConfig(configPath);
+  
+  if (!fileConfig.organizations) {
+    return [];
+  }
+  
+  return Object.entries(fileConfig.organizations).map(([id, org]) => ({
+    id,
+    name: org.name || id,
+    aiProvider: org.aiProvider || 'ollama',
+    aiModel: org.aiModel || 'unknown',
+    isActive: id === fileConfig.activeOrg,
+  }));
+}
+
+/**
+ * Get active organization ID
+ * @returns {string|null}
+ */
+export function getActiveOrg() {
+  const configPath = getConfigPath();
+  const fileConfig = loadFileConfig(configPath);
+  return fileConfig.activeOrg || null;
+}

package/lib/fallback/add-files-strategy.mjs

@@ -0,0 +1,15 @@
+/**
+ * Add Files Strategy - Handles when only new files are added
+ */
+
+import { BaseFallbackStrategy } from './base-fallback-strategy.mjs';
+
+export class AddFilesStrategy extends BaseFallbackStrategy {
+  canHandle({ added, modified, deleted }) {
+    return added > 0 && modified === 0 && deleted === 0;
+  }
+
+  getMessage() {
+    return 'feat: add new files';
+  }
+}

package/lib/fallback/base-fallback-strategy.mjs

@@ -0,0 +1,34 @@
+/**
+ * Base Fallback Strategy - Strategy Pattern interface
+ * All fallback strategies must extend this class
+ */
+
+export class BaseFallbackStrategy {
+  /**
+   * Check if this strategy can handle the given file stats
+   * @param {Object} stats - File change statistics
+   * @param {number} stats.added - Number of added files
+   * @param {number} stats.modified - Number of modified files
+   * @param {number} stats.deleted - Number of deleted files
+   * @returns {boolean}
+   */
+  canHandle(stats) {
+    throw new Error(`${this.constructor.name} must implement canHandle(stats)`);
+  }
+
+  /**
+   * Get the fallback commit message
+   * @returns {string}
+   */
+  getMessage() {
+    throw new Error(`${this.constructor.name} must implement getMessage()`);
+  }
+
+  /**
+   * Get strategy name (for debugging)
+   * @returns {string}
+   */
+  getName() {
+    return this.constructor.name;
+  }
+}

package/lib/fallback/delete-files-strategy.mjs

@@ -0,0 +1,15 @@
+/**
+ * Delete Files Strategy - Handles when files are deleted
+ */
+
+import { BaseFallbackStrategy } from './base-fallback-strategy.mjs';
+
+export class DeleteFilesStrategy extends BaseFallbackStrategy {
+  canHandle({ deleted }) {
+    return deleted > 0;
+  }
+
+  getMessage() {
+    return 'chore: remove files';
+  }
+}

package/lib/fallback/fallback-resolver.mjs

@@ -0,0 +1,54 @@
+/**
+ * Fallback Resolver - Coordinates fallback strategies
+ * Uses Strategy Pattern to select appropriate message
+ */
+
+import { AddFilesStrategy } from './add-files-strategy.mjs';
+import { ModifyFilesStrategy } from './modify-files-strategy.mjs';
+import { DeleteFilesStrategy } from './delete-files-strategy.mjs';
+
+export class FallbackResolver {
+  constructor() {
+    // Order matters: more specific strategies first
+    this.strategies = [
+      new AddFilesStrategy(),
+      new DeleteFilesStrategy(),
+      new ModifyFilesStrategy(),
+    ];
+    this.defaultMessage = 'chore: update';
+  }
+
+  /**
+   * Resolve the appropriate fallback message based on file stats
+   * @param {Object} stats - File change statistics
+   * @param {number} stats.added - Number of added files
+   * @param {number} stats.modified - Number of modified files
+   * @param {number} stats.deleted - Number of deleted files
+   * @returns {string} - The fallback commit message
+   */
+  resolve(stats) {
+    for (const strategy of this.strategies) {
+      if (strategy.canHandle(stats)) {
+        return strategy.getMessage();
+      }
+    }
+    
+    return this.defaultMessage;
+  }
+
+  /**
+   * Add a custom strategy
+   * @param {BaseFallbackStrategy} strategy - Strategy to add
+   */
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+
+  /**
+   * Set default message for when no strategy matches
+   * @param {string} message - Default message
+   */
+  setDefaultMessage(message) {
+    this.defaultMessage = message;
+  }
+}

package/lib/fallback/modify-files-strategy.mjs

@@ -0,0 +1,15 @@
+/**
+ * Modify Files Strategy - Handles when files are modified
+ */
+
+import { BaseFallbackStrategy } from './base-fallback-strategy.mjs';
+
+export class ModifyFilesStrategy extends BaseFallbackStrategy {
+  canHandle({ modified }) {
+    return modified > 0;
+  }
+
+  getMessage() {
+    return 'refactor: update code';
+  }
+}

package/lib/providers/anthropic-provider.mjs

@@ -0,0 +1,44 @@
+/**
+ * Anthropic AI Provider implementation
+ */
+
+import { BaseAIProvider } from './base-provider.mjs';
+import { ApiKeyAuthStrategy } from '../auth/auth-strategy.mjs';
+
+export class AnthropicProvider extends BaseAIProvider {
+  constructor(config) {
+    // Use API Key authentication strategy
+    const authStrategy = new ApiKeyAuthStrategy(config, {
+      keyName: 'anthropicKey',
+      headerName: 'x-api-key',
+      headerFormat: '{key}',
+    });
+    super(config, authStrategy);
+  }
+
+  async generate(prompt) {
+    // Get auth headers from strategy
+    const authHeaders = await this.authStrategy.getAuthHeaders();
+
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...authHeaders,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model: this.config.aiModel || 'claude-sonnet-4-20250514',
+        max_tokens: 200,
+        messages: [{ role: 'user', content: prompt }],
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Anthropic error: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data.content[0].text.trim().replace(/^["']|["']$/g, '');
+  }
+}