clevermation-cli 0.3.2

package/src/commands/init.ts

@@ -0,0 +1,429 @@
+import { Command } from 'commander';
+import { input, select, checkbox, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { execa } from 'execa';
+import { logger } from '../utils/logger.js';
+import { saveProjectConfig, getProjectConfigDir, loadGlobalConfig } from '../utils/config.js';
+import type {
+  ProjectConfig,
+  ServiceType,
+  ProjectType,
+  ModelType,
+} from '../types/config.js';
+
+interface InitOptions {
+  name?: string;
+  customer?: string;
+  yes?: boolean;
+}
+
+export function createInitCommand(): Command {
+  return new Command('init')
+    .description('Initialisiere ein neues Clevermation Projekt')
+    .option('-n, --name <name>', 'Projektname')
+    .option('-c, --customer <customer>', 'Kundenname (für Kundenprojekte)')
+    .option('-y, --yes', 'Alle Defaults akzeptieren')
+    .action(async (options: InitOptions) => {
+      await runInit(options);
+    });
+}
+
+async function runInit(options: InitOptions) {
+  logger.title('Clevermation Project Setup');
+
+  // Prüfen ob bereits ein Projekt existiert
+  if (await fs.pathExists(getProjectConfigDir())) {
+    logger.warning('Es existiert bereits ein Clevermation Projekt in diesem Verzeichnis.');
+    const overwrite = await confirm({
+      message: 'Möchtest du die Konfiguration überschreiben?',
+      default: false,
+    });
+    if (!overwrite) {
+      logger.info('Setup abgebrochen.');
+      return;
+    }
+  }
+
+  // Step 1: Projekt-Typ
+  const projectType = (await select({
+    message: 'Projekt-Typ',
+    choices: [
+      { name: 'Kundenprojekt (kunde-projekt)', value: 'customer' },
+      { name: 'Internes Projekt (clevermation-name)', value: 'internal' },
+    ],
+  })) as ProjectType;
+
+  // Step 2: Projektname
+  const projectName =
+    options.name ||
+    (await input({
+      message: 'Projektname',
+      validate: (v) =>
+        /^[a-z0-9-]+$/.test(v) ||
+        'Nur Kleinbuchstaben, Zahlen und Bindestriche erlaubt',
+    }));
+
+  // Step 3: Kundenname (falls Kundenprojekt)
+  let customerName: string | undefined;
+  if (projectType === 'customer') {
+    customerName =
+      options.customer ||
+      (await input({
+        message: 'Kundenname',
+        validate: (v) =>
+          /^[a-z0-9-]+$/.test(v) ||
+          'Nur Kleinbuchstaben, Zahlen und Bindestriche erlaubt',
+      }));
+  }
+
+  // Step 4: Services auswählen (Checkboxen)
+  const services = (await checkbox({
+    message: 'Wähle die Services für dein Projekt',
+    choices: [
+      { name: 'Supabase (Datenbank, Auth, Storage)', value: 'supabase' },
+      { name: 'N8N (Workflow Automation)', value: 'n8n' },
+      { name: 'ElevenLabs (Voice AI)', value: 'elevenlabs' },
+    ],
+  })) as ServiceType[];
+
+  // Step 5: Claude Model
+  const modelPreference = (await select({
+    message: 'Standard Claude Model für dieses Projekt',
+    choices: [
+      { name: 'Opus - Höchste Qualität, komplexe Tasks', value: 'opus' },
+      { name: 'Sonnet - Ausgewogen (empfohlen)', value: 'sonnet' },
+      { name: 'Haiku - Schnell und kostengünstig', value: 'haiku' },
+    ],
+    default: 'sonnet',
+  })) as ModelType;
+
+  // Step 6: Optimale Einstellungen
+  // Prüfe ob in globaler Config default gesetzt ist
+  const globalConfig = await loadGlobalConfig();
+  const defaultOptimal = globalConfig?.preferences?.optimaleEinstellungen ?? true;
+
+  const optimaleEinstellungen = await confirm({
+    message: 'Optimale Projekt-Einstellungen vornehmen?',
+    default: defaultOptimal,
+  });
+
+  // Step 7: Zusammenfassung
+  const repoName =
+    projectType === 'customer'
+      ? `${customerName}-${projectName}`
+      : `clevermation-${projectName}`;
+
+  logger.blank();
+  logger.dim('Setup Zusammenfassung:');
+  logger.dim(`  Repo: Clevermation/${repoName}`);
+  logger.dim(
+    `  Services: GitHub${services.length > 0 ? ', ' + services.join(', ') : ''}`
+  );
+  logger.dim(`  Model: ${modelPreference}`);
+  logger.blank();
+
+  const proceed = await confirm({
+    message: 'Projekt mit diesen Einstellungen erstellen?',
+    default: true,
+  });
+
+  if (!proceed) {
+    logger.warning('Setup abgebrochen.');
+    return;
+  }
+
+  // Step 7: Projekt erstellen
+  const spinner = ora('Erstelle Projektstruktur...').start();
+
+  try {
+    // Verzeichnisse erstellen
+    await createProjectStructure();
+    spinner.text = 'Richte Claude Code Plugins ein...';
+
+    // Claude Code Konfiguration
+    await setupClaudeCode(services, modelPreference);
+
+    // Optimale Einstellungen (wenn gewählt)
+    if (optimaleEinstellungen) {
+      spinner.text = 'Wende optimale Einstellungen an...';
+      await applyOptimalSettings();
+    }
+
+    spinner.text = 'Speichere Projektkonfiguration...';
+
+    // Projekt Config speichern
+    const config: ProjectConfig = {
+      version: '1.0.0',
+      project: {
+        name: projectName,
+        type: projectType,
+        customer: customerName,
+      },
+      services: {
+        github: {
+          enabled: true,
+          repo: repoName,
+          org: 'Clevermation',
+        },
+        supabase: services.includes('supabase')
+          ? { enabled: true }
+          : { enabled: false },
+        n8n: services.includes('n8n') ? { enabled: true } : { enabled: false },
+        elevenlabs: services.includes('elevenlabs')
+          ? { enabled: true }
+          : { enabled: false },
+      },
+      claudeCode: {
+        plugins: getPluginsForServices(services),
+        marketplace: 'Clevermation/clevermation-claude-plugins',
+        model: modelPreference,
+      },
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+
+    await saveProjectConfig(config);
+
+    // Git initialisieren (falls noch nicht vorhanden)
+    if (!(await fs.pathExists('.git'))) {
+      spinner.text = 'Initialisiere Git Repository...';
+      await execa('git', ['init']);
+    }
+
+    spinner.succeed('Projekt erfolgreich erstellt!');
+
+    // Nächste Schritte anzeigen
+    showNextSteps(repoName, services);
+  } catch (error) {
+    spinner.fail('Setup fehlgeschlagen');
+    throw error;
+  }
+}
+
+async function createProjectStructure(): Promise<void> {
+  const dirs = [
+    '.clevermation',
+    '.claude',
+    '.claude/agents',
+    '.claude/skills',
+    '.claude/commands',
+    'src',
+    'docs',
+  ];
+
+  for (const dir of dirs) {
+    await fs.ensureDir(dir);
+  }
+
+  // .gitignore erstellen/erweitern
+  const gitignoreContent = `# Dependencies
+node_modules/
+.bun/
+
+# Build
+dist/
+.output/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Claude Code Local Settings
+.claude/settings.local.json
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+`;
+
+  const gitignorePath = '.gitignore';
+  if (await fs.pathExists(gitignorePath)) {
+    const existing = await fs.readFile(gitignorePath, 'utf-8');
+    if (!existing.includes('.claude/settings.local.json')) {
+      await fs.appendFile(gitignorePath, '\n# Claude Code\n.claude/settings.local.json\n');
+    }
+  } else {
+    await fs.writeFile(gitignorePath, gitignoreContent);
+  }
+}
+
+async function setupClaudeCode(
+  services: ServiceType[],
+  model: ModelType
+): Promise<void> {
+  // .claude/settings.json erstellen
+  const settings = {
+    permissions: {
+      allow: ['Bash(npm*)', 'Bash(bun*)', 'Bash(git*)'],
+      deny: [],
+    },
+    agents: {
+      defaultModel: model,
+    },
+  };
+
+  await fs.writeJson('.claude/settings.json', settings, { spaces: 2 });
+
+  // .claude/settings.local.json Template erstellen
+  const envVars: Record<string, string> = {
+    FIRECRAWL_API_KEY: '',
+  };
+
+  if (services.includes('supabase')) {
+    envVars.SUPABASE_URL = '';
+    envVars.SUPABASE_SECRET_KEY = '';
+    envVars.SUPABASE_PUBLISHABLE_KEY = '';
+  }
+
+  if (services.includes('n8n')) {
+    envVars.N8N_URL = '';
+    envVars.N8N_API_KEY = '';
+  }
+
+  if (services.includes('elevenlabs')) {
+    envVars.ELEVENLABS_API_KEY = '';
+  }
+
+  await fs.writeJson('.claude/settings.local.json', { env: envVars }, { spaces: 2 });
+
+  // .mcp.json erstellen
+  await createMcpConfig(services);
+}
+
+async function createMcpConfig(services: ServiceType[]): Promise<void> {
+  const mcpConfig: Record<string, unknown> = {
+    mcpServers: {
+      // Immer Firecrawl für Recherche
+      firecrawl: {
+        command: 'npx',
+        args: ['-y', 'firecrawl-mcp'],
+        env: { FIRECRAWL_API_KEY: '${FIRECRAWL_API_KEY}' },
+      },
+      // Immer Playwright für Frontend-Tests
+      playwright: {
+        command: 'npx',
+        args: ['-y', '@anthropic/mcp-playwright'],
+      },
+    },
+  };
+
+  const servers = mcpConfig.mcpServers as Record<string, unknown>;
+
+  if (services.includes('supabase')) {
+    servers.supabase = {
+      command: 'npx',
+      args: ['-y', '@supabase/mcp-server-supabase'],
+      env: {
+        SUPABASE_URL: '${SUPABASE_URL}',
+        SUPABASE_SECRET_KEY: '${SUPABASE_SECRET_KEY}',
+      },
+    };
+  }
+
+  if (services.includes('n8n')) {
+    servers['n8n-mcp'] = {
+      command: 'npx',
+      args: ['n8n-mcp'],
+      env: {
+        MCP_MODE: 'stdio',
+        LOG_LEVEL: 'error',
+        DISABLE_CONSOLE_OUTPUT: 'true',
+        N8N_API_URL: '${N8N_URL}',
+        N8N_API_KEY: '${N8N_API_KEY}',
+      },
+    };
+  }
+
+  await fs.writeJson('.mcp.json', mcpConfig, { spaces: 2 });
+}
+
+function getPluginsForServices(services: ServiceType[]): string[] {
+  const plugins = ['researcher', 'plan-agent', 'frontend-test'];
+
+  if (services.includes('supabase')) {
+    plugins.push('supabase-agent');
+  }
+
+  if (services.includes('n8n')) {
+    plugins.push('n8n-agent');
+  }
+
+  return plugins;
+}
+
+function showNextSteps(repoName: string, services: ServiceType[]): void {
+  logger.blank();
+  logger.title('Nächste Schritte');
+
+  logger.info('1. Konfiguriere deine API Keys:');
+  logger.dim('   Bearbeite .claude/settings.local.json');
+  logger.blank();
+
+  if (services.length > 0) {
+    logger.info('2. Authentifiziere dich bei den Services:');
+    if (services.includes('supabase')) {
+      logger.dim('   $ supabase login');
+    }
+    if (services.includes('n8n')) {
+      logger.dim('   $ cl auth login n8n');
+    }
+    logger.blank();
+  }
+
+  logger.info(`${services.length > 0 ? '3' : '2'}. Synchronisiere mit GitHub:`);
+  logger.dim(`   $ cl sync`);
+  logger.dim(`   (Erstellt Clevermation/${repoName})`);
+  logger.blank();
+
+  logger.info(`${services.length > 0 ? '4' : '3'}. Starte Claude Code:`);
+  logger.dim('   $ claude');
+  logger.blank();
+}
+
+/**
+ * Wendet optimale Projekt-Einstellungen an.
+ * Erstellt/aktualisiert globale CLAUDE.md mit Clevermation-Kontext.
+ * TODO: Wird in separater Session mit User definiert.
+ */
+async function applyOptimalSettings(): Promise<void> {
+  const globalClaudeMd = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+
+  // Prüfe ob globale CLAUDE.md bereits existiert
+  const exists = await fs.pathExists(globalClaudeMd);
+
+  if (!exists) {
+    // Erstelle Basis CLAUDE.md (wird später mit User verfeinert)
+    await fs.ensureDir(path.dirname(globalClaudeMd));
+
+    const claudeMdContent = `# Clevermation Entwickler-Kontext
+
+## Unternehmen
+Clevermation - No-Code/Low-Code Automation Agentur
+
+## Package Manager Standards
+- TypeScript/JavaScript: \`bun\` (nicht npm/yarn/pnpm)
+- Python: \`uv\` (nicht pip/poetry)
+
+## Projekt-Konventionen
+- Deutsche Kommentare und Dokumentation
+- TypeScript mit strict mode
+- Formatierung: Prettier (TS/JS), Ruff (Python)
+
+---
+*Erstellt von Clevermation CLI - Weitere Einstellungen folgen*
+`;
+
+    await fs.writeFile(globalClaudeMd, claudeMdContent);
+  }
+}

package/src/commands/open.ts

@@ -0,0 +1,104 @@
+import { Command } from 'commander';
+import { select } from '@inquirer/prompts';
+import { execa } from 'execa';
+import { logger } from '../utils/logger.js';
+import { loadGlobalConfig, saveGlobalConfig } from '../utils/config.js';
+
+type IDE = 'code' | 'cursor' | 'webstorm' | 'zed';
+
+const IDE_COMMANDS: Record<IDE, { command: string; name: string }> = {
+  code: { command: 'code', name: 'VS Code' },
+  cursor: { command: 'cursor', name: 'Cursor' },
+  webstorm: { command: 'webstorm', name: 'WebStorm' },
+  zed: { command: 'zed', name: 'Zed' },
+};
+
+export function createOpenCommand(): Command {
+  const cmd = new Command('open').description('Öffne Projekt in IDE');
+
+  cmd
+    .argument('[path]', 'Pfad zum Öffnen', '.')
+    .option('-i, --ide <ide>', 'IDE (code, cursor, webstorm, zed)')
+    .option('--set-default <ide>', 'Setze Standard-IDE')
+    .action(async (path: string, options: { ide?: string; setDefault?: string }) => {
+      if (options.setDefault) {
+        await setDefaultIDE(options.setDefault as IDE);
+        return;
+      }
+
+      await openInIDE(path, options.ide as IDE | undefined);
+    });
+
+  return cmd;
+}
+
+async function openInIDE(path: string, ide?: IDE): Promise<void> {
+  // IDE ermitteln (Argument > Config > Default)
+  let selectedIDE = ide;
+
+  if (!selectedIDE) {
+    const config = await loadGlobalConfig();
+    selectedIDE = config?.preferences?.defaultIDE as IDE | undefined;
+  }
+
+  // Wenn immer noch keine IDE, VS Code als Default
+  if (!selectedIDE) {
+    selectedIDE = 'code';
+  }
+
+  const ideConfig = IDE_COMMANDS[selectedIDE];
+
+  if (!ideConfig) {
+    logger.error(`Unbekannte IDE: ${selectedIDE}`);
+    logger.dim('  Verfügbar: code, cursor, webstorm, zed');
+    return;
+  }
+
+  // Prüfe ob IDE installiert ist
+  try {
+    await execa('which', [ideConfig.command]);
+  } catch {
+    logger.error(`${ideConfig.name} nicht gefunden`);
+    logger.dim(`  Stelle sicher, dass "${ideConfig.command}" im PATH ist.`);
+
+    // Frage nach Alternative
+    const alternative = (await select({
+      message: 'Alternative IDE wählen?',
+      choices: Object.entries(IDE_COMMANDS).map(([key, value]) => ({
+        name: value.name,
+        value: key,
+      })),
+    })) as IDE;
+
+    selectedIDE = alternative;
+  }
+
+  // Öffne IDE
+  try {
+    const finalConfig = IDE_COMMANDS[selectedIDE];
+    await execa(finalConfig.command, [path], { stdio: 'ignore', detached: true });
+    logger.success(`Geöffnet in ${finalConfig.name}`);
+  } catch (error) {
+    logger.error('Konnte IDE nicht öffnen');
+  }
+}
+
+async function setDefaultIDE(ide: IDE): Promise<void> {
+  if (!IDE_COMMANDS[ide]) {
+    logger.error(`Unbekannte IDE: ${ide}`);
+    logger.dim('  Verfügbar: code, cursor, webstorm, zed');
+    return;
+  }
+
+  const config = (await loadGlobalConfig()) || {
+    version: '1.0.0',
+    auth: {},
+    preferences: {},
+  };
+
+  config.preferences = config.preferences || {};
+  config.preferences.defaultIDE = ide;
+
+  await saveGlobalConfig(config);
+  logger.success(`Standard-IDE: ${IDE_COMMANDS[ide].name}`);
+}

package/src/commands/sync.ts

@@ -0,0 +1,181 @@
+import { Command } from 'commander';
+import { confirm, input } from '@inquirer/prompts';
+import { execa } from 'execa';
+import chalk from 'chalk';
+import ora from 'ora';
+import { logger } from '../utils/logger.js';
+import { loadProjectConfig } from '../utils/config.js';
+
+interface SyncOptions {
+  force?: boolean;
+}
+
+export function createSyncCommand(): Command {
+  return new Command('sync')
+    .description('Synchronisiere Projekt mit GitHub')
+    .option('-f, --force', 'Force push (mit Vorsicht verwenden)')
+    .action(async (options: SyncOptions) => {
+      await runSync(options);
+    });
+}
+
+async function runSync(options: SyncOptions) {
+  logger.title('GitHub Synchronisation');
+
+  // Step 1: Prüfe gh CLI Installation
+  const ghInstalled = await checkGhCli();
+  if (!ghInstalled) {
+    logger.error('GitHub CLI (gh) ist nicht installiert.');
+    logger.info('Installiere mit: brew install gh');
+    return;
+  }
+
+  // Step 2: Prüfe gh Authentifizierung
+  const ghAuthenticated = await checkGhAuth();
+  if (!ghAuthenticated) {
+    logger.warning('GitHub CLI ist nicht authentifiziert.');
+    const authenticate = await confirm({
+      message: 'Möchtest du dich jetzt authentifizieren?',
+      default: true,
+    });
+
+    if (authenticate) {
+      logger.blank();
+      await execa('gh', ['auth', 'login'], { stdio: 'inherit' });
+      logger.blank();
+
+      // Erneut prüfen
+      if (!(await checkGhAuth())) {
+        logger.error('Authentifizierung fehlgeschlagen.');
+        return;
+      }
+    } else {
+      return;
+    }
+  }
+
+  // Step 3: Lade Projekt Config
+  const config = await loadProjectConfig();
+  if (!config) {
+    logger.error('Kein Clevermation Projekt gefunden.');
+    logger.info('Führe zuerst "cl init" aus.');
+    return;
+  }
+
+  const repoName = config.services.github.repo;
+  const org = config.services.github.org;
+  const fullRepoName = `${org}/${repoName}`;
+
+  // Step 4: Prüfe ob Remote existiert
+  const hasRemote = await checkRemoteExists();
+
+  if (!hasRemote) {
+    // Prüfe ob Repo auf GitHub existiert
+    const repoExists = await checkRepoExists(org, repoName);
+
+    if (!repoExists) {
+      // Repo erstellen
+      const createRepo = await confirm({
+        message: `Privates Repository ${fullRepoName} erstellen?`,
+        default: true,
+      });
+
+      if (createRepo) {
+        const spinner = ora('Erstelle Repository...').start();
+        try {
+          await execa('gh', [
+            'repo',
+            'create',
+            fullRepoName,
+            '--private',
+            '--source',
+            '.',
+            '--remote',
+            'origin',
+            '--push',
+          ]);
+          spinner.succeed(`Repository erstellt: ${fullRepoName}`);
+          logger.success('Projekt synchronisiert!');
+          return;
+        } catch (error) {
+          spinner.fail('Repository-Erstellung fehlgeschlagen');
+          throw error;
+        }
+      } else {
+        return;
+      }
+    } else {
+      // Repo existiert, aber kein Remote - Remote hinzufügen
+      const spinner = ora('Füge Remote hinzu...').start();
+      await execa('git', ['remote', 'add', 'origin', `git@github.com:${fullRepoName}.git`]);
+      spinner.succeed('Remote hinzugefügt');
+    }
+  }
+
+  // Step 5: Push zu Remote
+  const spinner = ora('Pushe zu Remote...').start();
+  try {
+    const pushArgs = ['push', '-u', 'origin', 'main'];
+    if (options.force) {
+      pushArgs.push('--force');
+    }
+    await execa('git', pushArgs);
+    spinner.succeed('Mit GitHub synchronisiert!');
+  } catch (error) {
+    spinner.fail('Push fehlgeschlagen');
+
+    // Prüfen ob es an fehlendem Commit liegt
+    const hasCommits = await checkHasCommits();
+    if (!hasCommits) {
+      logger.info('Tipp: Du musst erst einen Commit erstellen.');
+      logger.dim('  git add . && git commit -m "Initial commit"');
+    } else {
+      throw error;
+    }
+  }
+}
+
+async function checkGhCli(): Promise<boolean> {
+  try {
+    await execa('gh', ['--version']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkGhAuth(): Promise<boolean> {
+  try {
+    await execa('gh', ['auth', 'status']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkRemoteExists(): Promise<boolean> {
+  try {
+    const result = await execa('git', ['remote', 'get-url', 'origin']);
+    return result.stdout.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function checkRepoExists(org: string, repo: string): Promise<boolean> {
+  try {
+    await execa('gh', ['repo', 'view', `${org}/${repo}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function checkHasCommits(): Promise<boolean> {
+  try {
+    await execa('git', ['rev-parse', 'HEAD']);
+    return true;
+  } catch {
+    return false;
+  }
+}