clevermation-cli 0.3.2

package/src/commands/auth.ts

@@ -0,0 +1,302 @@
+import { Command } from 'commander';
+import { select, confirm, input, password } from '@inquirer/prompts';
+import { execa } from 'execa';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import {
+  checkGitHubAuth,
+  checkSupabaseAuth,
+} from '../utils/prerequisites.js';
+import { loadGlobalConfig, saveGlobalConfig } from '../utils/config.js';
+
+type ServiceType = 'github' | 'supabase' | 'n8n' | 'elevenlabs' | 'all';
+
+export function createAuthCommand(): Command {
+  const cmd = new Command('auth').description('Authentifizierung für Services verwalten');
+
+  cmd
+    .command('status')
+    .description('Zeige Auth-Status aller Services')
+    .action(async () => {
+      await showAuthStatus();
+    });
+
+  cmd
+    .command('login [service]')
+    .description('Bei einem Service anmelden')
+    .action(async (service?: string) => {
+      await loginService(service as ServiceType);
+    });
+
+  cmd
+    .command('logout [service]')
+    .description('Von einem Service abmelden')
+    .action(async (service?: string) => {
+      await logoutService(service as ServiceType);
+    });
+
+  // Default action wenn nur `cl auth` aufgerufen wird
+  cmd.action(async () => {
+    await showAuthStatus();
+  });
+
+  return cmd;
+}
+
+async function showAuthStatus(): Promise<void> {
+  logger.title('Authentifizierung');
+
+  const spinner = ora('Prüfe Auth-Status...').start();
+
+  // GitHub
+  const ghAuth = await checkGitHubAuth();
+
+  // Supabase
+  const supabaseAuth = await checkSupabaseAuth();
+
+  // N8N & ElevenLabs aus Config
+  const config = await loadGlobalConfig();
+
+  spinner.stop();
+
+  console.log(chalk.bold('  Services:\n'));
+
+  // GitHub
+  if (ghAuth.authenticated) {
+    console.log(chalk.green('  ✓'), 'GitHub', chalk.dim(`(@${ghAuth.username})`));
+  } else {
+    console.log(chalk.red('  ✗'), 'GitHub', chalk.dim('(nicht angemeldet)'));
+  }
+
+  // Supabase
+  if (supabaseAuth) {
+    console.log(chalk.green('  ✓'), 'Supabase');
+  } else {
+    console.log(chalk.yellow('  ○'), 'Supabase', chalk.dim('(nicht angemeldet)'));
+  }
+
+  // N8N
+  if (config?.auth?.n8n?.apiKey) {
+    console.log(chalk.green('  ✓'), 'N8N', chalk.dim(`(${config.auth.n8n.url})`));
+  } else {
+    console.log(chalk.yellow('  ○'), 'N8N', chalk.dim('(nicht konfiguriert)'));
+  }
+
+  // ElevenLabs
+  if (config?.auth?.elevenlabs?.apiKey) {
+    console.log(chalk.green('  ✓'), 'ElevenLabs');
+  } else {
+    console.log(chalk.yellow('  ○'), 'ElevenLabs', chalk.dim('(nicht konfiguriert)'));
+  }
+
+  logger.blank();
+  console.log(chalk.dim('  Anmelden: cl auth login <service>'));
+  console.log(chalk.dim('  Services: github, supabase, n8n, elevenlabs, all'));
+  logger.blank();
+}
+
+async function loginService(service?: ServiceType): Promise<void> {
+  // Wenn kein Service angegeben, fragen
+  const selectedService =
+    service ||
+    ((await select({
+      message: 'Bei welchem Service anmelden?',
+      choices: [
+        { name: 'Alle Services', value: 'all' },
+        { name: 'GitHub', value: 'github' },
+        { name: 'Supabase', value: 'supabase' },
+        { name: 'N8N', value: 'n8n' },
+        { name: 'ElevenLabs', value: 'elevenlabs' },
+      ],
+    })) as ServiceType);
+
+  if (selectedService === 'all') {
+    await loginGitHub();
+    await loginSupabase();
+    await loginN8N();
+    await loginElevenLabs();
+  } else {
+    switch (selectedService) {
+      case 'github':
+        await loginGitHub();
+        break;
+      case 'supabase':
+        await loginSupabase();
+        break;
+      case 'n8n':
+        await loginN8N();
+        break;
+      case 'elevenlabs':
+        await loginElevenLabs();
+        break;
+    }
+  }
+}
+
+async function loginGitHub(): Promise<void> {
+  logger.info('GitHub Login');
+
+  const ghAuth = await checkGitHubAuth();
+  if (ghAuth.authenticated) {
+    logger.success(`Bereits angemeldet als @${ghAuth.username}`);
+
+    const reauth = await confirm({
+      message: 'Erneut anmelden?',
+      default: false,
+    });
+
+    if (!reauth) return;
+  }
+
+  try {
+    await execa('gh', ['auth', 'login', '--web'], { stdio: 'inherit' });
+
+    // Setup git für GitHub Packages
+    await execa('gh', ['auth', 'setup-git']);
+
+    logger.success('GitHub Login erfolgreich');
+  } catch {
+    logger.error('GitHub Login fehlgeschlagen');
+  }
+}
+
+async function loginSupabase(): Promise<void> {
+  logger.info('Supabase Login');
+
+  // Prüfe ob Supabase CLI installiert
+  try {
+    await execa('supabase', ['--version']);
+  } catch {
+    logger.warning('Supabase CLI nicht installiert');
+    logger.dim('  Installieren: brew install supabase/tap/supabase');
+    return;
+  }
+
+  try {
+    await execa('supabase', ['login'], { stdio: 'inherit' });
+    logger.success('Supabase Login erfolgreich');
+  } catch {
+    logger.error('Supabase Login fehlgeschlagen');
+  }
+}
+
+async function loginN8N(): Promise<void> {
+  logger.info('N8N Konfiguration');
+
+  const url = await input({
+    message: 'N8N Instance URL',
+    default: 'https://n8n.clevermation.com',
+    validate: (v) => v.startsWith('http') || 'Muss eine gültige URL sein',
+  });
+
+  const apiKey = await password({
+    message: 'N8N API Key',
+    validate: (v) => v.length > 0 || 'API Key erforderlich',
+  });
+
+  // Validiere Credentials
+  const spinner = ora('Validiere N8N Credentials...').start();
+
+  try {
+    const response = await fetch(`${url}/api/v1/workflows`, {
+      headers: { 'X-N8N-API-KEY': apiKey },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (response.ok) {
+      spinner.succeed('N8N Credentials gültig');
+
+      // Speichere in Config
+      const config = (await loadGlobalConfig()) || {
+        version: '1.0.0',
+        auth: {},
+        preferences: {},
+      };
+
+      config.auth = config.auth || {};
+      config.auth.n8n = { url, apiKey };
+
+      await saveGlobalConfig(config);
+      logger.success('N8N konfiguriert');
+    } else {
+      spinner.fail('Ungültige N8N Credentials');
+    }
+  } catch {
+    spinner.fail('Verbindung zu N8N fehlgeschlagen');
+  }
+}
+
+async function loginElevenLabs(): Promise<void> {
+  logger.info('ElevenLabs Konfiguration');
+
+  const apiKey = await password({
+    message: 'ElevenLabs API Key',
+    validate: (v) => v.length > 0 || 'API Key erforderlich',
+  });
+
+  // Validiere API Key
+  const spinner = ora('Validiere ElevenLabs API Key...').start();
+
+  try {
+    const response = await fetch('https://api.elevenlabs.io/v1/user', {
+      headers: { 'xi-api-key': apiKey },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (response.ok) {
+      spinner.succeed('ElevenLabs API Key gültig');
+
+      // Speichere in Config
+      const config = (await loadGlobalConfig()) || {
+        version: '1.0.0',
+        auth: {},
+        preferences: {},
+      };
+
+      config.auth = config.auth || {};
+      config.auth.elevenlabs = { apiKey };
+
+      await saveGlobalConfig(config);
+      logger.success('ElevenLabs konfiguriert');
+    } else {
+      spinner.fail('Ungültiger ElevenLabs API Key');
+    }
+  } catch {
+    spinner.fail('Validierung fehlgeschlagen');
+  }
+}
+
+async function logoutService(service?: ServiceType): Promise<void> {
+  const selectedService =
+    service ||
+    ((await select({
+      message: 'Von welchem Service abmelden?',
+      choices: [
+        { name: 'GitHub', value: 'github' },
+        { name: 'Supabase', value: 'supabase' },
+        { name: 'N8N', value: 'n8n' },
+        { name: 'ElevenLabs', value: 'elevenlabs' },
+      ],
+    })) as ServiceType);
+
+  switch (selectedService) {
+    case 'github':
+      await execa('gh', ['auth', 'logout'], { stdio: 'inherit' });
+      break;
+    case 'supabase':
+      // Supabase hat kein logout command
+      logger.info('Supabase: Lösche Token manuell in ~/.supabase');
+      break;
+    case 'n8n':
+    case 'elevenlabs': {
+      const config = await loadGlobalConfig();
+      if (config?.auth) {
+        delete config.auth[selectedService];
+        await saveGlobalConfig(config);
+        logger.success(`${selectedService} Credentials entfernt`);
+      }
+      break;
+    }
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,174 @@
+import { Command } from 'commander';
+import { select, input, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import {
+  loadProjectConfig,
+  loadGlobalConfig,
+  saveGlobalConfig,
+} from '../utils/config.js';
+
+export function createConfigCommand(): Command {
+  const cmd = new Command('config').description(
+    'Zeige und bearbeite Projektkonfiguration'
+  );
+
+  cmd
+    .command('show')
+    .description('Zeige aktuelle Konfiguration')
+    .action(async () => {
+      await showConfig();
+    });
+
+  cmd
+    .command('auth')
+    .description('Verwalte Service-Authentifizierung')
+    .action(async () => {
+      await manageAuth();
+    });
+
+  // Default: show
+  cmd.action(async () => {
+    await showConfig();
+  });
+
+  return cmd;
+}
+
+async function showConfig() {
+  const projectConfig = await loadProjectConfig();
+  const globalConfig = await loadGlobalConfig();
+
+  logger.title('Konfiguration');
+
+  if (projectConfig) {
+    logger.info('Projekt:');
+    logger.dim(`  Name: ${projectConfig.project.name}`);
+    logger.dim(`  Typ: ${projectConfig.project.type}`);
+    if (projectConfig.project.customer) {
+      logger.dim(`  Kunde: ${projectConfig.project.customer}`);
+    }
+    logger.dim(`  Repo: ${projectConfig.services.github.org}/${projectConfig.services.github.repo}`);
+    logger.blank();
+
+    logger.info('Services:');
+    logger.dim(`  GitHub: ✓ aktiviert`);
+    logger.dim(
+      `  Supabase: ${projectConfig.services.supabase?.enabled ? '✓ aktiviert' : '✗ deaktiviert'}`
+    );
+    logger.dim(
+      `  N8N: ${projectConfig.services.n8n?.enabled ? '✓ aktiviert' : '✗ deaktiviert'}`
+    );
+    logger.dim(
+      `  ElevenLabs: ${projectConfig.services.elevenlabs?.enabled ? '✓ aktiviert' : '✗ deaktiviert'}`
+    );
+    logger.blank();
+
+    logger.info('Claude Code:');
+    logger.dim(`  Model: ${projectConfig.claudeCode.model}`);
+    logger.dim(`  Plugins: ${projectConfig.claudeCode.plugins.join(', ')}`);
+  } else {
+    logger.warning('Kein Projekt gefunden. Führe "cl init" aus.');
+  }
+
+  logger.blank();
+  logger.info('Global:');
+  logger.dim(`  Standard Model: ${globalConfig.preferences.defaultModel}`);
+  logger.dim(`  Auto-Update: ${globalConfig.preferences.autoUpdate ? 'Ja' : 'Nein'}`);
+  logger.blank();
+}
+
+async function manageAuth() {
+  logger.title('Service Authentifizierung');
+
+  const service = await select({
+    message: 'Wähle Service zur Konfiguration',
+    choices: [
+      { name: 'N8N', value: 'n8n' },
+      { name: 'ElevenLabs', value: 'elevenlabs' },
+      { name: 'Supabase (via CLI)', value: 'supabase' },
+      { name: 'GitHub (via CLI)', value: 'github' },
+    ],
+  });
+
+  const globalConfig = await loadGlobalConfig();
+
+  switch (service) {
+    case 'n8n':
+      await authN8n(globalConfig);
+      break;
+    case 'elevenlabs':
+      await authElevenLabs(globalConfig);
+      break;
+    case 'supabase':
+      logger.info('Supabase verwendet die Supabase CLI zur Authentifizierung.');
+      logger.dim('  Führe aus: supabase login');
+      break;
+    case 'github':
+      logger.info('GitHub verwendet die GitHub CLI zur Authentifizierung.');
+      logger.dim('  Führe aus: gh auth login');
+      break;
+  }
+}
+
+async function authN8n(globalConfig: Awaited<ReturnType<typeof loadGlobalConfig>>) {
+  const url = await input({
+    message: 'N8N Instance URL',
+    default: globalConfig.auth.n8n?.url || 'https://n8n.clevermation.com',
+    validate: (v) => v.startsWith('http') || 'Muss eine gültige URL sein',
+  });
+
+  const apiKey = await input({
+    message: 'N8N API Key',
+    validate: (v) => v.length > 0 || 'API Key erforderlich',
+  });
+
+  // API Key validieren
+  logger.info('Validiere N8N Credentials...');
+  try {
+    const response = await fetch(`${url}/api/v1/workflows`, {
+      headers: { 'X-N8N-API-KEY': apiKey },
+    });
+
+    if (response.ok) {
+      logger.success('N8N Credentials gültig!');
+
+      // Speichern
+      globalConfig.auth.n8n = { url, apiKey };
+      await saveGlobalConfig(globalConfig);
+      logger.success('Credentials gespeichert.');
+    } else {
+      logger.error('Ungültige N8N Credentials.');
+    }
+  } catch {
+    logger.error('Verbindung zu N8N fehlgeschlagen.');
+  }
+}
+
+async function authElevenLabs(globalConfig: Awaited<ReturnType<typeof loadGlobalConfig>>) {
+  const apiKey = await input({
+    message: 'ElevenLabs API Key',
+    validate: (v) => v.length > 0 || 'API Key erforderlich',
+  });
+
+  // API Key validieren
+  logger.info('Validiere ElevenLabs API Key...');
+  try {
+    const response = await fetch('https://api.elevenlabs.io/v1/user', {
+      headers: { 'xi-api-key': apiKey },
+    });
+
+    if (response.ok) {
+      logger.success('ElevenLabs API Key gültig!');
+
+      // Speichern
+      globalConfig.auth.elevenlabs = { apiKey };
+      await saveGlobalConfig(globalConfig);
+      logger.success('API Key gespeichert.');
+    } else {
+      logger.error('Ungültiger ElevenLabs API Key.');
+    }
+  } catch {
+    logger.error('Validierung fehlgeschlagen.');
+  }
+}

package/src/commands/doctor.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { showPrerequisiteStatus } from '../utils/prerequisites.js';
+import { logger } from '../utils/logger.js';
+
+export function createDoctorCommand(): Command {
+  return new Command('doctor')
+    .description('Prüfe System-Voraussetzungen und zeige Probleme')
+    .action(async () => {
+      await showPrerequisiteStatus();
+
+      logger.blank();
+      logger.dim('  Bei Problemen: cl auth login');
+      logger.blank();
+    });
+}

package/src/commands/explain.ts

@@ -0,0 +1,113 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from '../utils/logger.js';
+import { loadProjectConfig } from '../utils/config.js';
+
+interface ExplainOptions {
+  verbose?: boolean;
+}
+
+export function createExplainCommand(): Command {
+  return new Command('explain')
+    .description('Erkläre die aktuelle Projektstruktur')
+    .option('-v, --verbose', 'Zeige detaillierte Erklärung')
+    .action(async (options: ExplainOptions) => {
+      await explainProject(options.verbose ?? false);
+    });
+}
+
+async function explainProject(verbose: boolean) {
+  const config = await loadProjectConfig();
+
+  logger.title('Projekt Übersicht');
+
+  if (!config) {
+    logger.error('Kein Clevermation Projekt gefunden.');
+    logger.info('Führe "cl init" aus, um ein Projekt zu erstellen.');
+    return;
+  }
+
+  // Basis-Info
+  logger.info('Projekt:');
+  logger.dim(`  Name: ${config.project.name}`);
+  logger.dim(
+    `  Typ: ${config.project.type === 'customer' ? 'Kundenprojekt' : 'Internes Projekt'}`
+  );
+  if (config.project.customer) {
+    logger.dim(`  Kunde: ${config.project.customer}`);
+  }
+  logger.blank();
+
+  // GitHub
+  logger.info('GitHub:');
+  logger.dim(`  Repository: ${config.services.github.org}/${config.services.github.repo}`);
+  logger.dim(`  Sichtbarkeit: Privat`);
+  logger.blank();
+
+  // Services
+  const enabledServices: string[] = ['GitHub'];
+  if (config.services.supabase?.enabled) enabledServices.push('Supabase');
+  if (config.services.n8n?.enabled) enabledServices.push('N8N');
+  if (config.services.elevenlabs?.enabled) enabledServices.push('ElevenLabs');
+
+  logger.info('Aktivierte Services:');
+  for (const service of enabledServices) {
+    logger.dim(`  • ${service}`);
+  }
+  logger.blank();
+
+  // Claude Code
+  logger.info('Claude Code:');
+  logger.dim(`  Standard Model: ${config.claudeCode.model}`);
+  logger.dim(`  Marketplace: ${config.claudeCode.marketplace}`);
+  logger.blank();
+
+  logger.info('Installierte Plugins:');
+  for (const plugin of config.claudeCode.plugins) {
+    logger.dim(`  • ${plugin}`);
+  }
+  logger.blank();
+
+  // Verbose: Verzeichnisstruktur
+  if (verbose) {
+    logger.info('Verzeichnisstruktur:');
+    await showDirectoryTree();
+    logger.blank();
+  }
+
+  // Timestamps
+  logger.dim(`Erstellt: ${new Date(config.createdAt).toLocaleDateString('de-DE')}`);
+  logger.dim(`Aktualisiert: ${new Date(config.updatedAt).toLocaleDateString('de-DE')}`);
+  logger.blank();
+}
+
+async function showDirectoryTree(dir: string = '.', prefix: string = '  '): Promise<void> {
+  const ignoreDirs = ['node_modules', '.git', 'dist', '.bun'];
+
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const filteredEntries = entries.filter((e) => !ignoreDirs.includes(e.name));
+
+    for (let i = 0; i < filteredEntries.length; i++) {
+      const entry = filteredEntries[i];
+      if (!entry) continue;
+
+      const isLast = i === filteredEntries.length - 1;
+      const connector = isLast ? '└── ' : '├── ';
+
+      if (entry.isDirectory()) {
+        console.log(chalk.dim(`${prefix}${connector}${chalk.blue(entry.name)}/`));
+        await showDirectoryTree(
+          path.join(dir, entry.name),
+          prefix + (isLast ? '    ' : '│   ')
+        );
+      } else {
+        console.log(chalk.dim(`${prefix}${connector}${entry.name}`));
+      }
+    }
+  } catch {
+    // Ignoriere Fehler
+  }
+}