clevermation-cli 0.3.2

package/src/utils/prerequisites.ts

@@ -0,0 +1,228 @@
+import { execa } from 'execa';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from './logger.js';
+
+interface Prerequisite {
+  name: string;
+  command: string;
+  versionFlag: string;
+  installCommand?: string;
+  installMessage?: string;
+  optional?: boolean;
+}
+
+const PREREQUISITES: Prerequisite[] = [
+  {
+    name: 'Bun',
+    command: 'bun',
+    versionFlag: '--version',
+    installCommand: 'curl -fsSL https://bun.sh/install | bash',
+    installMessage: 'Installiere Bun...',
+  },
+  {
+    name: 'Git',
+    command: 'git',
+    versionFlag: '--version',
+    installCommand: 'brew install git',
+    installMessage: 'Installiere Git...',
+  },
+  {
+    name: 'GitHub CLI',
+    command: 'gh',
+    versionFlag: '--version',
+    installCommand: 'brew install gh',
+    installMessage: 'Installiere GitHub CLI...',
+  },
+  {
+    name: 'Claude Code',
+    command: 'claude',
+    versionFlag: '--version',
+    installCommand: 'brew install claude',
+    installMessage: 'Installiere Claude Code...',
+    optional: true,
+  },
+  {
+    name: 'Supabase CLI',
+    command: 'supabase',
+    versionFlag: '--version',
+    installCommand: 'brew install supabase/tap/supabase',
+    installMessage: 'Installiere Supabase CLI...',
+    optional: true,
+  },
+];
+
+interface CheckResult {
+  name: string;
+  installed: boolean;
+  version?: string;
+  optional: boolean;
+}
+
+/**
+ * Prüft alle Voraussetzungen und installiert fehlende automatisch.
+ * Läuft still im Hintergrund - User merkt nichts außer bei Fehlern.
+ */
+export async function ensurePrerequisites(options?: {
+  verbose?: boolean;
+  requiredOnly?: boolean;
+  autoInstall?: boolean;
+}): Promise<CheckResult[]> {
+  const { verbose = false, requiredOnly = false, autoInstall = true } = options || {};
+  const results: CheckResult[] = [];
+
+  const prereqs = requiredOnly
+    ? PREREQUISITES.filter((p) => !p.optional)
+    : PREREQUISITES;
+
+  for (const prereq of prereqs) {
+    const result = await checkPrerequisite(prereq);
+    results.push(result);
+
+    // Auto-Install wenn nicht vorhanden und nicht optional
+    if (!result.installed && autoInstall && prereq.installCommand && !prereq.optional) {
+      await installPrerequisite(prereq, verbose);
+      // Erneut prüfen
+      const recheck = await checkPrerequisite(prereq);
+      results[results.length - 1] = recheck;
+    }
+  }
+
+  return results;
+}
+
+async function checkPrerequisite(prereq: Prerequisite): Promise<CheckResult> {
+  try {
+    const { stdout } = await execa(prereq.command, [prereq.versionFlag], {
+      timeout: 5000,
+      reject: false,
+    });
+
+    // Version extrahieren (erstes Match von Zahlen mit Punkten)
+    const versionMatch = stdout.match(/\d+\.\d+(\.\d+)?/);
+    const version = versionMatch ? versionMatch[0] : undefined;
+
+    return {
+      name: prereq.name,
+      installed: true,
+      version,
+      optional: prereq.optional || false,
+    };
+  } catch {
+    return {
+      name: prereq.name,
+      installed: false,
+      optional: prereq.optional || false,
+    };
+  }
+}
+
+async function installPrerequisite(prereq: Prerequisite, verbose: boolean): Promise<boolean> {
+  if (!prereq.installCommand) return false;
+
+  const spinner = verbose
+    ? ora(prereq.installMessage || `Installiere ${prereq.name}...`).start()
+    : null;
+
+  try {
+    // Führe Install-Command aus
+    await execa('sh', ['-c', prereq.installCommand], {
+      timeout: 120000, // 2 Minuten Timeout
+      stdio: verbose ? 'inherit' : 'pipe',
+    });
+
+    spinner?.succeed(`${prereq.name} installiert`);
+    return true;
+  } catch (error) {
+    spinner?.fail(`${prereq.name} Installation fehlgeschlagen`);
+    return false;
+  }
+}
+
+/**
+ * Zeigt den Status aller Voraussetzungen an (für cl doctor).
+ */
+export async function showPrerequisiteStatus(): Promise<void> {
+  logger.title('System-Check');
+
+  const results = await ensurePrerequisites({ autoInstall: false });
+
+  for (const result of results) {
+    if (result.installed) {
+      const version = result.version ? chalk.dim(` v${result.version}`) : '';
+      console.log(chalk.green('  ✓'), result.name + version);
+    } else if (result.optional) {
+      console.log(chalk.yellow('  ○'), result.name, chalk.dim('(optional, nicht installiert)'));
+    } else {
+      console.log(chalk.red('  ✗'), result.name, chalk.dim('(nicht installiert)'));
+    }
+  }
+
+  logger.blank();
+
+  // GitHub Auth Status prüfen
+  const ghAuthStatus = await checkGitHubAuth();
+  if (ghAuthStatus.authenticated) {
+    console.log(chalk.green('  ✓'), `GitHub authentifiziert als ${ghAuthStatus.username}`);
+  } else {
+    console.log(chalk.red('  ✗'), 'GitHub nicht authentifiziert');
+    console.log(chalk.dim('    → gh auth login'));
+  }
+
+  // Supabase Auth Status prüfen
+  const supabaseAuthStatus = await checkSupabaseAuth();
+  if (supabaseAuthStatus) {
+    console.log(chalk.green('  ✓'), 'Supabase authentifiziert');
+  } else {
+    console.log(chalk.yellow('  ○'), 'Supabase nicht authentifiziert', chalk.dim('(optional)'));
+  }
+
+  logger.blank();
+}
+
+/**
+ * Prüft GitHub Authentifizierung.
+ */
+export async function checkGitHubAuth(): Promise<{ authenticated: boolean; username?: string }> {
+  try {
+    const { stdout } = await execa('gh', ['auth', 'status'], { reject: false });
+    const usernameMatch = stdout.match(/Logged in to .+ account (\w+)/);
+    return {
+      authenticated: stdout.includes('Logged in'),
+      username: usernameMatch?.[1],
+    };
+  } catch {
+    return { authenticated: false };
+  }
+}
+
+/**
+ * Prüft Supabase Authentifizierung.
+ */
+export async function checkSupabaseAuth(): Promise<boolean> {
+  try {
+    const result = await execa('supabase', ['projects', 'list'], {
+      timeout: 10000,
+      reject: false,
+    });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Stille Hintergrund-Prüfung beim CLI-Start.
+ * Installiert fehlende Required-Tools automatisch.
+ */
+export async function silentPrerequisiteCheck(): Promise<void> {
+  try {
+    await ensurePrerequisites({
+      verbose: false,
+      requiredOnly: true,
+      autoInstall: true,
+    });
+  } catch {
+    // Fehler ignorieren - soll CLI nicht blockieren
+  }
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}