clevermation-cli 0.3.2

package/src/commands/update.ts

@@ -0,0 +1,90 @@
+import { Command } from 'commander';
+import { confirm } from '@inquirer/prompts';
+import { execa } from 'execa';
+import ora from 'ora';
+import { logger } from '../utils/logger.js';
+
+interface UpdateOptions {
+  cliOnly?: boolean;
+  pluginsOnly?: boolean;
+}
+
+export function createUpdateCommand(): Command {
+  return new Command('update')
+    .description('Aktualisiere CLI und Plugins')
+    .option('--cli-only', 'Nur CLI aktualisieren')
+    .option('--plugins-only', 'Nur Plugins aktualisieren')
+    .action(async (options: UpdateOptions) => {
+      await runUpdate(options);
+    });
+}
+
+async function runUpdate(options: UpdateOptions) {
+  logger.title('Update');
+
+  // CLI Update
+  if (!options.pluginsOnly) {
+    const spinner = ora('Prüfe auf CLI Updates...').start();
+
+    try {
+      // Aktuelle Version ermitteln
+      const packageJson = await import('../../package.json', {
+        assert: { type: 'json' },
+      });
+      const currentVersion = packageJson.default.version;
+
+      spinner.text = 'Aktualisiere CLI...';
+
+      // Update durchführen
+      await execa('bun', ['update', 'clevermation-cli']);
+
+      spinner.succeed(`CLI aktualisiert (v${currentVersion})`);
+    } catch (error) {
+      spinner.info('CLI Update übersprungen (lokal installiert)');
+    }
+  }
+
+  // Plugin Update
+  if (!options.cliOnly) {
+    const spinner = ora('Aktualisiere Claude Code Plugins...').start();
+
+    try {
+      // Prüfe ob Marketplace installiert ist
+      const marketplacePath = await getMarketplacePath();
+
+      if (marketplacePath) {
+        await execa('git', ['-C', marketplacePath, 'pull', 'origin', 'main']);
+        spinner.succeed('Plugins aktualisiert!');
+      } else {
+        spinner.info('Kein Plugin Marketplace gefunden.');
+        logger.dim('  Führe "cl init" aus, um Plugins zu installieren.');
+      }
+    } catch (error) {
+      spinner.fail('Plugin Update fehlgeschlagen');
+      logger.dim('  Prüfe deine Internetverbindung.');
+    }
+  }
+
+  logger.blank();
+}
+
+async function getMarketplacePath(): Promise<string | null> {
+  // Versuche verschiedene Pfade
+  const possiblePaths = [
+    '.claude/plugins/clevermation-claude-plugins',
+    `${process.env.HOME}/.claude/plugins/clevermation-claude-plugins`,
+  ];
+
+  for (const p of possiblePaths) {
+    try {
+      const fs = await import('fs-extra');
+      if (await fs.default.pathExists(p)) {
+        return p;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return null;
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import { createInitCommand } from './commands/init.js';
+import { createSyncCommand } from './commands/sync.js';
+import { createConfigCommand } from './commands/config.js';
+import { createExplainCommand } from './commands/explain.js';
+import { createUpdateCommand } from './commands/update.js';
+import { createAuthCommand } from './commands/auth.js';
+import { createDoctorCommand } from './commands/doctor.js';
+import { createOpenCommand } from './commands/open.js';
+import { handleError } from './utils/logger.js';
+import { checkForUpdates } from './utils/auto-update.js';
+import { silentPrerequisiteCheck } from './utils/prerequisites.js';
+
+const VERSION = '0.3.2';
+
+const program = new Command();
+
+program
+  .name('cl')
+  .description('Clevermation CLI - Internes Tool für Claude Code Projekte')
+  .version(VERSION);
+
+// Commands registrieren
+program.addCommand(createInitCommand());
+program.addCommand(createSyncCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createAuthCommand());
+program.addCommand(createDoctorCommand());
+program.addCommand(createOpenCommand());
+program.addCommand(createExplainCommand());
+program.addCommand(createUpdateCommand());
+
+// Hintergrund-Tasks (non-blocking)
+Promise.all([
+  // Auto-Update Check
+  checkForUpdates(VERSION),
+  // Prerequisite Check & Auto-Install
+  silentPrerequisiteCheck(),
+]).catch(() => {
+  // Fehler ignorieren - soll CLI nicht blockieren
+});
+
+// Ausführen
+program.parseAsync(process.argv).catch(handleError);

package/src/types/config.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+
+// Globale CLI Konfiguration (~/.clevermation/config.json)
+export const GlobalConfigSchema = z.object({
+  version: z.string(),
+  defaultOrg: z.string().default('Clevermation'),
+  auth: z.object({
+    github: z
+      .object({
+        authenticated: z.boolean(),
+        username: z.string().optional(),
+      })
+      .optional(),
+    supabase: z
+      .object({
+        authenticated: z.boolean(),
+        accessToken: z.string().optional(),
+      })
+      .optional(),
+    n8n: z
+      .object({
+        url: z.string().optional(),
+        apiKey: z.string().optional(),
+      })
+      .optional(),
+    elevenlabs: z
+      .object({
+        apiKey: z.string().optional(),
+      })
+      .optional(),
+  }),
+  preferences: z.object({
+    defaultModel: z.enum(['opus', 'sonnet', 'haiku']).default('sonnet'),
+    defaultIDE: z.enum(['code', 'cursor', 'webstorm', 'zed']).default('code'),
+    autoUpdate: z.boolean().default(true),
+    optimaleEinstellungen: z.boolean().default(true),
+  }),
+});
+
+export type GlobalConfig = z.infer<typeof GlobalConfigSchema>;
+
+// Projekt Konfiguration (.clevermation/config.json)
+export const ProjectConfigSchema = z.object({
+  version: z.string(),
+  project: z.object({
+    name: z.string(),
+    type: z.enum(['customer', 'internal']),
+    customer: z.string().optional(),
+    description: z.string().optional(),
+  }),
+  services: z.object({
+    github: z.object({
+      enabled: z.literal(true),
+      repo: z.string(),
+      org: z.string().default('Clevermation'),
+    }),
+    supabase: z
+      .object({
+        enabled: z.boolean(),
+        projectRef: z.string().optional(),
+        url: z.string().optional(),
+      })
+      .optional(),
+    n8n: z
+      .object({
+        enabled: z.boolean(),
+        instanceUrl: z.string().optional(),
+      })
+      .optional(),
+    elevenlabs: z
+      .object({
+        enabled: z.boolean(),
+      })
+      .optional(),
+  }),
+  claudeCode: z.object({
+    plugins: z.array(z.string()),
+    marketplace: z.string().default('Clevermation/clevermation-claude-plugins'),
+    model: z.enum(['opus', 'sonnet', 'haiku']).default('sonnet'),
+  }),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+
+// Service-Typen für Init
+export type ServiceType = 'supabase' | 'n8n' | 'elevenlabs';
+export type ProjectType = 'customer' | 'internal';
+export type ModelType = 'opus' | 'sonnet' | 'haiku';

package/src/utils/auto-update.ts

@@ -0,0 +1,169 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import semver from 'semver';
+
+const UPDATE_CHECK_FILE = path.join(os.homedir(), '.clevermation', 'last-update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 Stunden
+const PACKAGE_NAME = 'clevermation-cli';
+
+interface UpdateCheckData {
+  lastCheck: number;
+  latestVersion: string | null;
+  notifiedVersion: string | null;
+}
+
+/**
+ * Prüft auf Updates und zeigt eine Benachrichtigung an.
+ * Läuft non-blocking im Hintergrund.
+ */
+export async function checkForUpdates(currentVersion: string): Promise<void> {
+  try {
+    // Prüfe ob wir kürzlich gecheckt haben
+    const checkData = await loadCheckData();
+    const now = Date.now();
+
+    if (checkData.lastCheck && now - checkData.lastCheck < CHECK_INTERVAL_MS) {
+      // Kürzlich gecheckt - zeige cached Ergebnis wenn Update verfügbar
+      if (checkData.latestVersion &&
+          semver.gt(checkData.latestVersion, currentVersion) &&
+          checkData.notifiedVersion !== checkData.latestVersion) {
+        showUpdateNotification(currentVersion, checkData.latestVersion);
+        await saveCheckData({ ...checkData, notifiedVersion: checkData.latestVersion });
+      }
+      return;
+    }
+
+    // Neuer Check (non-blocking)
+    checkForUpdatesAsync(currentVersion, checkData);
+  } catch {
+    // Fehler ignorieren - Update-Check soll CLI nicht blockieren
+  }
+}
+
+async function checkForUpdatesAsync(
+  currentVersion: string,
+  checkData: UpdateCheckData
+): Promise<void> {
+  try {
+    // Versuche Version von npm/GitHub Packages zu holen
+    const latestVersion = await fetchLatestVersion();
+
+    if (latestVersion) {
+      const newCheckData: UpdateCheckData = {
+        lastCheck: Date.now(),
+        latestVersion,
+        notifiedVersion: checkData.notifiedVersion,
+      };
+
+      await saveCheckData(newCheckData);
+
+      if (semver.gt(latestVersion, currentVersion) &&
+          checkData.notifiedVersion !== latestVersion) {
+        showUpdateNotification(currentVersion, latestVersion);
+        await saveCheckData({ ...newCheckData, notifiedVersion: latestVersion });
+      }
+    }
+  } catch {
+    // Fehler ignorieren
+  }
+}
+
+async function fetchLatestVersion(): Promise<string | null> {
+  try {
+    // Versuche über npm view
+    const result = await execa('npm', ['view', PACKAGE_NAME, 'version'], {
+      timeout: 5000,
+      reject: false,
+    });
+
+    if (result.exitCode === 0 && result.stdout) {
+      return result.stdout.trim();
+    }
+
+    // Fallback: GitHub API für Releases
+    const response = await fetch(
+      'https://api.github.com/repos/Clevermation/clevermation-cli/releases/latest',
+      { signal: AbortSignal.timeout(5000) }
+    );
+
+    if (response.ok) {
+      const data = await response.json() as { tag_name: string };
+      return data.tag_name.replace(/^v/, '');
+    }
+  } catch {
+    // Fehler ignorieren
+  }
+
+  return null;
+}
+
+async function loadCheckData(): Promise<UpdateCheckData> {
+  try {
+    if (await fs.pathExists(UPDATE_CHECK_FILE)) {
+      return await fs.readJson(UPDATE_CHECK_FILE);
+    }
+  } catch {
+    // Fehler ignorieren
+  }
+
+  return {
+    lastCheck: 0,
+    latestVersion: null,
+    notifiedVersion: null,
+  };
+}
+
+async function saveCheckData(data: UpdateCheckData): Promise<void> {
+  try {
+    await fs.ensureDir(path.dirname(UPDATE_CHECK_FILE));
+    await fs.writeJson(UPDATE_CHECK_FILE, data);
+  } catch {
+    // Fehler ignorieren
+  }
+}
+
+function showUpdateNotification(currentVersion: string, latestVersion: string): void {
+  const boxWidth = 50;
+  const line = '─'.repeat(boxWidth);
+
+  console.log();
+  console.log(chalk.yellow(`  ╭${line}╮`));
+  console.log(chalk.yellow(`  │${' '.repeat(boxWidth)}│`));
+  console.log(chalk.yellow(`  │${centerText(`Update verfügbar: ${currentVersion} → ${chalk.green(latestVersion)}`, boxWidth)}│`));
+  console.log(chalk.yellow(`  │${' '.repeat(boxWidth)}│`));
+  console.log(chalk.yellow(`  │${centerText('Aktualisiere mit:', boxWidth)}│`));
+  console.log(chalk.yellow(`  │${centerText(chalk.cyan('cl update'), boxWidth)}│`));
+  console.log(chalk.yellow(`  │${' '.repeat(boxWidth)}│`));
+  console.log(chalk.yellow(`  ╰${line}╯`));
+  console.log();
+}
+
+function centerText(text: string, width: number): string {
+  // Entferne ANSI Codes für Längenberechnung
+  const plainText = text.replace(/\x1b\[[0-9;]*m/g, '');
+  const padding = Math.max(0, Math.floor((width - plainText.length) / 2));
+  const rightPadding = width - plainText.length - padding;
+  return ' '.repeat(padding) + text + ' '.repeat(Math.max(0, rightPadding));
+}
+
+/**
+ * Führt ein automatisches Update durch wenn gewünscht.
+ */
+export async function performAutoUpdate(): Promise<boolean> {
+  try {
+    console.log(chalk.blue('  Aktualisiere CLI...'));
+
+    await execa('bun', ['update', PACKAGE_NAME], { stdio: 'inherit' });
+
+    console.log(chalk.green('  ✓ CLI erfolgreich aktualisiert!'));
+    console.log(chalk.dim('    Starte die CLI neu um die neue Version zu nutzen.'));
+
+    return true;
+  } catch {
+    console.log(chalk.red('  ✗ Update fehlgeschlagen'));
+    return false;
+  }
+}

package/src/utils/config.ts

@@ -0,0 +1,85 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import {
+  GlobalConfigSchema,
+  ProjectConfigSchema,
+  type GlobalConfig,
+  type ProjectConfig,
+} from '../types/config.js';
+
+// Pfade
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.clevermation');
+const GLOBAL_CONFIG_PATH = path.join(GLOBAL_CONFIG_DIR, 'config.json');
+const PROJECT_CONFIG_DIR = '.clevermation';
+const PROJECT_CONFIG_PATH = path.join(PROJECT_CONFIG_DIR, 'config.json');
+
+// Default Configs
+const DEFAULT_GLOBAL_CONFIG: GlobalConfig = {
+  version: '1.0.0',
+  defaultOrg: 'Clevermation',
+  auth: {},
+  preferences: {
+    defaultModel: 'sonnet',
+    defaultIDE: 'code',
+    autoUpdate: true,
+    optimaleEinstellungen: true,
+  },
+};
+
+// Globale Config
+export async function loadGlobalConfig(): Promise<GlobalConfig> {
+  try {
+    if (await fs.pathExists(GLOBAL_CONFIG_PATH)) {
+      const data = await fs.readJson(GLOBAL_CONFIG_PATH);
+      return GlobalConfigSchema.parse(data);
+    }
+  } catch {
+    // Falls parsing fehlschlägt, default zurückgeben
+  }
+  return DEFAULT_GLOBAL_CONFIG;
+}
+
+export async function saveGlobalConfig(config: GlobalConfig): Promise<void> {
+  await fs.ensureDir(GLOBAL_CONFIG_DIR);
+  await fs.writeJson(GLOBAL_CONFIG_PATH, config, { spaces: 2 });
+}
+
+export async function updateGlobalConfig(
+  updates: Partial<GlobalConfig>
+): Promise<GlobalConfig> {
+  const current = await loadGlobalConfig();
+  const updated = { ...current, ...updates };
+  await saveGlobalConfig(updated);
+  return updated;
+}
+
+// Projekt Config
+export async function loadProjectConfig(): Promise<ProjectConfig | null> {
+  try {
+    if (await fs.pathExists(PROJECT_CONFIG_PATH)) {
+      const data = await fs.readJson(PROJECT_CONFIG_PATH);
+      return ProjectConfigSchema.parse(data);
+    }
+  } catch {
+    // Falls parsing fehlschlägt
+  }
+  return null;
+}
+
+export async function saveProjectConfig(config: ProjectConfig): Promise<void> {
+  await fs.ensureDir(PROJECT_CONFIG_DIR);
+  await fs.writeJson(PROJECT_CONFIG_PATH, config, { spaces: 2 });
+}
+
+export async function hasProjectConfig(): Promise<boolean> {
+  return fs.pathExists(PROJECT_CONFIG_PATH);
+}
+
+export function getProjectConfigDir(): string {
+  return PROJECT_CONFIG_DIR;
+}
+
+export function getGlobalConfigDir(): string {
+  return GLOBAL_CONFIG_DIR;
+}

package/src/utils/logger.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+
+export const logger = {
+  info: (msg: string) => console.log(chalk.blue('  info'), msg),
+  success: (msg: string) => console.log(chalk.green('  ✓'), msg),
+  warning: (msg: string) => console.log(chalk.yellow('  ⚠'), msg),
+  error: (msg: string) => console.log(chalk.red('  ✗'), msg),
+
+  step: (num: number, total: number, msg: string) => {
+    console.log(chalk.dim(`  [${num}/${total}]`), msg);
+  },
+
+  title: (msg: string) => {
+    console.log(chalk.bold.blue(`\n  ${msg}\n`));
+  },
+
+  dim: (msg: string) => console.log(chalk.dim(`  ${msg}`)),
+
+  blank: () => console.log(''),
+};
+
+export class ClevermationError extends Error {
+  constructor(
+    message: string,
+    public hint?: string,
+    public code?: string
+  ) {
+    super(message);
+    this.name = 'ClevermationError';
+  }
+}
+
+export function handleError(error: unknown): never {
+  if (error instanceof ClevermationError) {
+    logger.error(error.message);
+    if (error.hint) {
+      logger.info(error.hint);
+    }
+  } else if (error instanceof Error) {
+    logger.error(error.message);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  } else {
+    logger.error('Ein unerwarteter Fehler ist aufgetreten');
+  }
+
+  process.exit(1);
+}