@dennisrepa/elevate 1.2.0

package/dist/cli.js

@@ -0,0 +1,3569 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { render } from "ink";
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+function findMonorepoRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if (pkg.workspaces) return dir;
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}
+function loadConfig() {
+  const rootDir = findMonorepoRoot(process.cwd());
+  const configPath = join(rootDir, "elevate.config.json");
+  let file = {};
+  if (existsSync(configPath)) {
+    try {
+      file = JSON.parse(readFileSync(configPath, "utf8"));
+    } catch {
+    }
+  }
+  return {
+    rootDir,
+    author: typeof file.author === "string" ? file.author : void 0,
+    excludeScopes: Array.isArray(file.excludeScopes) ? file.excludeScopes : [],
+    postUpdateScript: typeof file.postUpdateScript === "string" ? file.postUpdateScript : void 0,
+    postUpdateLabel: typeof file.postUpdateLabel === "string" ? file.postUpdateLabel : typeof file.postUpdateScript === "string" ? file.postUpdateScript : void 0,
+    locale: file.locale === "de" || file.locale === "en" ? file.locale : void 0,
+    channel: file.channel === "all" ? "all" : "stable"
+  };
+}
+
+// src/app.tsx
+import { useState as useState8, useMemo as useMemo5, useCallback as useCallback5 } from "react";
+import { Box as Box14, useInput as useInput2, useApp } from "ink";
+
+// src/adapters/npm/npm-discovery.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var NpmModuleDiscoveryAdapter = class {
+  async discover(rootDir) {
+    const rootPkg = readJson(join2(rootDir, "package.json"));
+    const modules = [
+      {
+        id: rootPkg?.name ?? "root",
+        name: rootPkg?.name ?? "Root Workspace (npm)",
+        path: rootDir,
+        relPath: "Root",
+        ecosystem: "npm",
+        isRoot: true
+      }
+    ];
+    if (!rootPkg?.workspaces) return modules;
+    const patterns = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : [];
+    for (const pattern of patterns) {
+      if (pattern.endsWith("/*")) {
+        const parentDir = join2(rootDir, pattern.slice(0, -2));
+        if (!existsSync2(parentDir)) continue;
+        for (const entry of readdirSync(parentDir, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          const pkgPath = join2(parentDir, entry.name, "package.json");
+          if (!existsSync2(pkgPath)) continue;
+          const pkg = readJson(pkgPath);
+          modules.push({
+            id: pkg?.name ?? `${pattern.slice(0, -2)}/${entry.name}`,
+            name: pkg?.name ?? `${pattern.slice(0, -2)}/${entry.name}`,
+            path: join2(parentDir, entry.name),
+            relPath: `${pattern.slice(0, -2)}/${entry.name}`,
+            ecosystem: "npm",
+            isRoot: false
+          });
+        }
+      } else {
+        const explicitPath = join2(rootDir, pattern);
+        const pkgPath = join2(explicitPath, "package.json");
+        if (!existsSync2(pkgPath)) continue;
+        const pkg = readJson(pkgPath);
+        modules.push({
+          id: pkg?.name ?? pattern,
+          name: pkg?.name ?? pattern,
+          path: explicitPath,
+          relPath: pattern,
+          ecosystem: "npm",
+          isRoot: false
+        });
+      }
+    }
+    return modules;
+  }
+};
+
+// src/adapters/npm/npm-registry.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import semver from "semver";
+var execAsync = promisify(exec);
+var NpmRegistryAdapter = class {
+  async getLatestVersion(coordinate, channel = "stable") {
+    try {
+      if (channel === "stable") {
+        const { stdout: stdout2 } = await execAsync(
+          `npm view ${coordinate.identifier} "dist-tags.latest" --json`,
+          { timeout: 15e3 }
+        );
+        const v = stdout2.trim().replace(/^"|"$/g, "");
+        if (v && semver.valid(v) && semver.prerelease(v) === null) {
+          return v;
+        }
+      }
+      const { stdout } = await execAsync(
+        `npm view ${coordinate.identifier} version --json`,
+        { timeout: 15e3 }
+      );
+      return stdout.trim().replace(/^"|"$/g, "");
+    } catch {
+      return null;
+    }
+  }
+  /** Liefert alle veröffentlichten Versionen (neueste zuerst) */
+  async getAllVersions(coordinate) {
+    try {
+      const { stdout } = await execAsync(
+        `npm view ${coordinate.identifier} versions --json`,
+        { timeout: 15e3 }
+      );
+      const parsed = JSON.parse(stdout.trim());
+      const list = Array.isArray(parsed) ? parsed : [parsed];
+      return list.map(String).reverse();
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/npm/npm-scanner.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
+import semver2 from "semver";
+var DIFF_ORDER = { major: 0, minor: 1, patch: 2 };
+var CONCURRENCY = 6;
+async function pooled(items, concurrency, fn) {
+  const results = [];
+  const executing = [];
+  for (const item of items) {
+    const p = Promise.resolve().then(() => fn(item));
+    results.push(p);
+    if (concurrency <= items.length) {
+      const slot = p.then(() => void executing.splice(executing.indexOf(slot), 1)).catch(() => void executing.splice(executing.indexOf(slot), 1));
+      executing.push(slot);
+      if (executing.length >= concurrency) await Promise.race(executing);
+    }
+  }
+  return Promise.all(results);
+}
+function matchesExcludedScope(name, excludeScopes) {
+  return excludeScopes.some((scope) => {
+    const normalized = scope.endsWith("/") ? scope : `${scope}/`;
+    return name.startsWith(normalized);
+  });
+}
+var NpmDependencyAdapter = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  registry;
+  async scan(module, excludedScopes, internalIds, channel = "stable") {
+    const pkgPath = join3(module.path, "package.json");
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+    } catch {
+      return [];
+    }
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const entries = Object.entries(allDeps).filter(
+      ([name]) => !internalIds.has(name) && !matchesExcludedScope(name, excludedScopes)
+    );
+    const candidates = [];
+    await pooled(entries, CONCURRENCY, async ([name, currentRange]) => {
+      const latest = await this.registry.getLatestVersion(
+        {
+          identifier: name,
+          artifact: name,
+          ecosystem: "npm"
+        },
+        channel
+      );
+      if (!latest) return;
+      const currentClean = semver2.minVersion(currentRange)?.version;
+      if (!currentClean || !semver2.gt(latest, currentClean)) return;
+      const diff = semver2.diff(currentClean, latest);
+      const prefix = currentRange.startsWith("~") ? "~" : currentRange.startsWith("^") ? "^" : "";
+      const prereleaseComponents = semver2.prerelease(latest);
+      const isPre = prereleaseComponents !== null;
+      const preTag = isPre ? String(prereleaseComponents[0]).toUpperCase() : void 0;
+      candidates.push({
+        coordinate: {
+          identifier: name,
+          artifact: name,
+          ecosystem: "npm"
+        },
+        currentRange,
+        currentClean,
+        latest,
+        newRange: `${prefix}${latest}`,
+        diff,
+        scope: pkg.devDependencies?.[name] ? "dev" : "prod",
+        selected: diff !== "major",
+        isPreRelease: isPre,
+        preReleaseTag: preTag
+      });
+    });
+    candidates.sort((a, b) => (DIFF_ORDER[a.diff] ?? 3) - (DIFF_ORDER[b.diff] ?? 3));
+    return candidates;
+  }
+};
+
+// src/adapters/npm/npm-updater.ts
+import { writeFileSync, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+var NpmUpdaterAdapter = class {
+  async applyUpdates(module, rootDir, updates, onProgress) {
+    const pkgPath = join4(module.path, "package.json");
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+    } catch {
+      throw new Error(`Konnte package.json in ${module.path} nicht lesen.`);
+    }
+    onProgress("Schreibe neue Versionen in package.json\u2026");
+    for (const item of updates) {
+      const name = item.coordinate.artifact;
+      if (pkg.dependencies?.[name]) {
+        pkg.dependencies[name] = item.newRange;
+      }
+      if (pkg.devDependencies?.[name]) {
+        pkg.devDependencies[name] = item.newRange;
+      }
+    }
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    onProgress("F\xFChre npm install aus (bitte kurz warten)\u2026");
+    let stdout = "";
+    let stderr = "";
+    try {
+      const res = await execAsync2("npm install", { cwd: rootDir });
+      stdout = res.stdout;
+      stderr = res.stderr;
+    } catch (err) {
+      stdout = err.stdout ?? "";
+      stderr = err.stderr ?? err.message;
+    }
+    onProgress("Analysiere Sicherheitsaudit & Output\u2026");
+    const combined = stdout + "\n" + stderr;
+    const auditMatch = combined.match(/found (\d+ vulnerabilit(?:y|ies).*)/i);
+    const fundingMatch = combined.match(/(\d+ packages? (?:is|are) looking for funding)/i);
+    return {
+      updatedCount: updates.length,
+      auditMessage: auditMatch ? auditMatch[0] : "Keine bekannten Schwachstellen gefunden.",
+      auditSeverity: auditMatch ? "warn" : "clean",
+      fundingMessage: fundingMatch ? fundingMatch[0] : void 0
+    };
+  }
+};
+
+// src/adapters/npm/npm-verifier.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+var NpmVerificationAdapter = class {
+  async verify(module, rootDir, customScript, customLabel) {
+    const script = customScript || "npm run check:versions";
+    const label = customLabel || "Workspace-Konsistenz (npm run check:versions)";
+    try {
+      const { stdout } = await execAsync3(script, { cwd: rootDir });
+      return {
+        status: "clean",
+        details: stdout.trim() || "Alle Workspace-Versionen sind konsistent.",
+        label
+      };
+    } catch (err) {
+      return {
+        status: "warn",
+        details: err.stdout || err.message,
+        label
+      };
+    }
+  }
+};
+
+// src/adapters/npm/npm-strategy.ts
+var NpmEcosystemStrategy = class {
+  ecosystem = "npm";
+  displayName = "Node / npm";
+  icon = "\u{1F4E6}";
+  manifestFile = "package.json";
+  discovery = new NpmModuleDiscoveryAdapter();
+  registry = new NpmRegistryAdapter();
+  reader = new NpmDependencyAdapter(this.registry);
+  updater = new NpmUpdaterAdapter();
+  verifier = new NpmVerificationAdapter();
+  getTabLabels(counts, t) {
+    return {
+      all: t.tabs.all(counts.total),
+      prod: t.tabs.dependencies(counts.prodCount),
+      dev: t.tabs.devDependencies(counts.devCount)
+    };
+  }
+};
+
+// src/adapters/maven/maven-discovery.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join5, relative } from "path";
+function extractPomInfo(pomPath) {
+  try {
+    const xml = readFileSync5(pomPath, "utf8");
+    const parentMatch = xml.match(/<parent>([\s\S]*?)<\/parent>/);
+    let parentGroup = "";
+    if (parentMatch) {
+      const pg = parentMatch[1].match(/<groupId>([^<]+)<\/groupId>/);
+      if (pg) parentGroup = pg[1].trim();
+    }
+    const strippedXml = xml.replace(/<parent>[\s\S]*?<\/parent>/, "").replace(/<dependencies>[\s\S]*?<\/dependencies>/, "").replace(/<build>[\s\S]*?<\/build>/, "");
+    const artifactMatch = strippedXml.match(/<artifactId>([^<]+)<\/artifactId>/);
+    const groupMatch = strippedXml.match(/<groupId>([^<]+)<\/groupId>/);
+    const nameMatch = strippedXml.match(/<name>([^<]+)<\/name>/);
+    const artifact = artifactMatch ? artifactMatch[1].trim() : "unbekannt";
+    const group = groupMatch ? groupMatch[1].trim() : parentGroup;
+    const name = nameMatch ? nameMatch[1].trim() : artifact;
+    return {
+      name: name || artifact,
+      id: group ? `${group}:${artifact}` : artifact
+    };
+  } catch {
+    return null;
+  }
+}
+function findPomFiles(dir, depth = 0, maxDepth = 4) {
+  if (depth > maxDepth || !existsSync3(dir)) return [];
+  const results = [];
+  try {
+    const entries = readdirSync2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "target") {
+        continue;
+      }
+      const fullPath = join5(dir, entry.name);
+      if (entry.isDirectory()) {
+        const pomPath = join5(fullPath, "pom.xml");
+        if (existsSync3(pomPath)) {
+          results.push(pomPath);
+        }
+        results.push(...findPomFiles(fullPath, depth + 1, maxDepth));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var MavenModuleDiscoveryAdapter = class {
+  async discover(rootDir) {
+    const pomFiles = findPomFiles(rootDir);
+    const modules = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    for (const pomPath of pomFiles) {
+      const moduleDir = pomPath.slice(0, -"/pom.xml".length);
+      if (seenPaths.has(moduleDir)) continue;
+      seenPaths.add(moduleDir);
+      const info = extractPomInfo(pomPath);
+      if (!info) continue;
+      const relPath = relative(rootDir, moduleDir).replace(/\\/g, "/");
+      modules.push({
+        id: info.id,
+        name: info.name,
+        path: moduleDir,
+        relPath: relPath || "Root",
+        ecosystem: "maven",
+        isRoot: moduleDir === rootDir
+      });
+    }
+    modules.sort((a, b) => a.relPath.localeCompare(b.relPath));
+    return modules;
+  }
+};
+
+// src/adapters/maven/maven-registry.ts
+function isPreReleaseVersion(version) {
+  return /[.-]?(alpha|beta|rc|cr|m\d*|preview|milestone|snapshot|ea|dev|b\d+)/i.test(version);
+}
+function extractPreReleaseTag(version) {
+  const match = version.match(/[.-]?(alpha|beta|rc|cr|m\d*|preview|milestone|snapshot|ea|dev)/i);
+  if (!match) return void 0;
+  const tag = match[1].toUpperCase();
+  if (tag.startsWith("M") && tag.length <= 3) return `M${tag.slice(1)}`;
+  return tag;
+}
+var MavenRegistryAdapter = class {
+  async getLatestVersion(coordinate, channel = "stable") {
+    if (!coordinate.group || !coordinate.artifact) return null;
+    const groupPath = coordinate.group.replace(/\./g, "/");
+    const url = `https://repo1.maven.org/maven2/${groupPath}/${coordinate.artifact}/maven-metadata.xml`;
+    try {
+      const response = await fetch(url, {
+        headers: { "User-Agent": "Elevate-Dependency-Updater" },
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (!response.ok) {
+        return await this.fallbackSearch(coordinate.group, coordinate.artifact, channel);
+      }
+      const xml = await response.text();
+      const allVersions = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1].trim());
+      if (channel === "stable") {
+        const releaseMatch2 = xml.match(/<release>([^<]+)<\/release>/);
+        if (releaseMatch2?.[1] && !isPreReleaseVersion(releaseMatch2[1].trim())) {
+          return releaseMatch2[1].trim();
+        }
+        for (let i = allVersions.length - 1; i >= 0; i--) {
+          const v = allVersions[i];
+          if (!isPreReleaseVersion(v)) {
+            return v;
+          }
+        }
+      }
+      const releaseMatch = xml.match(/<release>([^<]+)<\/release>/);
+      if (releaseMatch?.[1]) return releaseMatch[1].trim();
+      const latestMatch = xml.match(/<latest>([^<]+)<\/latest>/);
+      if (latestMatch?.[1]) return latestMatch[1].trim();
+      if (allVersions.length > 0) {
+        return allVersions[allVersions.length - 1];
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async fallbackSearch(group, artifact, channel) {
+    try {
+      const query = `g:${encodeURIComponent(group)}+AND+a:${encodeURIComponent(artifact)}`;
+      const url = `https://search.maven.org/solrsearch/select?q=${query}&rows=20&wt=json`;
+      const res = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+      if (!res.ok) return null;
+      const data = await res.json();
+      const docs = data?.response?.docs || [];
+      if (docs.length === 0) return null;
+      if (channel === "stable") {
+        for (const doc of docs) {
+          const v = doc.v || doc.latestVersion;
+          if (v && !isPreReleaseVersion(v)) return v;
+        }
+      }
+      return docs[0]?.latestVersion || docs[0]?.v || null;
+    } catch {
+      return null;
+    }
+  }
+  /** Liefert alle verfügbaren Versionen aus dem Maven-Repository (neueste zuerst) */
+  async getAllVersions(coordinate) {
+    if (!coordinate.group || !coordinate.artifact) return [];
+    const groupPath = coordinate.group.replace(/\./g, "/");
+    const url = `https://repo1.maven.org/maven2/${groupPath}/${coordinate.artifact}/maven-metadata.xml`;
+    try {
+      const response = await fetch(url, {
+        headers: { "User-Agent": "Elevate-Dependency-Updater" },
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (!response.ok) {
+        return await this.fallbackAllVersions(coordinate.group, coordinate.artifact);
+      }
+      const xml = await response.text();
+      const allVersions = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map(
+        (m) => m[1].trim()
+      );
+      if (allVersions.length > 0) {
+        return allVersions.reverse();
+      }
+      return await this.fallbackAllVersions(coordinate.group, coordinate.artifact);
+    } catch {
+      return await this.fallbackAllVersions(coordinate.group, coordinate.artifact);
+    }
+  }
+  async fallbackAllVersions(group, artifact) {
+    try {
+      const query = `g:${encodeURIComponent(group)}+AND+a:${encodeURIComponent(artifact)}`;
+      const url = `https://search.maven.org/solrsearch/select?q=${query}&rows=100&core=gav&wt=json`;
+      const res = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+      if (!res.ok) return [];
+      const data = await res.json();
+      const docs = data?.response?.docs || [];
+      return docs.map((d) => d.v).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/adapters/maven/maven-scanner.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
+import semver3 from "semver";
+var DIFF_ORDER2 = { major: 0, minor: 1, patch: 2 };
+var CONCURRENCY2 = 6;
+async function pooled2(items, concurrency, fn) {
+  const results = [];
+  const executing = [];
+  for (const item of items) {
+    const p = Promise.resolve().then(() => fn(item));
+    results.push(p);
+    if (concurrency <= items.length) {
+      const slot = p.then(() => void executing.splice(executing.indexOf(slot), 1)).catch(() => void executing.splice(executing.indexOf(slot), 1));
+      executing.push(slot);
+      if (executing.length >= concurrency) await Promise.race(executing);
+    }
+  }
+  return Promise.all(results);
+}
+function cleanJavaVersion(v) {
+  const match = v.match(/^v?(\d+\.\d+(?:\.\d+)?)/);
+  if (!match) return null;
+  return semver3.coerce(match[1])?.version ?? null;
+}
+var MavenDependencyAdapter = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  registry;
+  async scan(module, excludedScopes, internalIds, channel = "stable") {
+    const pomPath = join6(module.path, "pom.xml");
+    let xml = "";
+    try {
+      xml = readFileSync6(pomPath, "utf8");
+    } catch {
+      return [];
+    }
+    const properties = /* @__PURE__ */ new Map();
+    const propBlockMatch = xml.match(/<properties>([\s\S]*?)<\/properties>/);
+    if (propBlockMatch?.[1]) {
+      const propMatches = propBlockMatch[1].matchAll(/<([a-zA-Z0-9_.-]+)>([^<]+)<\/\1>/g);
+      for (const m of propMatches) {
+        properties.set(m[1].trim(), m[2].trim());
+      }
+    }
+    const rawDeps = [];
+    const seenCoordinates = /* @__PURE__ */ new Set();
+    const depBlockMatches = xml.matchAll(/<dependency>([\s\S]*?)<\/dependency>/g);
+    for (const match of depBlockMatches) {
+      const block = match[1];
+      const groupMatch = block.match(/<groupId>([^<]+)<\/groupId>/);
+      const artifactMatch = block.match(/<artifactId>([^<]+)<\/artifactId>/);
+      const versionMatch = block.match(/<version>([^<]+)<\/version>/);
+      const scopeMatch = block.match(/<scope>([^<]+)<\/scope>/);
+      if (!groupMatch?.[1] || !artifactMatch?.[1]) continue;
+      const group = groupMatch[1].trim();
+      const artifact = artifactMatch[1].trim();
+      const identifier = `${group}:${artifact}`;
+      if (seenCoordinates.has(identifier)) continue;
+      seenCoordinates.add(identifier);
+      let rawVersion = versionMatch?.[1]?.trim() || "";
+      if (rawVersion.startsWith("${") && rawVersion.endsWith("}")) {
+        const propKey = rawVersion.slice(2, -1);
+        rawVersion = properties.get(propKey) || rawVersion;
+      }
+      if (!rawVersion || rawVersion.startsWith("${")) {
+        continue;
+      }
+      const scope = scopeMatch?.[1]?.trim() === "test" ? "test" : "prod";
+      const isInternal = internalIds.has(identifier) || internalIds.has(artifact) || excludedScopes.some((s) => group.startsWith(s.replace(/^@/, "")));
+      if (isInternal) continue;
+      rawDeps.push({ group, artifact, rawVersion, scope });
+    }
+    const candidates = [];
+    await pooled2(rawDeps, CONCURRENCY2, async (dep) => {
+      const latest = await this.registry.getLatestVersion(
+        {
+          identifier: `${dep.group}:${dep.artifact}`,
+          group: dep.group,
+          artifact: dep.artifact,
+          ecosystem: "maven"
+        },
+        channel
+      );
+      if (!latest) return;
+      const currentClean = cleanJavaVersion(dep.rawVersion);
+      const latestClean = cleanJavaVersion(latest);
+      if (!currentClean || !latestClean) return;
+      if (semver3.gt(latestClean, currentClean)) {
+        const diff = semver3.diff(currentClean, latestClean) || "minor";
+        const isPre = isPreReleaseVersion(latest);
+        const preTag = isPre ? extractPreReleaseTag(latest) : void 0;
+        candidates.push({
+          coordinate: {
+            identifier: `${dep.group}:${dep.artifact}`,
+            group: dep.group,
+            artifact: dep.artifact,
+            ecosystem: "maven"
+          },
+          currentRange: dep.rawVersion,
+          currentClean,
+          latest,
+          newRange: latest,
+          diff,
+          scope: dep.scope,
+          selected: diff !== "major",
+          isPreRelease: isPre,
+          preReleaseTag: preTag
+        });
+      }
+    });
+    candidates.sort((a, b) => (DIFF_ORDER2[a.diff] ?? 3) - (DIFF_ORDER2[b.diff] ?? 3));
+    return candidates;
+  }
+};
+
+// src/adapters/maven/maven-updater.ts
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync7 } from "fs";
+import { join as join7 } from "path";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsync4 = promisify4(exec4);
+var MavenUpdaterAdapter = class {
+  async applyUpdates(module, _rootDir, updates, onProgress) {
+    const pomPath = join7(module.path, "pom.xml");
+    let xml = "";
+    try {
+      xml = readFileSync7(pomPath, "utf8");
+    } catch {
+      throw new Error(`Konnte pom.xml in ${module.path} nicht lesen.`);
+    }
+    onProgress("Schreibe neue Versionen in pom.xml\u2026");
+    for (const item of updates) {
+      const group = item.coordinate.group;
+      const artifact = item.coordinate.artifact;
+      const newVersion = item.newRange;
+      if (!group || !artifact) continue;
+      const depRegex = new RegExp(
+        `(<dependency>[\\s\\S]*?<groupId>${group}<\\/groupId>[\\s\\S]*?<artifactId>${artifact}<\\/artifactId>[\\s\\S]*?<version>)([^<]+)(<\\/version>[\\s\\S]*?<\\/dependency>)`,
+        "g"
+      );
+      xml = xml.replace(depRegex, `$1${newVersion}$3`);
+    }
+    writeFileSync2(pomPath, xml, "utf8");
+    onProgress("L\xF6se neue Maven-Abh\xE4ngigkeiten auf (mvn dependency:resolve)\u2026");
+    let stdout = "";
+    let stderr = "";
+    try {
+      const res = await execAsync4("mvn dependency:resolve -q -DskipTests", {
+        cwd: module.path,
+        timeout: 6e4
+      });
+      stdout = res.stdout;
+      stderr = res.stderr;
+    } catch (err) {
+      stdout = err.stdout ?? "";
+      stderr = err.stderr ?? err.message;
+    }
+    onProgress("Analysiere Maven-Status\u2026");
+    const hasError = stdout.includes("BUILD FAILURE") || stderr.includes("BUILD FAILURE");
+    return {
+      updatedCount: updates.length,
+      auditMessage: hasError ? "Achtung: Einige Abh\xE4ngigkeiten konnten nicht sofort aufgel\xF6st werden." : "Alle Maven-Abh\xE4ngigkeiten erfolgreich aufgel\xF6st.",
+      auditSeverity: hasError ? "warn" : "clean",
+      fundingMessage: void 0
+    };
+  }
+};
+
+// src/adapters/maven/maven-verifier.ts
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+var execAsync5 = promisify5(exec5);
+var MavenVerificationAdapter = class {
+  async verify(module, _rootDir, customScript, customLabel) {
+    const script = customScript || "mvn test-compile -q";
+    const label = customLabel || "Java-Kompilierungstest (mvn test-compile)";
+    try {
+      const { stdout } = await execAsync5(script, {
+        cwd: module.path,
+        timeout: 9e4
+      });
+      return {
+        status: "clean",
+        details: stdout.trim() || "Java-Quellcode kompiliert fehlerfrei.",
+        label
+      };
+    } catch (err) {
+      return {
+        status: "warn",
+        details: (err.stdout || err.stderr || err.message).slice(0, 300),
+        label
+      };
+    }
+  }
+};
+
+// src/adapters/maven/maven-strategy.ts
+var MavenEcosystemStrategy = class {
+  ecosystem = "maven";
+  displayName = "Java / Maven";
+  icon = "\u2615";
+  manifestFile = "pom.xml";
+  discovery = new MavenModuleDiscoveryAdapter();
+  registry = new MavenRegistryAdapter();
+  reader = new MavenDependencyAdapter(this.registry);
+  updater = new MavenUpdaterAdapter();
+  verifier = new MavenVerificationAdapter();
+  getTabLabels(counts, _t) {
+    return {
+      all: `[1] Alle (${counts.total})`,
+      prod: `[2] Compile (${counts.prodCount})`,
+      dev: `[3] Test (${counts.devCount})`
+    };
+  }
+};
+
+// src/domain/ecosystem-factory.ts
+var EcosystemFactory = class {
+  static instances = /* @__PURE__ */ new Map();
+  /** Liefert die Strategie für das gewünschte Ökosystem (Lazy Singleton) */
+  static getStrategy(ecosystem) {
+    let strategy = this.instances.get(ecosystem);
+    if (!strategy) {
+      if (ecosystem === "maven") {
+        strategy = new MavenEcosystemStrategy();
+      } else {
+        strategy = new NpmEcosystemStrategy();
+      }
+      this.instances.set(ecosystem, strategy);
+    }
+    return strategy;
+  }
+  /** Liefert alle verfügbaren Ökosysteme */
+  static getAvailableEcosystems() {
+    return ["npm", "maven"];
+  }
+};
+
+// src/i18n/index.ts
+import { useState, useCallback, useMemo } from "react";
+
+// src/i18n/locales/de.ts
+var de = {
+  header: {
+    title: "Elevate",
+    developedBy: (name) => `Entwickelt & gepflegt von ${name}`,
+    langToggleHint: "[L] DE / EN",
+    ecosystemToggleHint: (nextName) => `[E] ${nextName}`
+  },
+  workspace: {
+    label: "Workspace / Modul",
+    switchHint: "Dr\xFCcke [W] zum Wechseln",
+    modalTitle: "\u{1F4C1} Modul ausw\xE4hlen (\u2191/\u2193 Navigieren, Enter Ausw\xE4hlen, Esc Abbrechen):"
+  },
+  tabs: {
+    all: (count) => `[1] Alle (${count})`,
+    dependencies: (count) => `[2] Dependencies (${count})`,
+    devDependencies: (count) => `[3] DevDependencies (${count})`
+  },
+  list: {
+    scanning: "\u23F3 Pr\xFCfe Registry auf verf\xFCgbare Updates\u2026",
+    allUpToDate: "\u{1F389} Alle Abh\xE4ngigkeiten in diesem Tab sind auf dem neuesten Stand!",
+    moreAbove: "\u25B2 \u2026 weitere oben",
+    moreBelow: (remaining) => `\u25BC \u2026 weitere unten (${remaining} \xFCbrig)`
+  },
+  badges: {
+    patch: "[Patch]",
+    minor: "[Minor]",
+    major: "[MAJOR]",
+    dev: "(dev/test)",
+    prod: "(prod/compile)"
+  },
+  status: {
+    selectedOf: (selected, total) => `${selected} von ${total}`,
+    breakdown: (patch, minor, major) => `(${patch} Patch, ${minor} Minor, ${major} Major)`,
+    symlinksProtected: (scopes) => `\u{1F6E1}\uFE0F Interne ${scopes.map((s) => `${s}/*`).join(", ")} gesch\xFCtzt`,
+    defaultProtected: "\u{1F6E1}\uFE0F Interne Monorepo-Module gesch\xFCtzt"
+  },
+  controls: {
+    navigate: "Navigieren",
+    toggle: "Toggle",
+    all: "Alle",
+    tabs: "Tabs",
+    workspace: "Modul",
+    ecosystem: "\xD6kosystem",
+    version: "Version",
+    language: "Sprache",
+    update: "Update starten",
+    quit: "Beenden"
+  },
+  versionModal: {
+    title: (pkgName) => `Version heraussuchen: ${pkgName}`,
+    current: (version) => `Aktuell installiert: ${version}`,
+    filterPlaceholder: "Tippe zum Filtern (z. B. 3.2 oder 18)\u2026",
+    loading: "Lade alle Versionen aus der Registry\u2026",
+    noVersions: "Keine passenden Versionen gefunden.",
+    hint: "[\u2191/\u2193/j/k] Navigieren  \u2502  [Enter] Ausw\xE4hlen  \u2502  [Esc] Abbrechen  \u2502  [Backspace] Filter l\xF6schen",
+    latestBadge: "LATEST",
+    currentBadge: "AKTUELL",
+    customBadge: "MANUELL"
+  },
+  updating: {
+    title: "\u26A1 Aktualisierung l\xE4uft\u2026",
+    stepWriting: (step, total) => `${step}/${total} \u2014 Schreibe neue Versionen ins Manifest\u2026`,
+    stepInstalling: (step, total) => `${step}/${total} \u2014 L\xF6se Abh\xE4ngigkeiten auf (bitte kurz warten)\u2026`,
+    stepAnalyzing: (step, total) => `${step}/${total} \u2014 Analysiere Build & Output\u2026`,
+    stepCustom: (step, total, label) => `${step}/${total} \u2014 ${label}\u2026`,
+    doNotClose: "Bitte das Terminal nicht schlie\xDFen."
+  },
+  summary: {
+    title: "\u2728 Aktualisierung abgeschlossen!",
+    successCount: (count, path) => `\u{1F4E6} ${count} Abh\xE4ngigkeiten erfolgreich in ${path} aktualisiert.`,
+    securityAudit: "\u{1F6E1}\uFE0F Status & Audit:",
+    cleanAudit: "Keine bekannten Probleme gefunden.",
+    funding: (msg) => `\u{1F4A1} Funding: ${msg}`,
+    postScript: (label) => `\u{1F50D} ${label}:`,
+    backHint: "[Enter] Zur\xFCck zum Dashboard   \u2502   [Q] Beenden"
+  },
+  mascot: {
+    name: "Pip",
+    idleChirps: ["*piep*", "*flausch*", "*pick pick*", "alles frisch! \u{1FAB6}", "*blinzel*"],
+    scanningChirps: ["*such*", "pr\xFCfe...", "oh, Updates?", "einen Moment!"],
+    updatingChirps: ["*schuft*", "baue Code...", "gleich fertig!", "arbeite emsig..."],
+    successChirps: ["hurra! \u{1F389}", "alles aktuell!", "top gepflegt! \u{1FAB6}", "super gemacht!"],
+    mavenChirps: ["*kaffee schl\xFCrf* \u2615", "Spring Boot l\xE4uft!", "Java 25 rockt!", "sauber gebaut!"]
+  },
+  splash: {
+    tagline: "Modernes Polyglot Dependency Dashboard",
+    loading: "Initialisiere Module & bereite Dashboard vor\u2026",
+    skipHint: "[Leertaste / Enter] zum \xDCberspringen"
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  header: {
+    title: "Elevate",
+    developedBy: (name) => `Developed & maintained by ${name}`,
+    langToggleHint: "[L] EN / DE",
+    ecosystemToggleHint: (nextName) => `[E] ${nextName}`
+  },
+  workspace: {
+    label: "Workspace / Module",
+    switchHint: "Press [W] to switch",
+    modalTitle: "\u{1F4C1} Select Module (\u2191/\u2193 Navigate, Enter Select, Esc Cancel):"
+  },
+  tabs: {
+    all: (count) => `[1] All (${count})`,
+    dependencies: (count) => `[2] Dependencies (${count})`,
+    devDependencies: (count) => `[3] DevDependencies (${count})`
+  },
+  list: {
+    scanning: "\u23F3 Checking registry for available updates\u2026",
+    allUpToDate: "\u{1F389} All dependencies in this tab are up to date!",
+    moreAbove: "\u25B2 \u2026 more above",
+    moreBelow: (remaining) => `\u25BC \u2026 more below (${remaining} remaining)`
+  },
+  badges: {
+    patch: "[Patch]",
+    minor: "[Minor]",
+    major: "[MAJOR]",
+    dev: "(dev/test)",
+    prod: "(prod/compile)"
+  },
+  status: {
+    selectedOf: (selected, total) => `${selected} of ${total}`,
+    breakdown: (patch, minor, major) => `(${patch} Patch, ${minor} Minor, ${major} Major)`,
+    symlinksProtected: (scopes) => `\u{1F6E1}\uFE0F Internal ${scopes.map((s) => `${s}/*`).join(", ")} protected`,
+    defaultProtected: "\u{1F6E1}\uFE0F Internal monorepo modules protected"
+  },
+  controls: {
+    navigate: "Navigate",
+    toggle: "Toggle",
+    all: "All",
+    tabs: "Tabs",
+    workspace: "Module",
+    ecosystem: "Ecosystem",
+    version: "Version",
+    language: "Language",
+    update: "Start update",
+    quit: "Quit"
+  },
+  versionModal: {
+    title: (pkgName) => `Pick version for: ${pkgName}`,
+    current: (version) => `Currently installed: ${version}`,
+    filterPlaceholder: "Type to filter (e.g. 3.2 or 18)\u2026",
+    loading: "Loading all versions from registry\u2026",
+    noVersions: "No matching versions found.",
+    hint: "[\u2191/\u2193/j/k] Navigate  \u2502  [Enter] Select  \u2502  [Esc] Cancel  \u2502  [Backspace] Clear filter",
+    latestBadge: "LATEST",
+    currentBadge: "CURRENT",
+    customBadge: "MANUAL"
+  },
+  updating: {
+    title: "\u26A1 Update in progress\u2026",
+    stepWriting: (step, total) => `${step}/${total} \u2014 Writing new versions to manifest\u2026`,
+    stepInstalling: (step, total) => `${step}/${total} \u2014 Resolving dependencies (please wait)\u2026`,
+    stepAnalyzing: (step, total) => `${step}/${total} \u2014 Analyzing build & output\u2026`,
+    stepCustom: (step, total, label) => `${step}/${total} \u2014 ${label}\u2026`,
+    doNotClose: "Please do not close the terminal."
+  },
+  summary: {
+    title: "\u2728 Update completed successfully!",
+    successCount: (count, path) => `\u{1F4E6} ${count} dependencies updated successfully in ${path}.`,
+    securityAudit: "\u{1F6E1}\uFE0F Status & Audit:",
+    cleanAudit: "No known issues found.",
+    funding: (msg) => `\u{1F4A1} Funding: ${msg}`,
+    postScript: (label) => `\u{1F50D} ${label}:`,
+    backHint: "[Enter] Back to Dashboard   \u2502   [Q] Quit"
+  },
+  mascot: {
+    name: "Pip",
+    idleChirps: ["*chirp*", "*fluff*", "*peck peck*", "all fresh! \u{1FAB6}", "*blink*"],
+    scanningChirps: ["*peeking*", "checking...", "ooh, updates?", "just a sec!"],
+    updatingChirps: ["*working hard*", "building...", "almost there!", "packing modules..."],
+    successChirps: ["hooray! \u{1F389}", "all updated!", "looking sharp! \u{1FAB6}", "great job!"],
+    mavenChirps: ["*sipping coffee* \u2615", "Spring Boot rocks!", "Java 25 is fly!", "clean build!"]
+  },
+  splash: {
+    tagline: "Modern Polyglot Dependency Dashboard",
+    loading: "Initializing modules & preparing dashboard\u2026",
+    skipHint: "[Space / Enter] to skip"
+  }
+};
+
+// src/i18n/index.ts
+var dictionaries = { de, en };
+function resolveInitialLocale(configured) {
+  if (configured === "de" || configured === "en") return configured;
+  const envLang = (process.env.LANG || process.env.LC_ALL || process.env.LANGUAGE || "").toLowerCase();
+  if (envLang.startsWith("en")) return "en";
+  return "de";
+}
+function getTranslations(locale) {
+  return dictionaries[locale] ?? dictionaries.de;
+}
+function useI18n(initialLocale = "de") {
+  const [locale, setLocale] = useState(initialLocale);
+  const toggleLocale = useCallback(() => {
+    setLocale((prev) => prev === "de" ? "en" : "de");
+  }, []);
+  const t = useMemo(() => getTranslations(locale), [locale]);
+  return {
+    locale,
+    setLocale,
+    toggleLocale,
+    t
+  };
+}
+
+// src/hooks/use-workspaces.ts
+import { useState as useState2, useEffect, useMemo as useMemo2, useCallback as useCallback2 } from "react";
+function useWorkspaces(strategy, rootDir) {
+  const [modules, setModules] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [activeIndex, setActiveIndex] = useState2(0);
+  const reload = useCallback2(async () => {
+    setLoading(true);
+    setModules([]);
+    setActiveIndex(0);
+    try {
+      const found = await strategy.discovery.discover(rootDir);
+      setModules(found);
+      setActiveIndex(0);
+    } catch {
+      setModules([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [strategy, rootDir]);
+  useEffect(() => {
+    reload();
+  }, [reload]);
+  const internalIds = useMemo2(() => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const m of modules) {
+      if (m.id) ids.add(m.id);
+      if (m.name) ids.add(m.name);
+    }
+    return ids;
+  }, [modules]);
+  const active = modules[activeIndex] || {
+    id: "empty",
+    name: "Kein Modul gefunden",
+    path: rootDir,
+    relPath: "Root",
+    ecosystem: strategy.ecosystem,
+    isRoot: true
+  };
+  return {
+    modules,
+    active,
+    activeIndex,
+    setActiveIndex,
+    internalIds,
+    loading,
+    reload
+  };
+}
+
+// src/hooks/use-packages.ts
+import { useState as useState3, useEffect as useEffect2, useMemo as useMemo3, useCallback as useCallback3 } from "react";
+import semver4 from "semver";
+function usePackages(strategy, module, internalIds, excludeScopes = [], channel = "stable") {
+  const [candidates, setCandidates] = useState3([]);
+  const [loading, setLoading] = useState3(false);
+  const [activeTab, setActiveTab] = useState3("all");
+  const [cursor, setCursor] = useState3(0);
+  const scan = useCallback3(async () => {
+    if (!module || module.id === "empty") {
+      setCandidates([]);
+      return;
+    }
+    setLoading(true);
+    setCursor(0);
+    setCandidates([]);
+    try {
+      const updates = await strategy.reader.scan(module, excludeScopes, internalIds, channel);
+      setCandidates(updates);
+    } catch {
+      setCandidates([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [strategy, module.path, module.id, internalIds, excludeScopes, channel]);
+  useEffect2(() => {
+    if (module && module.id !== "empty") {
+      scan();
+    }
+  }, [module.path, module.id, strategy.ecosystem, channel]);
+  const visible = useMemo3(() => {
+    if (activeTab === "prod") return candidates.filter((c) => c.scope === "prod");
+    if (activeTab === "dev") return candidates.filter((c) => c.scope !== "prod");
+    return candidates;
+  }, [candidates, activeTab]);
+  const counts = useMemo3(() => {
+    const selected = candidates.filter((c) => c.selected);
+    return {
+      total: candidates.length,
+      prodCount: candidates.filter((c) => c.scope === "prod").length,
+      devCount: candidates.filter((c) => c.scope !== "prod").length,
+      selectedCount: selected.length,
+      patchCount: selected.filter((c) => c.diff === "patch").length,
+      minorCount: selected.filter((c) => c.diff === "minor").length,
+      majorCount: selected.filter((c) => c.diff === "major").length
+    };
+  }, [candidates]);
+  const togglePackage = useCallback3((identifier) => {
+    setCandidates(
+      (prev) => prev.map(
+        (c) => c.coordinate.identifier === identifier ? { ...c, selected: !c.selected } : c
+      )
+    );
+  }, []);
+  const toggleAllVisible = useCallback3(() => {
+    const allSelected = visible.every((c) => c.selected);
+    const visibleIds = new Set(visible.map((c) => c.coordinate.identifier));
+    setCandidates(
+      (prev) => prev.map(
+        (c) => visibleIds.has(c.coordinate.identifier) ? { ...c, selected: !allSelected } : c
+      )
+    );
+  }, [visible]);
+  const setCustomVersion = useCallback3((identifier, chosenVersion) => {
+    setCandidates(
+      (prev) => prev.map((c) => {
+        if (c.coordinate.identifier !== identifier) return c;
+        const prefix = c.currentRange.startsWith("~") ? "~" : c.currentRange.startsWith("^") ? "^" : "";
+        let diff = "minor";
+        const cleanChosen = semver4.valid(chosenVersion);
+        if (c.currentClean && cleanChosen) {
+          const semDiff = semver4.diff(c.currentClean, chosenVersion);
+          if (semDiff === "major" || semDiff === "minor" || semDiff === "patch") {
+            diff = semDiff;
+          }
+        }
+        const isPre = isPreReleaseVersion(chosenVersion);
+        const preTag = isPre ? extractPreReleaseTag(chosenVersion) : void 0;
+        return {
+          ...c,
+          newRange: `${prefix}${chosenVersion}`,
+          diff,
+          selected: true,
+          isPreRelease: isPre,
+          preReleaseTag: preTag,
+          isCustomVersion: true
+        };
+      })
+    );
+  }, []);
+  const switchTab = useCallback3((tab) => {
+    setActiveTab(tab);
+    setCursor(0);
+  }, []);
+  const cycleTab = useCallback3(() => {
+    setActiveTab((t) => t === "all" ? "prod" : t === "prod" ? "dev" : "all");
+    setCursor(0);
+  }, []);
+  return {
+    packages: candidates,
+    loading,
+    visible,
+    counts,
+    activeTab,
+    cursor,
+    setCursor,
+    scan,
+    switchTab,
+    cycleTab,
+    togglePackage,
+    toggleAllVisible,
+    setCustomVersion
+  };
+}
+
+// src/hooks/use-updater.ts
+import { useState as useState4, useCallback as useCallback4 } from "react";
+function useUpdater(strategy, rootDir, setView, postUpdate) {
+  const [step, setStep] = useState4("");
+  const [summary, setSummary] = useState4(null);
+  const run = useCallback4(
+    async (module, selected, _t) => {
+      if (selected.length === 0) return;
+      setView("updating");
+      const updaterResult = await strategy.updater.applyUpdates(
+        module,
+        rootDir,
+        selected,
+        (progressMessage) => setStep(progressMessage)
+      );
+      setStep("F\xFChre Verifikation und Konsistenzchecks durch\u2026");
+      const verifierResult = await strategy.verifier.verify(
+        module,
+        rootDir,
+        postUpdate?.script,
+        postUpdate?.label
+      );
+      setSummary({
+        ...updaterResult,
+        verificationStatus: verifierResult.status,
+        verificationDetails: verifierResult.details,
+        verificationLabel: verifierResult.label
+      });
+      setView("summary");
+    },
+    [strategy, rootDir, setView, postUpdate]
+  );
+  return { step, summary, run };
+}
+
+// src/components/splash-screen.tsx
+import { useState as useState5, useEffect as useEffect3 } from "react";
+import { Box, Text } from "ink";
+
+// src/theme.ts
+var theme = {
+  icon: "\u{1FAB6}",
+  colors: {
+    // Brand & Akzente (Orange-Palette)
+    brand: "#FF8800",
+    brandLight: "#FFA726",
+    brandDark: "#E65100",
+    brandSoft: "#FFE0B2",
+    accent: "#FF9800",
+    // Süßes Hühnchen (Mascot)
+    mascotBody: "#FFD54F",
+    mascotComb: "#FF7043",
+    mascotBeak: "#FF9800",
+    mascotBlush: "#FF8A80",
+    mascotFeet: "#FFA726",
+    // Statusfarben
+    success: "green",
+    warning: "yellow",
+    danger: "red",
+    muted: "gray",
+    white: "white",
+    // UI-Elemente
+    border: "#FF8800",
+    borderMuted: "gray",
+    focus: "#FFA726"
+  }
+};
+
+// src/components/splash-screen.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var SplashScreen = ({ onComplete, author }) => {
+  const t = en;
+  const [progress, setProgress] = useState5(0);
+  const [frame, setFrame] = useState5(0);
+  useEffect3(() => {
+    const progressTimer = setInterval(() => {
+      setProgress((prev) => {
+        if (prev >= 100) {
+          clearInterval(progressTimer);
+          setTimeout(onComplete, 250);
+          return 100;
+        }
+        return prev + 5;
+      });
+    }, 150);
+    const mascotTimer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % 4);
+    }, 400);
+    return () => {
+      clearInterval(progressTimer);
+      clearInterval(mascotTimer);
+    };
+  }, [onComplete]);
+  const mascotFrames = [
+    { face: "( \u2022\u04E9\u2022 )", arms: "/ >\u{1FAB6}", chirp: "*chirp!*" },
+    { face: "( \u1D54\u04E9\u1D54 )", arms: "/ >\u{1FAB6}", chirp: "*hello!*" },
+    { face: "( -\u04E9- )", arms: "/ >\u{1FAB6}", chirp: "*blink*" },
+    { face: "( \u2022\u04E9\u2022 )", arms: "\\(\u2022\u04E9\u2022)/", chirp: "ready! \u2728" }
+  ];
+  const curMascot = mascotFrames[frame % mascotFrames.length];
+  const barLength = 24;
+  const filledLength = Math.round(progress / 100 * barLength);
+  const emptyLength = Math.max(0, barLength - filledLength);
+  const progressBar = "\u2588".repeat(filledLength) + "\u2591".repeat(emptyLength);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      borderStyle: "round",
+      borderColor: theme.colors.brand,
+      paddingY: 2,
+      paddingX: 4,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsxs(Text, { bold: true, color: theme.colors.brand, children: [
+          theme.icon,
+          "   E  L  E  V  A  T  E"
+        ] }) }),
+        /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: t.splash.tagline }),
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", marginY: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.colors.mascotComb, bold: true, children: "(\\_/)" }),
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: theme.colors.mascotBody, bold: true, children: [
+              curMascot.face,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: theme.colors.brandLight, italic: true, children: curMascot.chirp })
+          ] }),
+          /* @__PURE__ */ jsx(Text, { color: theme.colors.brandLight, bold: true, children: curMascot.arms })
+        ] }),
+        author && /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: t.header.developedBy(author) }) }),
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", marginTop: 1, children: [
+          /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: theme.colors.brandLight, bold: true, children: [
+            "[",
+            progressBar,
+            "] ",
+            Math.min(100, progress),
+            "%"
+          ] }) }),
+          /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, children: t.splash.loading }) })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.colors.muted, dimColor: true, children: t.splash.skipHint }) })
+      ]
+    }
+  );
+};
+
+// src/components/header.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var Header = ({
+  author,
+  t,
+  currentLocale,
+  strategy,
+  nextStrategyName,
+  channel
+}) => /* @__PURE__ */ jsxs2(
+  Box2,
+  {
+    borderStyle: "round",
+    borderColor: theme.colors.brand,
+    paddingX: 1,
+    justifyContent: "space-between",
+    alignItems: "center",
+    children: [
+      /* @__PURE__ */ jsxs2(Box2, { alignItems: "center", children: [
+        /* @__PURE__ */ jsxs2(Text2, { bold: true, color: theme.colors.brand, children: [
+          theme.icon,
+          " ",
+          t.header.title
+        ] }),
+        /* @__PURE__ */ jsxs2(Box2, { marginLeft: 2, children: [
+          /* @__PURE__ */ jsx2(Text2, { color: theme.colors.muted, children: "\u2502 " }),
+          /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.brandLight, bold: true, children: [
+            strategy.icon,
+            " ",
+            strategy.displayName
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.muted, children: [
+            " [",
+            channel,
+            "] "
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.muted, children: [
+            "(",
+            t.header.ecosystemToggleHint(nextStrategyName),
+            ")"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2(Box2, { marginLeft: 2, children: [
+          /* @__PURE__ */ jsx2(Text2, { color: theme.colors.muted, children: "\u2502 " }),
+          /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.brandLight, bold: true, children: [
+            "[",
+            currentLocale.toUpperCase(),
+            "]"
+          ] }),
+          /* @__PURE__ */ jsxs2(Text2, { color: theme.colors.muted, children: [
+            " ",
+            t.header.langToggleHint
+          ] })
+        ] })
+      ] }),
+      author && /* @__PURE__ */ jsx2(Text2, { color: theme.colors.muted, children: t.header.developedBy(author) })
+    ]
+  }
+);
+
+// src/components/workspace-bar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var WorkspaceBar = ({ module, excludeScopes, strategy, t }) => {
+  const scopeHint = excludeScopes.length > 0 ? t.status.symlinksProtected(excludeScopes) : t.status.defaultProtected;
+  return /* @__PURE__ */ jsxs3(Box3, { marginY: 1, justifyContent: "space-between", alignItems: "center", children: [
+    /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", flexShrink: 1, children: [
+      /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+        "\u{1F4CD} ",
+        strategy.icon,
+        " ",
+        t.workspace.label,
+        ": "
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.colors.brandLight, children: module.name }),
+      /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
+        " (",
+        module.relPath,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Box3, { alignItems: "center", marginLeft: 2, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: scopeHint }),
+      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.muted, children: "  \u2502  " }),
+      /* @__PURE__ */ jsx3(Text3, { color: theme.colors.brandLight, bold: true, children: "[W]" }),
+      /* @__PURE__ */ jsxs3(Text3, { color: theme.colors.muted, children: [
+        " ",
+        t.workspace.switchHint.replace("[W]", "").trim()
+      ] })
+    ] })
+  ] });
+};
+
+// src/components/tab-bar.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var TabBar = ({ activeTab, counts, strategy, t }) => {
+  const labels = strategy.getTabLabels(counts, t);
+  return /* @__PURE__ */ jsxs4(Box4, { borderStyle: "single", borderColor: theme.colors.borderMuted, paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(
+      Text4,
+      {
+        bold: true,
+        color: activeTab === "all" ? theme.colors.brand : theme.colors.white,
+        underline: activeTab === "all",
+        children: labels.all
+      }
+    ),
+    /* @__PURE__ */ jsx4(Text4, { color: theme.colors.muted, children: "   \u2502   " }),
+    /* @__PURE__ */ jsx4(
+      Text4,
+      {
+        bold: true,
+        color: activeTab === "prod" ? theme.colors.brand : theme.colors.white,
+        underline: activeTab === "prod",
+        children: labels.prod
+      }
+    ),
+    /* @__PURE__ */ jsx4(Text4, { color: theme.colors.muted, children: "   \u2502   " }),
+    /* @__PURE__ */ jsx4(
+      Text4,
+      {
+        bold: true,
+        color: activeTab === "dev" ? theme.colors.brand : theme.colors.white,
+        underline: activeTab === "dev",
+        children: labels.dev
+      }
+    )
+  ] });
+};
+
+// src/components/package-list.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/components/package-row.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var PackageRow = ({ item, isFocused, t }) => {
+  const badge = item.diff === "major" ? /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.colors.danger, children: t.badges.major }) : item.diff === "minor" ? /* @__PURE__ */ jsx5(Text5, { color: theme.colors.warning, children: t.badges.minor }) : /* @__PURE__ */ jsx5(Text5, { color: theme.colors.success, children: t.badges.patch });
+  const displayName = item.coordinate?.identifier || item.name || "";
+  const isDevOrTest = item.scope === "dev" || item.scope === "test";
+  return /* @__PURE__ */ jsxs5(Box5, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: theme.colors.brandLight, bold: true, children: isFocused ? "\u2794 " : "  " }),
+      /* @__PURE__ */ jsx5(Text5, { color: item.selected ? theme.colors.success : theme.colors.muted, bold: true, children: item.selected ? "[\u2714] " : "[ ] " }),
+      /* @__PURE__ */ jsxs5(Text5, { bold: isFocused, color: isFocused ? theme.colors.brandLight : theme.colors.white, children: [
+        displayName.slice(0, 42).padEnd(42),
+        " "
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { color: theme.colors.muted, children: [
+        item.currentRange.padEnd(12),
+        " "
+      ] }),
+      /* @__PURE__ */ jsx5(Text5, { color: theme.colors.muted, children: "\u2794 " }),
+      /* @__PURE__ */ jsxs5(Text5, { bold: true, color: theme.colors.white, children: [
+        item.newRange.padEnd(12),
+        " "
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      item.isCustomVersion && /* @__PURE__ */ jsxs5(Text5, { bold: true, color: theme.colors.brandLight, children: [
+        "[",
+        t.versionModal.customBadge,
+        "]",
+        " "
+      ] }),
+      item.isPreRelease && /* @__PURE__ */ jsxs5(Text5, { bold: true, color: "#E040FB", children: [
+        "[",
+        item.preReleaseTag || "PRE",
+        "]",
+        " "
+      ] }),
+      badge,
+      /* @__PURE__ */ jsxs5(Text5, { color: theme.colors.muted, children: [
+        " ",
+        isDevOrTest ? t.badges.dev : t.badges.prod
+      ] })
+    ] })
+  ] });
+};
+
+// src/components/package-list.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var WINDOW_SIZE = 7;
+var PackageList = ({ items, cursor, loading, t }) => {
+  const startIdx = Math.max(
+    0,
+    Math.min(
+      cursor - Math.floor(WINDOW_SIZE / 2),
+      Math.max(0, items.length - WINDOW_SIZE)
+    )
+  );
+  const window = items.slice(startIdx, startIdx + WINDOW_SIZE);
+  return /* @__PURE__ */ jsx6(
+    Box6,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: theme.colors.border,
+      padding: 1,
+      marginY: 1,
+      minHeight: 10,
+      children: loading ? /* @__PURE__ */ jsx6(Box6, { marginY: 2, justifyContent: "center", children: /* @__PURE__ */ jsx6(Text6, { color: theme.colors.warning, children: t.list.scanning }) }) : items.length === 0 ? /* @__PURE__ */ jsx6(Box6, { marginY: 2, justifyContent: "center", children: /* @__PURE__ */ jsx6(Text6, { color: theme.colors.success, children: t.list.allUpToDate }) }) : /* @__PURE__ */ jsxs6(Fragment, { children: [
+        startIdx > 0 && /* @__PURE__ */ jsx6(Text6, { color: theme.colors.muted, children: t.list.moreAbove }),
+        window.map((item, idx) => /* @__PURE__ */ jsx6(
+          PackageRow,
+          {
+            item,
+            isFocused: startIdx + idx === cursor,
+            t
+          },
+          `${item.coordinate?.identifier || item.name}_${startIdx + idx}`
+        )),
+        startIdx + WINDOW_SIZE < items.length && /* @__PURE__ */ jsx6(Text6, { color: theme.colors.muted, children: t.list.moreBelow(items.length - (startIdx + WINDOW_SIZE)) })
+      ] })
+    }
+  );
+};
+
+// src/components/status-bar.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+
+// src/components/mascot.tsx
+import { useState as useState6, useEffect as useEffect4 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var ChickenMascot = ({ state = "idle", t, ecosystem = "npm" }) => {
+  const [frame, setFrame] = useState6(0);
+  const [chirpIndex, setChirpIndex] = useState6(0);
+  useEffect4(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % 6);
+    }, 1400);
+    return () => clearInterval(timer);
+  }, []);
+  useEffect4(() => {
+    const chirpTimer = setInterval(() => {
+      setChirpIndex((prev) => prev + 1);
+    }, 4200);
+    return () => clearInterval(chirpTimer);
+  }, []);
+  let chickFace = "( \u2022\u04E9\u2022 )";
+  let wingLeft = " ";
+  let wingRight = " ";
+  let currentChirp = "";
+  if (state === "scanning") {
+    const scanningFaces = ["( \u2022\u04E9\u2022 )?", "( \u02D8\u04E9\u02D8 )\u{1F50D}", "( \u2022\u04E9\u2022 )\u{1F50E}", "( \u1D54\u04E9\u1D54 )?"];
+    chickFace = scanningFaces[frame % scanningFaces.length];
+    currentChirp = t.mascot.scanningChirps[chirpIndex % t.mascot.scanningChirps.length];
+  } else if (state === "updating") {
+    const updatingFrames = [
+      { face: "( \u2022\u04E9\u2022 )", l: "\u0E07", r: "\u0E07" },
+      { face: "( \u02D8\u04E9\u02D8 )", l: "~", r: "~" },
+      { face: "( \u2022\u04E9\u2022 )", l: "\u1559", r: "\u1557" },
+      { face: "( \u1D54\u04E9\u1D54 )", l: "\u0E07", r: "\u0E07" }
+    ];
+    const cur = updatingFrames[frame % updatingFrames.length];
+    chickFace = cur.face;
+    wingLeft = cur.l;
+    wingRight = cur.r;
+    currentChirp = t.mascot.updatingChirps[chirpIndex % t.mascot.updatingChirps.length];
+  } else if (state === "success") {
+    const successFaces = ["\\( \u1D54\u04E9\u1D54 )/", "\\( \u2022\u04E9\u2022 )/ \u{1F389}", "*( \u1D54\u04E9\u1D54 )* \u{1FAB6}", "\\( \u1D54\u04E9\u1D54 )/ \u2728"];
+    chickFace = successFaces[frame % successFaces.length];
+    currentChirp = t.mascot.successChirps[chirpIndex % t.mascot.successChirps.length];
+  } else {
+    const idleFaces = [
+      { face: "( \u2022\u04E9\u2022 )", l: " ", r: " " },
+      { face: "( \u2022\u04E9\u2022 )", l: " ", r: " " },
+      { face: "( -\u04E9- )", l: " ", r: " " },
+      // Blinzeln
+      { face: "( \u1D54\u04E9\u1D54 )", l: " ", r: " " },
+      // Lächeln
+      { face: "( \u2022\u04E9- )", l: " ", r: " " },
+      // Zwinkern
+      { face: "( \u02D8\u04E9\u02D8 )", l: " ", r: "~\u{1FAB6}" }
+      // Flausch-Feder
+    ];
+    const cur = idleFaces[frame % idleFaces.length];
+    chickFace = cur.face;
+    wingLeft = cur.l;
+    wingRight = cur.r;
+    const chirpsPool = ecosystem === "maven" ? [...t.mascot.idleChirps, ...t.mascot.mavenChirps] : t.mascot.idleChirps;
+    currentChirp = chirpsPool[chirpIndex % chirpsPool.length];
+  }
+  return /* @__PURE__ */ jsxs7(Box7, { alignItems: "center", children: [
+    /* @__PURE__ */ jsx7(Text7, { color: theme.colors.mascotComb, bold: true, children: wingLeft === " " ? " " : wingLeft }),
+    /* @__PURE__ */ jsx7(Text7, { color: theme.colors.mascotBody, bold: true, children: chickFace }),
+    /* @__PURE__ */ jsx7(Text7, { color: theme.colors.brandLight, bold: true, children: wingRight }),
+    currentChirp ? /* @__PURE__ */ jsx7(Box7, { marginLeft: 1, children: /* @__PURE__ */ jsx7(Text7, { color: theme.colors.brandLight, italic: true, children: currentChirp }) }) : null
+  ] });
+};
+
+// src/components/status-bar.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var StatusBar = ({
+  counts,
+  visibleCount,
+  t,
+  mascotState = "idle",
+  ecosystem = "npm"
+}) => {
+  return /* @__PURE__ */ jsxs8(
+    Box8,
+    {
+      borderStyle: "single",
+      borderColor: theme.colors.borderMuted,
+      paddingX: 1,
+      justifyContent: "space-between",
+      alignItems: "center",
+      children: [
+        /* @__PURE__ */ jsxs8(Box8, { children: [
+          /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
+            t.status.selectedOf(counts.selectedCount, visibleCount),
+            " "
+          ] }),
+          /* @__PURE__ */ jsx8(Text8, { color: theme.colors.muted, children: t.status.breakdown(counts.patchCount, counts.minorCount, counts.majorCount) })
+        ] }),
+        /* @__PURE__ */ jsx8(ChickenMascot, { state: mascotState, t, ecosystem })
+      ]
+    }
+  );
+};
+
+// src/components/controls-bar.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+var ControlsBar = ({ t }) => /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, flexWrap: "wrap", children: [
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[\u2191/\u2193]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.navigate,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[Space]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.toggle,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[A]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.all,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[Tab/1/2/3]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.tabs,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[W]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.workspace,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[V]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.version,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brand, bold: true, children: "[E]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.ecosystem,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.brandLight, bold: true, children: "[L]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.language,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.success, bold: true, children: "[U]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.update,
+    " \u2502 "
+  ] }),
+  /* @__PURE__ */ jsx9(Text9, { color: theme.colors.danger, bold: true, children: "[Q]" }),
+  /* @__PURE__ */ jsxs9(Text9, { color: theme.colors.muted, children: [
+    " ",
+    t.controls.quit
+  ] })
+] });
+
+// src/components/workspace-modal.tsx
+import { Box as Box10, Text as Text10 } from "ink";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+var WorkspaceModal = ({ modules, focusedIndex, strategy, t }) => /* @__PURE__ */ jsxs10(
+  Box10,
+  {
+    flexDirection: "column",
+    borderStyle: "single",
+    borderColor: theme.colors.brand,
+    padding: 1,
+    marginY: 1,
+    children: [
+      /* @__PURE__ */ jsxs10(Text10, { bold: true, color: theme.colors.brandLight, children: [
+        strategy.icon,
+        " ",
+        t.workspace.modalTitle
+      ] }),
+      /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", marginTop: 1, children: modules.map((m, idx) => /* @__PURE__ */ jsxs10(Box10, { children: [
+        /* @__PURE__ */ jsxs10(
+          Text10,
+          {
+            color: idx === focusedIndex ? theme.colors.brandLight : theme.colors.white,
+            bold: idx === focusedIndex,
+            children: [
+              idx === focusedIndex ? " \u2794 " : "   ",
+              m.name.slice(0, 48).padEnd(48)
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs10(Text10, { color: theme.colors.muted, children: [
+          "(",
+          m.relPath,
+          ")"
+        ] })
+      ] }, m.path)) })
+    ]
+  }
+);
+
+// src/components/version-modal.tsx
+import { useState as useState7, useEffect as useEffect5, useMemo as useMemo4 } from "react";
+import { Box as Box11, Text as Text11, useInput } from "ink";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+var WINDOW_SIZE2 = 8;
+var VersionModal = ({
+  candidate,
+  strategy,
+  t,
+  onSelect,
+  onCancel
+}) => {
+  const [allVersions, setAllVersions] = useState7([]);
+  const [loading, setLoading] = useState7(true);
+  const [filterText, setFilterText] = useState7("");
+  const [cursor, setCursor] = useState7(0);
+  useEffect5(() => {
+    let active = true;
+    setLoading(true);
+    strategy.registry.getAllVersions(candidate.coordinate).then((versions) => {
+      if (!active) return;
+      setAllVersions(versions);
+      setCursor(0);
+    }).catch(() => {
+      if (!active) return;
+      setAllVersions([]);
+    }).finally(() => {
+      if (active) setLoading(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [strategy, candidate.coordinate]);
+  const filtered = useMemo4(() => {
+    if (!filterText.trim()) return allVersions;
+    const lower = filterText.toLowerCase();
+    return allVersions.filter((v) => v.toLowerCase().includes(lower));
+  }, [allVersions, filterText]);
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      if (filtered.length > 0 && cursor >= 0 && cursor < filtered.length) {
+        onSelect(filtered[cursor]);
+      }
+      return;
+    }
+    if (key.upArrow || input === "k" && filterText === "") {
+      setCursor((prev) => Math.max(0, prev - 1));
+      return;
+    }
+    if (key.downArrow || input === "j" && filterText === "") {
+      setCursor((prev) => Math.min(filtered.length - 1, prev + 1));
+      return;
+    }
+    if (key.pageUp) {
+      setCursor((prev) => Math.max(0, prev - 5));
+      return;
+    }
+    if (key.pageDown) {
+      setCursor((prev) => Math.min(filtered.length - 1, prev + 5));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setFilterText((prev) => prev.slice(0, -1));
+      setCursor(0);
+      return;
+    }
+    if (input === "q" && filterText === "") {
+      onCancel();
+      return;
+    }
+    if (input && !key.ctrl && !key.meta && /^[\w.\-+~]$/.test(input)) {
+      setFilterText((prev) => prev + input);
+      setCursor(0);
+    }
+  });
+  const startIdx = Math.max(
+    0,
+    Math.min(
+      cursor - Math.floor(WINDOW_SIZE2 / 2),
+      Math.max(0, filtered.length - WINDOW_SIZE2)
+    )
+  );
+  const windowed = filtered.slice(startIdx, startIdx + WINDOW_SIZE2);
+  return /* @__PURE__ */ jsxs11(
+    Box11,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.colors.brand,
+      padding: 1,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsxs11(Box11, { justifyContent: "space-between", marginBottom: 1, children: [
+          /* @__PURE__ */ jsxs11(Text11, { bold: true, color: theme.colors.brandLight, children: [
+            theme.icon,
+            " ",
+            t.versionModal.title(candidate.coordinate.identifier)
+          ] }),
+          /* @__PURE__ */ jsx11(Text11, { color: theme.colors.muted, children: t.versionModal.current(candidate.currentRange) })
+        ] }),
+        /* @__PURE__ */ jsxs11(
+          Box11,
+          {
+            borderStyle: "single",
+            borderColor: theme.colors.border,
+            paddingX: 1,
+            marginBottom: 1,
+            children: [
+              /* @__PURE__ */ jsxs11(Text11, { bold: true, color: theme.colors.white, children: [
+                "Filter:",
+                " "
+              ] }),
+              /* @__PURE__ */ jsx11(Text11, { color: filterText ? theme.colors.brandLight : theme.colors.muted, children: filterText || t.versionModal.filterPlaceholder }),
+              filterText ? /* @__PURE__ */ jsx11(Text11, { color: theme.colors.brandLight, bold: true, children: "_" }) : null,
+              filterText ? /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsxs11(Text11, { color: theme.colors.muted, children: [
+                "(",
+                filtered.length,
+                " Treffer)"
+              ] }) }) : null
+            ]
+          }
+        ),
+        loading ? /* @__PURE__ */ jsx11(Box11, { marginY: 2, justifyContent: "center", children: /* @__PURE__ */ jsxs11(Text11, { color: theme.colors.warning, children: [
+          "\u23F3 ",
+          t.versionModal.loading
+        ] }) }) : filtered.length === 0 ? /* @__PURE__ */ jsx11(Box11, { marginY: 2, justifyContent: "center", children: /* @__PURE__ */ jsxs11(Text11, { color: theme.colors.danger, children: [
+          "\u274C ",
+          t.versionModal.noVersions
+        ] }) }) : /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+          startIdx > 0 && /* @__PURE__ */ jsxs11(Text11, { color: theme.colors.muted, children: [
+            "\u25B2 \u2026 ",
+            startIdx,
+            " weitere oben"
+          ] }),
+          windowed.map((ver, idx) => {
+            const actualIdx = startIdx + idx;
+            const isFocused = actualIdx === cursor;
+            const isLatest = ver === candidate.latest;
+            const isCurrent = ver === candidate.currentClean;
+            const isPre = isPreReleaseVersion(ver);
+            const preTag = isPre ? extractPreReleaseTag(ver) : void 0;
+            return /* @__PURE__ */ jsxs11(Box11, { justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsxs11(Box11, { children: [
+                /* @__PURE__ */ jsx11(
+                  Text11,
+                  {
+                    color: isFocused ? theme.colors.brandLight : theme.colors.muted,
+                    bold: isFocused,
+                    children: isFocused ? " \u2794 " : "   "
+                  }
+                ),
+                /* @__PURE__ */ jsx11(
+                  Text11,
+                  {
+                    bold: isFocused,
+                    color: isFocused ? theme.colors.brandLight : isCurrent ? theme.colors.muted : theme.colors.white,
+                    children: ver.padEnd(28)
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxs11(Box11, { children: [
+                isCurrent && /* @__PURE__ */ jsxs11(Text11, { color: theme.colors.muted, children: [
+                  "[",
+                  t.versionModal.currentBadge,
+                  "]",
+                  " "
+                ] }),
+                isLatest && /* @__PURE__ */ jsxs11(Text11, { bold: true, color: theme.colors.brand, children: [
+                  "[",
+                  t.versionModal.latestBadge,
+                  "]",
+                  " "
+                ] }),
+                isPre && /* @__PURE__ */ jsxs11(Text11, { bold: true, color: "#E040FB", children: [
+                  "[",
+                  preTag || "PRE",
+                  "]",
+                  " "
+                ] })
+              ] })
+            ] }, ver);
+          }),
+          startIdx + WINDOW_SIZE2 < filtered.length && /* @__PURE__ */ jsxs11(Text11, { color: theme.colors.muted, children: [
+            "\u25BC \u2026 ",
+            filtered.length - (startIdx + WINDOW_SIZE2),
+            " weitere unten"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx11(
+          Box11,
+          {
+            borderStyle: "single",
+            borderColor: theme.colors.border,
+            paddingX: 1,
+            marginTop: 1,
+            children: /* @__PURE__ */ jsx11(Text11, { color: theme.colors.muted, children: t.versionModal.hint })
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/summary-view.tsx
+import { Box as Box12, Text as Text12 } from "ink";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+var SummaryView = ({ summary, module, strategy, t }) => {
+  const vStatus = summary.verificationStatus || summary.postScriptStatus;
+  const vLabel = summary.verificationLabel || summary.postScriptLabel || "Verifikation";
+  const vDetails = summary.verificationDetails || summary.postScriptDetails;
+  return /* @__PURE__ */ jsxs12(
+    Box12,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: theme.colors.success,
+      padding: 1,
+      marginY: 1,
+      children: [
+        /* @__PURE__ */ jsxs12(Box12, { justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsxs12(Text12, { bold: true, color: theme.colors.success, children: [
+            strategy.icon,
+            " ",
+            t.summary.title
+          ] }),
+          /* @__PURE__ */ jsx12(ChickenMascot, { state: "success", t, ecosystem: strategy.ecosystem })
+        ] }),
+        /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginY: 1, children: [
+          /* @__PURE__ */ jsx12(Text12, { color: theme.colors.white, children: t.summary.successCount(summary.updatedCount, module.relPath) }),
+          /* @__PURE__ */ jsxs12(Box12, { marginTop: 1, children: [
+            /* @__PURE__ */ jsxs12(
+              Text12,
+              {
+                color: summary.auditSeverity === "clean" ? theme.colors.success : theme.colors.warning,
+                bold: true,
+                children: [
+                  t.summary.securityAudit,
+                  " "
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx12(Text12, { children: summary.auditMessage })
+          ] }),
+          summary.fundingMessage && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: theme.colors.muted, children: t.summary.funding(summary.fundingMessage) }) }),
+          vStatus && /* @__PURE__ */ jsxs12(Box12, { marginTop: 1, flexDirection: "column", children: [
+            /* @__PURE__ */ jsx12(
+              Text12,
+              {
+                color: vStatus === "clean" ? theme.colors.success : theme.colors.warning,
+                bold: true,
+                children: t.summary.postScript(vLabel)
+              }
+            ),
+            /* @__PURE__ */ jsx12(Text12, { color: theme.colors.muted, children: vDetails })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx12(Box12, { borderStyle: "single", borderColor: theme.colors.borderMuted, paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { bold: true, color: theme.colors.brandLight, children: t.summary.backHint }) })
+      ]
+    }
+  );
+};
+
+// src/components/updating-view.tsx
+import { Box as Box13, Text as Text13 } from "ink";
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+var UpdatingView = ({ step, t, ecosystem = "npm" }) => /* @__PURE__ */ jsxs13(
+  Box13,
+  {
+    flexDirection: "column",
+    borderStyle: "round",
+    borderColor: theme.colors.brand,
+    padding: 1,
+    marginY: 1,
+    children: [
+      /* @__PURE__ */ jsxs13(Box13, { justifyContent: "space-between", alignItems: "center", children: [
+        /* @__PURE__ */ jsx13(Text13, { bold: true, color: theme.colors.brandLight, children: t.updating.title }),
+        /* @__PURE__ */ jsx13(ChickenMascot, { state: "updating", t, ecosystem })
+      ] }),
+      /* @__PURE__ */ jsx13(Box13, { marginY: 1, children: /* @__PURE__ */ jsx13(Text13, { bold: true, color: theme.colors.brandLight, children: step }) }),
+      /* @__PURE__ */ jsx13(Text13, { color: theme.colors.muted, children: t.updating.doNotClose })
+    ]
+  }
+);
+
+// src/app.tsx
+import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+var App = ({ config }) => {
+  const { exit } = useApp();
+  const [view, setView] = useState8("splash");
+  const [modalIndex, setModalIndex] = useState8(0);
+  const [versionPickerCandidate, setVersionPickerCandidate] = useState8(null);
+  const [ecosystem, setEcosystem] = useState8("npm");
+  const strategy = useMemo5(() => EcosystemFactory.getStrategy(ecosystem), [ecosystem]);
+  const nextEcosystem = ecosystem === "npm" ? "maven" : "npm";
+  const nextStrategy = useMemo5(() => EcosystemFactory.getStrategy(nextEcosystem), [nextEcosystem]);
+  const toggleEcosystem = useCallback5(() => {
+    setEcosystem((prev) => prev === "npm" ? "maven" : "npm");
+  }, []);
+  const { locale, toggleLocale, t } = useI18n(resolveInitialLocale(config.locale));
+  const ws = useWorkspaces(strategy, config.rootDir);
+  const pkg = usePackages(
+    strategy,
+    ws.active,
+    ws.internalIds,
+    config.excludeScopes,
+    config.channel
+  );
+  const updater = useUpdater(strategy, config.rootDir, setView, {
+    script: config.postUpdateScript,
+    label: config.postUpdateLabel
+  });
+  const mascotState = view === "updating" ? "updating" : pkg.loading ? "scanning" : view === "summary" ? "success" : "idle";
+  useInput2((input, key) => {
+    if (view === "version_modal") {
+      return;
+    }
+    if (input === "q" && view !== "updating") {
+      exit();
+      return;
+    }
+    if (view === "splash") {
+      if (key.return || input === " ") {
+        setView("dashboard");
+        pkg.scan();
+      }
+      return;
+    }
+    if ((input === "l" || input === "L") && view !== "updating") {
+      toggleLocale();
+      return;
+    }
+    if (view === "workspace_modal") {
+      if (key.upArrow || input === "k") {
+        setModalIndex((i) => Math.max(0, i - 1));
+      } else if (key.downArrow || input === "j") {
+        setModalIndex((i) => Math.min(ws.modules.length - 1, i + 1));
+      } else if (key.return) {
+        ws.setActiveIndex(modalIndex);
+        setView("dashboard");
+        pkg.scan();
+      } else if (key.escape || input === "w") {
+        setView("dashboard");
+      }
+      return;
+    }
+    if (view === "summary") {
+      if (key.return || input === "d") {
+        setView("dashboard");
+        pkg.scan();
+      }
+      return;
+    }
+    if (view === "dashboard") {
+      if (input === "e" || input === "E") {
+        toggleEcosystem();
+        return;
+      }
+      if (input === "w") {
+        setModalIndex(ws.activeIndex);
+        setView("workspace_modal");
+      } else if (input === "v" || input === "V") {
+        const focused = pkg.visible[pkg.cursor];
+        if (focused) {
+          setVersionPickerCandidate(focused);
+          setView("version_modal");
+        }
+      } else if (key.tab) {
+        pkg.cycleTab();
+      } else if (input === "1") {
+        pkg.switchTab("all");
+      } else if (input === "2") {
+        pkg.switchTab("prod");
+      } else if (input === "3") {
+        pkg.switchTab("dev");
+      } else if (key.upArrow || input === "k") {
+        pkg.setCursor((i) => Math.max(0, i - 1));
+      } else if (key.downArrow || input === "j") {
+        pkg.setCursor((i) => Math.min(pkg.visible.length - 1, i + 1));
+      } else if (input === " ") {
+        const focused = pkg.visible[pkg.cursor];
+        if (focused) pkg.togglePackage(focused.coordinate.identifier);
+      } else if (input === "a") {
+        pkg.toggleAllVisible();
+      } else if (input === "r") {
+        pkg.scan();
+      } else if (input === "u" && pkg.counts.selectedCount > 0 && !pkg.loading) {
+        const selected = pkg.packages.filter((p) => p.selected);
+        updater.run(ws.active, selected, t);
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", padding: 1, children: [
+    view === "splash" && /* @__PURE__ */ jsx14(
+      SplashScreen,
+      {
+        onComplete: () => {
+          setView("dashboard");
+          pkg.scan();
+        },
+        author: config.author
+      }
+    ),
+    view !== "splash" && /* @__PURE__ */ jsxs14(Fragment2, { children: [
+      /* @__PURE__ */ jsx14(
+        Header,
+        {
+          author: config.author,
+          t,
+          currentLocale: locale,
+          strategy,
+          nextStrategyName: `${nextStrategy.icon} ${nextStrategy.displayName}`,
+          channel: config.channel
+        }
+      ),
+      view === "workspace_modal" && /* @__PURE__ */ jsx14(
+        WorkspaceModal,
+        {
+          modules: ws.modules,
+          focusedIndex: modalIndex,
+          strategy,
+          t
+        }
+      ),
+      view === "version_modal" && versionPickerCandidate && /* @__PURE__ */ jsx14(
+        VersionModal,
+        {
+          candidate: versionPickerCandidate,
+          strategy,
+          t,
+          onSelect: (chosenVersion) => {
+            pkg.setCustomVersion(versionPickerCandidate.coordinate.identifier, chosenVersion);
+            setView("dashboard");
+            setVersionPickerCandidate(null);
+          },
+          onCancel: () => {
+            setView("dashboard");
+            setVersionPickerCandidate(null);
+          }
+        }
+      ),
+      view === "updating" && /* @__PURE__ */ jsx14(UpdatingView, { step: updater.step, t, ecosystem: strategy.ecosystem }),
+      view === "summary" && updater.summary && /* @__PURE__ */ jsx14(
+        SummaryView,
+        {
+          summary: updater.summary,
+          module: ws.active,
+          strategy,
+          t
+        }
+      ),
+      view === "dashboard" && /* @__PURE__ */ jsxs14(Fragment2, { children: [
+        /* @__PURE__ */ jsx14(
+          WorkspaceBar,
+          {
+            module: ws.active,
+            excludeScopes: config.excludeScopes,
+            strategy,
+            t
+          }
+        ),
+        /* @__PURE__ */ jsx14(
+          TabBar,
+          {
+            activeTab: pkg.activeTab,
+            counts: pkg.counts,
+            strategy,
+            t
+          }
+        ),
+        /* @__PURE__ */ jsx14(
+          PackageList,
+          {
+            items: pkg.visible,
+            cursor: pkg.cursor,
+            loading: pkg.loading,
+            t
+          }
+        ),
+        /* @__PURE__ */ jsx14(
+          StatusBar,
+          {
+            counts: pkg.counts,
+            visibleCount: pkg.visible.length,
+            t,
+            mascotState,
+            ecosystem: strategy.ecosystem
+          }
+        ),
+        /* @__PURE__ */ jsx14(ControlsBar, { t })
+      ] })
+    ] })
+  ] });
+};
+
+// src/cli/parser.ts
+function parseCliArgs(args) {
+  const [first, ...rest] = args;
+  if (!first || first === "--help" || first === "-h" || first === "help") {
+    if (first === "--help" || first === "-h" || first === "help") {
+      return { subcommand: "help" };
+    }
+    return {};
+  }
+  if (first === "mcp" || first === "serve") {
+    return { subcommand: "mcp" };
+  }
+  const validCommands = ["modules", "scan", "versions", "update", "init"];
+  const isSubcommand = validCommands.includes(first);
+  const subcommand = isSubcommand ? first : void 0;
+  const remaining = isSubcommand ? rest : args;
+  const result = { subcommand };
+  const positionals = [];
+  for (let i = 0; i < remaining.length; i++) {
+    const arg = remaining[i];
+    if (arg === "--json") {
+      result.json = true;
+    } else if (arg === "--all") {
+      result.all = true;
+    } else if (arg === "--all-modules") {
+      result.allModules = true;
+    } else if (arg === "--allow-major") {
+      result.allowMajor = true;
+    } else if (arg === "--dry-run") {
+      result.dryRun = true;
+    } else if (arg === "--skip-verify") {
+      result.skipVerify = true;
+    } else if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg.startsWith("--ecosystem=")) {
+      const val = arg.split("=")[1];
+      if (val === "npm" || val === "maven") result.ecosystem = val;
+    } else if (arg === "-e" || arg === "--ecosystem") {
+      const val = remaining[++i];
+      if (val === "npm" || val === "maven") result.ecosystem = val;
+    } else if (arg.startsWith("--module=")) {
+      result.module = arg.split("=")[1];
+    } else if (arg === "-m" || arg === "--module") {
+      result.module = remaining[++i];
+    } else if (arg.startsWith("--channel=")) {
+      const val = arg.split("=")[1];
+      if (val === "stable" || val === "all") result.channel = val;
+    } else if (arg === "-c" || arg === "--channel") {
+      const val = remaining[++i];
+      if (val === "stable" || val === "all") result.channel = val;
+    } else if (arg.startsWith("--packages=")) {
+      result.packages = arg.split("=")[1]?.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (arg === "-p" || arg === "--packages") {
+      result.packages = remaining[++i]?.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (!arg.startsWith("-")) {
+      positionals.push(arg);
+    }
+  }
+  if (positionals.length > 0) {
+    result.positional = positionals[0];
+  }
+  return result;
+}
+function printCliHelp() {
+  console.log(`
+\u{1FAB6} Elevate \u2014 Modern Polyglot Dependency Manager & Updater
+
+USAGE:
+  elevate                               Launch interactive terminal dashboard (TUI)
+  elevate <subcommand> [flags]          Execute headless command (for CI/CD & AI agents)
+  elevate mcp                           Start Model Context Protocol (MCP) server
+
+SUBCOMMANDS:
+  modules                               List all detected repository modules
+  scan                                  Scan dependencies for available updates
+  versions <package>                    List all published versions of a package
+  update                                Apply updates to specified or all packages
+  init                                  Configure AI coding tools (MCP + agent skills)
+  mcp                                   Start stdio-based MCP server
+
+FLAGS:
+  -e, --ecosystem <npm|maven>          Target ecosystem (default: npm)
+  -m, --module <name|path>             Target module ID or relative path (default: root)
+  -c, --channel <stable|all>           Release channel (default: stable)
+  -p, --packages <pkg1,pkg2@1.2.3>     Comma-separated list of packages to update
+      --all                            Update all eligible dependencies
+      --all-modules                    Scan across all discovered monorepo modules
+      --allow-major                    Allow breaking major version upgrades
+      --dry-run                        Simulate updates without modifying any files
+      --skip-verify                    Skip post-update build & test verification
+      --json                           Format output as machine-readable JSON
+  -h, --help                           Display this help message
+
+EXAMPLES:
+  elevate scan --json
+  elevate scan --ecosystem=maven --channel=stable --all-modules --json
+  elevate versions chalk --ecosystem=npm --json
+  elevate update --module=apps/e2e-cockpit --packages=chalk@5.6.2 --json
+  elevate update --ecosystem=npm --all --allow-major --dry-run
+  elevate init
+  elevate init --json
+`);
+}
+
+// src/cli/command-modules.ts
+async function handleModulesCommand(options, config) {
+  const ecosystem = options.ecosystem ?? "npm";
+  const strategy = EcosystemFactory.getStrategy(ecosystem);
+  const modules = await strategy.discovery.discover(config.rootDir);
+  if (options.json) {
+    console.log(JSON.stringify({ ecosystem, count: modules.length, modules }, null, 2));
+    return 0;
+  }
+  console.log(`
+\u{1FAB6} Discovered ${strategy.icon} ${strategy.displayName} Modules (${modules.length}):
+`);
+  for (const m of modules) {
+    const isRootBadge = m.isRoot ? " [ROOT]" : "";
+    console.log(`  \u2022 ${m.name.padEnd(45)} (${m.relPath})${isRootBadge}`);
+  }
+  console.log("");
+  return 0;
+}
+
+// src/cli/command-scan.ts
+async function handleScanCommand(options, config) {
+  const ecosystem = options.ecosystem ?? "npm";
+  const channel = options.channel ?? config.channel ?? "stable";
+  const strategy = EcosystemFactory.getStrategy(ecosystem);
+  const modules = await strategy.discovery.discover(config.rootDir);
+  if (modules.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: `No ${strategy.displayName} modules found.`, ecosystem }, null, 2));
+    } else {
+      console.error(`\u274C No ${strategy.displayName} modules found.`);
+    }
+    return 1;
+  }
+  const internalIds = /* @__PURE__ */ new Set();
+  for (const m of modules) {
+    if (m.id) internalIds.add(m.id);
+    if (m.name) internalIds.add(m.name);
+  }
+  const targetModules = [];
+  if (options.allModules) {
+    targetModules.push(...modules);
+  } else if (options.module) {
+    const match = modules.find(
+      (m) => m.id.toLowerCase() === options.module.toLowerCase() || m.relPath.toLowerCase() === options.module.toLowerCase() || m.path.toLowerCase().endsWith(options.module.toLowerCase())
+    );
+    if (!match) {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { error: `Module '${options.module}' not found.`, available: modules.map((m) => m.relPath) },
+            null,
+            2
+          )
+        );
+      } else {
+        console.error(`\u274C Module '${options.module}' not found.`);
+      }
+      return 1;
+    }
+    targetModules.push(match);
+  } else {
+    targetModules.push(modules[0]);
+  }
+  const allResults = [];
+  let totalUpdatesCount = 0;
+  for (const mod of targetModules) {
+    try {
+      const updates = await strategy.reader.scan(mod, config.excludeScopes, internalIds, channel);
+      allResults.push({ module: mod, updates });
+      totalUpdatesCount += updates.length;
+    } catch {
+      allResults.push({ module: mod, updates: [] });
+    }
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ecosystem,
+          channel,
+          scannedModules: targetModules.length,
+          totalUpdatesCount,
+          results: allResults.map((r) => ({
+            moduleId: r.module.id,
+            modulePath: r.module.relPath,
+            updateCount: r.updates.length,
+            updates: r.updates.map((u) => ({
+              identifier: u.coordinate.identifier,
+              currentRange: u.currentRange,
+              currentClean: u.currentClean,
+              latest: u.latest,
+              newRange: u.newRange,
+              diff: u.diff,
+              scope: u.scope,
+              isPreRelease: u.isPreRelease ?? false,
+              preReleaseTag: u.preReleaseTag
+            }))
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return totalUpdatesCount > 0 ? 1 : 0;
+  }
+  console.log(`
+\u{1FAB6} Elevate Scan Results (${strategy.icon} ${strategy.displayName}, Channel: ${channel}):
+`);
+  for (const r of allResults) {
+    console.log(`\u{1F4E6} Module: ${r.module.name} (${r.module.relPath}) \u2014 ${r.updates.length} update(s) available`);
+    if (r.updates.length === 0) {
+      console.log("   \u2728 All dependencies are up to date.\n");
+      continue;
+    }
+    for (const u of r.updates) {
+      const diffTag = `[${u.diff.toUpperCase()}]`.padEnd(9);
+      const preBadge = u.isPreRelease ? `[${u.preReleaseTag || "PRE"}] ` : "";
+      console.log(
+        `   \u2022 ${diffTag} ${preBadge}${u.coordinate.identifier.padEnd(36)} ${u.currentRange.padEnd(12)} \u2794 ${u.latest}`
+      );
+    }
+    console.log("");
+  }
+  console.log(`Summary: ${totalUpdatesCount} pending update(s) across ${targetModules.length} module(s).
+`);
+  return totalUpdatesCount > 0 ? 1 : 0;
+}
+
+// src/cli/command-versions.ts
+async function handleVersionsCommand(options) {
+  const pkgIdentifier = options.positional;
+  if (!pkgIdentifier) {
+    console.error("\u274C Error: Please specify a package name (e.g. `elevate versions chalk`).");
+    return 1;
+  }
+  const ecosystem = options.ecosystem ?? (pkgIdentifier.includes(":") ? "maven" : "npm");
+  const strategy = EcosystemFactory.getStrategy(ecosystem);
+  let coordinate;
+  if (ecosystem === "maven") {
+    const parts = pkgIdentifier.split(":");
+    coordinate = {
+      identifier: pkgIdentifier,
+      group: parts[0],
+      artifact: parts[1] || parts[0],
+      ecosystem: "maven"
+    };
+  } else {
+    coordinate = {
+      identifier: pkgIdentifier,
+      artifact: pkgIdentifier,
+      ecosystem: "npm"
+    };
+  }
+  const versions = await strategy.registry.getAllVersions(coordinate);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ecosystem,
+          package: pkgIdentifier,
+          totalCount: versions.length,
+          latest: versions[0] || null,
+          versions: versions.map((v) => ({
+            version: v,
+            isPreRelease: isPreReleaseVersion(v),
+            tag: extractPreReleaseTag(v)
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  console.log(`
+\u{1FAB6} Published versions for '${pkgIdentifier}' (${strategy.icon} ${strategy.displayName}, ${versions.length} total):
+`);
+  for (const v of versions.slice(0, 30)) {
+    const isPre = isPreReleaseVersion(v);
+    const tag = isPre ? `[${extractPreReleaseTag(v) || "PRE"}]` : "[STABLE]";
+    console.log(`  \u2022 ${v.padEnd(25)} ${tag}`);
+  }
+  if (versions.length > 30) {
+    console.log(`  \u2026 and ${versions.length - 30} older versions.
+`);
+  } else {
+    console.log("");
+  }
+  return 0;
+}
+
+// src/cli/command-update.ts
+import semver5 from "semver";
+async function handleUpdateCommand(options, config) {
+  const ecosystem = options.ecosystem ?? "npm";
+  const strategy = EcosystemFactory.getStrategy(ecosystem);
+  const modules = await strategy.discovery.discover(config.rootDir);
+  if (modules.length === 0) {
+    console.error(`\u274C No ${strategy.displayName} modules found.`);
+    return 1;
+  }
+  let targetModule = modules[0];
+  if (options.module) {
+    const match = modules.find(
+      (m) => m.id.toLowerCase() === options.module.toLowerCase() || m.relPath.toLowerCase() === options.module.toLowerCase() || m.path.toLowerCase().endsWith(options.module.toLowerCase())
+    );
+    if (!match) {
+      console.error(`\u274C Module '${options.module}' not found.`);
+      return 1;
+    }
+    targetModule = match;
+  }
+  const internalIds = /* @__PURE__ */ new Set();
+  for (const m of modules) {
+    if (m.id) internalIds.add(m.id);
+    if (m.name) internalIds.add(m.name);
+  }
+  const availableUpdates = await strategy.reader.scan(
+    targetModule,
+    config.excludeScopes,
+    internalIds,
+    options.channel ?? "stable"
+  );
+  const updatesToApply = [];
+  if (options.all) {
+    for (const c of availableUpdates) {
+      if (c.diff === "major" && !options.allowMajor) {
+        if (!options.json) {
+          console.warn(`\u26A0\uFE0F  Skipping major update for '${c.coordinate.identifier}' (requires --allow-major)`);
+        }
+        continue;
+      }
+      updatesToApply.push(c);
+    }
+  } else if (options.packages && options.packages.length > 0) {
+    for (const item of options.packages) {
+      let [name, targetVer] = item.split("@");
+      if (item.startsWith("@") && item.includes("@", 1)) {
+        const atIdx = item.lastIndexOf("@");
+        name = item.slice(0, atIdx);
+        targetVer = item.slice(atIdx + 1);
+      }
+      const found = availableUpdates.find((u) => u.coordinate.identifier === name);
+      if (found) {
+        if (targetVer) {
+          const prefix = found.currentRange.startsWith("~") ? "~" : found.currentRange.startsWith("^") ? "^" : "";
+          const diff = semver5.valid(targetVer) && found.currentClean ? semver5.diff(found.currentClean, targetVer) || "minor" : "minor";
+          if (diff === "major" && !options.allowMajor) {
+            console.error(`\u274C Error: '${name}' requires a major version upgrade to ${targetVer}. Please pass --allow-major.`);
+            return 1;
+          }
+          updatesToApply.push({
+            ...found,
+            newRange: `${prefix}${targetVer}`,
+            diff,
+            selected: true
+          });
+        } else {
+          if (found.diff === "major" && !options.allowMajor) {
+            console.error(`\u274C Error: '${name}' is a major update (${found.currentClean} \u2794 ${found.latest}). Please pass --allow-major.`);
+            return 1;
+          }
+          updatesToApply.push({ ...found, selected: true });
+        }
+      } else {
+        if (!targetVer) {
+          console.error(`\u274C Package '${name}' has no pending updates detected. Please specify a target version (e.g. ${name}@1.2.3).`);
+          return 1;
+        }
+        updatesToApply.push({
+          coordinate: {
+            identifier: name,
+            artifact: name,
+            ecosystem
+          },
+          currentRange: "unknown",
+          currentClean: "0.0.0",
+          latest: targetVer,
+          newRange: targetVer,
+          diff: "minor",
+          scope: "prod",
+          selected: true
+        });
+      }
+    }
+  } else {
+    console.error('\u274C Please specify packages to update via --packages="pkg1,pkg2" or --all.');
+    return 1;
+  }
+  if (updatesToApply.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ message: "No updates selected to apply.", updatedCount: 0 }, null, 2));
+    } else {
+      console.log("\u2139\uFE0F  No updates selected to apply.");
+    }
+    return 0;
+  }
+  if (options.dryRun) {
+    const simulationResult = {
+      dryRun: true,
+      targetModule: targetModule.relPath,
+      ecosystem,
+      updatesCount: updatesToApply.length,
+      updates: updatesToApply.map((u) => ({
+        identifier: u.coordinate.identifier,
+        currentRange: u.currentRange,
+        newRange: u.newRange,
+        diff: u.diff
+      }))
+    };
+    if (options.json) {
+      console.log(JSON.stringify(simulationResult, null, 2));
+    } else {
+      console.log(`
+\u{1FAB6} [DRY-RUN] Planned updates for ${targetModule.name} (${updatesToApply.length}):
+`);
+      for (const u of updatesToApply) {
+        console.log(`  \u2022 ${u.coordinate.identifier.padEnd(36)} ${u.currentRange} \u2794 ${u.newRange} (${u.diff.toUpperCase()})`);
+      }
+      console.log("\n(No files were modified because --dry-run is active).\n");
+    }
+    return 0;
+  }
+  if (!options.json) {
+    console.log(`
+\u26A1 Applying ${updatesToApply.length} update(s) to ${targetModule.name}\u2026`);
+  }
+  const updateResult = await strategy.updater.applyUpdates(
+    targetModule,
+    config.rootDir,
+    updatesToApply,
+    (step) => {
+      if (!options.json) console.log(`   ${step}`);
+    }
+  );
+  let verifyResult;
+  if (!options.skipVerify) {
+    if (!options.json) console.log(`\u{1F50D} Running build & test verification\u2026`);
+    verifyResult = await strategy.verifier.verify(
+      targetModule,
+      config.rootDir,
+      config.postUpdateScript,
+      config.postUpdateLabel
+    );
+  }
+  const finalSummary = {
+    success: verifyResult?.status !== "warn",
+    module: targetModule.relPath,
+    ecosystem,
+    ...updateResult,
+    verification: verifyResult ? {
+      status: verifyResult.status,
+      label: verifyResult.label,
+      details: verifyResult.details
+    } : void 0
+  };
+  if (options.json) {
+    console.log(JSON.stringify(finalSummary, null, 2));
+    return finalSummary.success ? 0 : 2;
+  }
+  console.log(`
+\u2728 Update completed successfully!
+`);
+  console.log(`  \u2022 Updated: ${updateResult.updatedCount} package(s)`);
+  console.log(`  \u2022 Audit Status: ${updateResult.auditSeverity.toUpperCase()} \u2014 ${updateResult.auditMessage}`);
+  if (verifyResult) {
+    console.log(`  \u2022 Verification: ${verifyResult.status.toUpperCase()} (${verifyResult.label})`);
+    if (verifyResult.status === "warn") {
+      console.warn(`    Details: ${verifyResult.details}`);
+    }
+  }
+  console.log("");
+  return finalSummary.success ? 0 : 2;
+}
+
+// src/cli/command-init.ts
+import { existsSync as existsSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync3, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join as join8, resolve as resolve2 } from "path";
+function mcpServerEntry() {
+  return {
+    command: "npx",
+    args: ["-y", "@dennisrepa/elevate", "mcp"]
+  };
+}
+var ELEVATE_SKILL_CONTENT = `# Elevate \u2014 Dependency Management Agent Skill
+
+## When to Use
+Use the Elevate MCP tools whenever the task involves:
+- Scanning or auditing dependencies for available updates
+- Updating one or more packages to specific or latest versions
+- Listing available versions of a package from npm or Maven registries
+- Discovering monorepo modules and their dependency structure
+- Any dependency-related operation in a monorepo
+
+## Important
+**Never** run raw \`npm update\`, \`npm install <pkg>@latest\`, or manually edit
+\`package.json\` / \`pom.xml\` version fields. Always use Elevate's MCP tools
+instead \u2014 they handle monorepo-aware scanning, safety guardrails (major version
+protection), and post-update verification automatically.
+
+## Available MCP Tools
+| Tool                    | Purpose                                                      |
+|-------------------------|--------------------------------------------------------------|
+| \`elevate_scan\`          | Scan dependencies for available updates with diff analysis   |
+| \`elevate_update\`        | Apply updates with safety guardrails and verification        |
+| \`elevate_get_versions\`  | List all published versions of a specific package            |
+| \`elevate_list_modules\`  | Discover all modules in a monorepo                           |
+| \`elevate_health_check\`  | Run build & audit verification after updates                 |
+
+## Typical Workflow
+1. \`elevate_list_modules\` \u2014 Discover project structure
+2. \`elevate_scan\` \u2014 Identify outdated dependencies
+3. \`elevate_update\` \u2014 Apply selected updates (use \`--allow-major\` only when explicitly requested)
+4. \`elevate_health_check\` \u2014 Verify build integrity
+`;
+var home = homedir();
+var isWin = platform() === "win32";
+function appData() {
+  return process.env.APPDATA || join8(home, "AppData", "Roaming");
+}
+function detectCursor(cwd) {
+  const env = {
+    id: "cursor",
+    name: "Cursor",
+    icon: "\u{1F5B1}\uFE0F",
+    detected: false,
+    reason: "",
+    mcpConfigured: false,
+    skillConfigured: false
+  };
+  const workspaceCursorDir = join8(cwd, ".cursor");
+  const globalCursorDir = join8(home, ".cursor");
+  if (existsSync4(workspaceCursorDir) || existsSync4(globalCursorDir)) {
+    env.detected = true;
+    env.reason = existsSync4(workspaceCursorDir) ? `Found .cursor/ in workspace` : `Found ~/.cursor/ global config`;
+  }
+  const mcpPath = join8(cwd, ".cursor", "mcp.json");
+  if (existsSync4(mcpPath)) {
+    try {
+      const content = JSON.parse(readFileSync8(mcpPath, "utf8"));
+      if (content?.mcpServers?.elevate) {
+        env.mcpConfigured = true;
+      }
+    } catch {
+    }
+  }
+  const rulesPath = join8(cwd, ".cursorrules");
+  if (existsSync4(rulesPath)) {
+    const content = readFileSync8(rulesPath, "utf8");
+    if (content.includes("elevate") || content.includes("Elevate")) {
+      env.skillConfigured = true;
+    }
+  }
+  return env;
+}
+function detectClaudeDesktop() {
+  const env = {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    icon: "\u{1F916}",
+    detected: false,
+    reason: "",
+    mcpConfigured: false,
+    skillConfigured: false
+  };
+  const configPath = isWin ? join8(appData(), "Claude", "claude_desktop_config.json") : join8(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (existsSync4(configPath)) {
+    env.detected = true;
+    env.reason = `Found ${configPath}`;
+    try {
+      const content = JSON.parse(readFileSync8(configPath, "utf8"));
+      if (content?.mcpServers?.elevate) {
+        env.mcpConfigured = true;
+      }
+    } catch {
+    }
+  }
+  return env;
+}
+function detectClaudeCode(cwd) {
+  const env = {
+    id: "claude-code",
+    name: "Claude Code",
+    icon: "\u2328\uFE0F",
+    detected: false,
+    reason: "",
+    mcpConfigured: false,
+    skillConfigured: false
+  };
+  const mcpJsonPath = join8(cwd, ".mcp.json");
+  const claudeMdPath = join8(cwd, "CLAUDE.md");
+  if (existsSync4(mcpJsonPath) || existsSync4(claudeMdPath)) {
+    env.detected = true;
+    env.reason = existsSync4(mcpJsonPath) ? `Found .mcp.json in workspace` : `Found CLAUDE.md in workspace`;
+  }
+  if (existsSync4(mcpJsonPath)) {
+    try {
+      const content = JSON.parse(readFileSync8(mcpJsonPath, "utf8"));
+      if (content?.mcpServers?.elevate) {
+        env.mcpConfigured = true;
+      }
+    } catch {
+    }
+  }
+  if (existsSync4(claudeMdPath)) {
+    const content = readFileSync8(claudeMdPath, "utf8");
+    if (content.includes("elevate") || content.includes("Elevate")) {
+      env.skillConfigured = true;
+    }
+  }
+  return env;
+}
+function detectAntigravity(cwd) {
+  const env = {
+    id: "antigravity",
+    name: "Google Antigravity",
+    icon: "\u{1F680}",
+    detected: false,
+    reason: "",
+    mcpConfigured: false,
+    skillConfigured: false
+  };
+  const globalGeminiDir = join8(home, ".gemini");
+  const workspaceAgentsDir = join8(cwd, ".agents");
+  if (existsSync4(globalGeminiDir) || existsSync4(workspaceAgentsDir)) {
+    env.detected = true;
+    env.reason = existsSync4(workspaceAgentsDir) ? `Found .agents/ in workspace` : `Found ~/.gemini/ global config`;
+  }
+  const mcpPaths = [
+    join8(cwd, ".agents", "mcp_config.json"),
+    join8(home, ".gemini", "config", "mcp_config.json")
+  ];
+  for (const p of mcpPaths) {
+    if (existsSync4(p)) {
+      try {
+        const content = JSON.parse(readFileSync8(p, "utf8"));
+        if (content?.mcpServers?.elevate) {
+          env.mcpConfigured = true;
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  return env;
+}
+function detectVSCode(cwd) {
+  const env = {
+    id: "vscode",
+    name: "VS Code / Copilot",
+    icon: "\u{1F48E}",
+    detected: false,
+    reason: "",
+    mcpConfigured: false,
+    skillConfigured: false
+  };
+  const vscodeDir = join8(cwd, ".vscode");
+  if (existsSync4(vscodeDir)) {
+    env.detected = true;
+    env.reason = `Found .vscode/ in workspace`;
+  }
+  const mcpPath = join8(cwd, ".vscode", "mcp.json");
+  if (existsSync4(mcpPath)) {
+    try {
+      const content = JSON.parse(readFileSync8(mcpPath, "utf8"));
+      if (content?.servers?.elevate) {
+        env.mcpConfigured = true;
+      }
+    } catch {
+    }
+  }
+  const copilotInstructions = join8(cwd, ".github", "copilot-instructions.md");
+  if (existsSync4(copilotInstructions)) {
+    const content = readFileSync8(copilotInstructions, "utf8");
+    if (content.includes("elevate") || content.includes("Elevate")) {
+      env.skillConfigured = true;
+    }
+  }
+  return env;
+}
+function detectWindsurf() {
+  const env = {
+    id: "windsurf",
+    name: "Windsurf",
+    icon: "\u{1F3C4}",
+    detected: false,
+    reason: "",
+    mcpConfigured: false,
+    skillConfigured: false
+  };
+  const configPath = isWin ? join8(appData(), "Codeium", "Windsurf", "mcp_config.json") : join8(home, ".codeium", "windsurf", "mcp_config.json");
+  const altPath = join8(home, ".codeium", "windsurf", "mcp_config.json");
+  if (existsSync4(configPath) || existsSync4(altPath)) {
+    env.detected = true;
+    env.reason = `Found Windsurf config`;
+    const path = existsSync4(configPath) ? configPath : altPath;
+    try {
+      const content = JSON.parse(readFileSync8(path, "utf8"));
+      if (content?.mcpServers?.elevate) {
+        env.mcpConfigured = true;
+      }
+    } catch {
+    }
+  }
+  return env;
+}
+function mergeJsonMcpServer(filePath, serverKey, topLevelKey) {
+  let existing = {};
+  if (existsSync4(filePath)) {
+    try {
+      existing = JSON.parse(readFileSync8(filePath, "utf8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const servers = existing[topLevelKey] || {};
+  if (servers[serverKey]) {
+    return { written: false, message: `${filePath}: elevate already registered` };
+  }
+  servers[serverKey] = mcpServerEntry();
+  existing[topLevelKey] = servers;
+  const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
+  if (dir && !existsSync4(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync3(filePath, JSON.stringify(existing, null, 2) + "\n", "utf8");
+  return { written: true, message: `${filePath}: elevate MCP server registered` };
+}
+function appendSkillToFile(filePath, content, marker) {
+  if (existsSync4(filePath)) {
+    const existing = readFileSync8(filePath, "utf8");
+    if (existing.includes(marker)) {
+      return { written: false, message: `${filePath}: skill already present` };
+    }
+    writeFileSync3(filePath, existing + "\n\n" + content, "utf8");
+    return { written: true, message: `${filePath}: skill appended` };
+  }
+  const dir = filePath.substring(0, filePath.lastIndexOf(isWin ? "\\" : "/"));
+  if (dir && !existsSync4(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync3(filePath, content, "utf8");
+  return { written: true, message: `${filePath}: skill created` };
+}
+function configureCursor(cwd, result) {
+  const mcpPath = join8(cwd, ".cursor", "mcp.json");
+  const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
+  result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor MCP: ${mcp.message}`);
+  const rulesPath = join8(cwd, ".cursorrules");
+  const skill = appendSkillToFile(rulesPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
+  result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Cursor Rules: ${skill.message}`);
+}
+function configureClaudeDesktop(result) {
+  const configPath = isWin ? join8(appData(), "Claude", "claude_desktop_config.json") : join8(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
+  result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Desktop MCP: ${mcp.message}`);
+}
+function configureClaudeCode(cwd, result) {
+  const mcpPath = join8(cwd, ".mcp.json");
+  const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
+  result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code MCP: ${mcp.message}`);
+  const claudeMdPath = join8(cwd, "CLAUDE.md");
+  const skill = appendSkillToFile(claudeMdPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
+  result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Claude Code Skill: ${skill.message}`);
+}
+function configureAntigravity(cwd, result) {
+  const mcpPath = join8(cwd, ".agents", "mcp_config.json");
+  const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
+  result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Antigravity MCP: ${mcp.message}`);
+}
+function configureVSCode(cwd, result) {
+  const mcpPath = join8(cwd, ".vscode", "mcp.json");
+  const mcp = mergeJsonMcpServer(mcpPath, "elevate", "servers");
+  result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  VS Code MCP: ${mcp.message}`);
+  const instructionsPath = join8(cwd, ".github", "copilot-instructions.md");
+  const skill = appendSkillToFile(instructionsPath, ELEVATE_SKILL_CONTENT, "elevate_scan");
+  result.actions.push(`${skill.written ? "\u2705" : "\u23ED\uFE0F"}  Copilot Instructions: ${skill.message}`);
+}
+function configureWindsurf(result) {
+  const configPath = isWin ? join8(appData(), "Codeium", "Windsurf", "mcp_config.json") : join8(home, ".codeium", "windsurf", "mcp_config.json");
+  const mcp = mergeJsonMcpServer(configPath, "elevate", "mcpServers");
+  result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Windsurf MCP: ${mcp.message}`);
+}
+async function handleInitCommand(options) {
+  const cwd = resolve2(process.cwd());
+  const result = {
+    cwd,
+    environments: [],
+    actions: [],
+    errors: []
+  };
+  const detectors = [
+    () => detectCursor(cwd),
+    () => detectClaudeDesktop(),
+    () => detectClaudeCode(cwd),
+    () => detectAntigravity(cwd),
+    () => detectVSCode(cwd),
+    () => detectWindsurf()
+  ];
+  for (const detect of detectors) {
+    result.environments.push(detect());
+  }
+  const detected = result.environments.filter((e) => e.detected);
+  if (detected.length === 0) {
+    if (!options.json) {
+      console.log(`
+\u{1FAB6} Elevate Init
+`);
+      console.log(`  No AI coding environments detected in this workspace.`);
+      console.log(`  Creating portable .mcp.json for broad compatibility.
+`);
+    }
+    const mcpPath = join8(cwd, ".mcp.json");
+    const mcp = mergeJsonMcpServer(mcpPath, "elevate", "mcpServers");
+    result.actions.push(`${mcp.written ? "\u2705" : "\u23ED\uFE0F"}  Generic MCP: ${mcp.message}`);
+  } else {
+    if (!options.json) {
+      console.log(`
+\u{1FAB6} Elevate Init \u2014 Detected ${detected.length} environment(s)
+`);
+    }
+    const configurators = {
+      cursor: configureCursor,
+      "claude-desktop": (_cwd, r) => configureClaudeDesktop(r),
+      "claude-code": configureClaudeCode,
+      antigravity: configureAntigravity,
+      vscode: configureVSCode,
+      windsurf: (_cwd, r) => configureWindsurf(r)
+    };
+    for (const env of detected) {
+      try {
+        const configure = configurators[env.id];
+        if (configure) {
+          configure(cwd, result);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        result.errors.push(`${env.name}: ${msg}`);
+      }
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.errors.length > 0 ? 1 : 0;
+  }
+  console.log("  Environments:");
+  for (const env of result.environments) {
+    const status = env.detected ? "\u2705" : "  ";
+    const mcpBadge = env.mcpConfigured ? " [MCP \u2713]" : "";
+    const skillBadge = env.skillConfigured ? " [Skill \u2713]" : "";
+    console.log(`    ${status} ${env.icon}  ${env.name.padEnd(22)}${env.detected ? env.reason : "not detected"}${mcpBadge}${skillBadge}`);
+  }
+  if (result.actions.length > 0) {
+    console.log(`
+  Actions:`);
+    for (const action of result.actions) {
+      console.log(`    ${action}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    console.log(`
+  \u26A0\uFE0F  Errors:`);
+    for (const error of result.errors) {
+      console.log(`    \u274C ${error}`);
+    }
+  }
+  console.log(`
+  Done! Restart your AI coding tools to pick up the new MCP configuration.`);
+  console.log(`  Agents will now automatically use Elevate for dependency management.
+`);
+  return result.errors.length > 0 ? 1 : 0;
+}
+
+// src/mcp/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import semver6 from "semver";
+async function startMcpServer(config) {
+  const server = new Server(
+    {
+      name: "elevate-mcp",
+      version: "1.2.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "elevate_discover_modules",
+          description: "Discovers all repository modules and workspaces for Node/npm (package.json) or Java/Maven (pom.xml).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              ecosystem: {
+                type: "string",
+                enum: ["npm", "maven"],
+                description: "Target ecosystem (default: npm)"
+              }
+            }
+          }
+        },
+        {
+          name: "elevate_scan",
+          description: "Scans a module (or all modules) for available dependency updates against the registry.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              ecosystem: {
+                type: "string",
+                enum: ["npm", "maven"],
+                description: "Target ecosystem (default: npm)"
+              },
+              moduleId: {
+                type: "string",
+                description: 'Module ID or relative path (e.g. "apps/e2e-cockpit"). If omitted, scans the root or primary module.'
+              },
+              channel: {
+                type: "string",
+                enum: ["stable", "all"],
+                description: 'Release channel: "stable" (production-ready versions only) or "all" (including pre-releases/betas). Default: stable'
+              },
+              allModules: {
+                type: "boolean",
+                description: "If true, scans all discovered modules across the monorepo."
+              }
+            }
+          }
+        },
+        {
+          name: "elevate_get_versions",
+          description: "Fetches the complete published version history of a package from the registry.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              ecosystem: {
+                type: "string",
+                enum: ["npm", "maven"],
+                description: "Target ecosystem (default: npm)"
+              },
+              identifier: {
+                type: "string",
+                description: "Package identifier (npm: chalk, maven: org.slf4j:slf4j-api)"
+              }
+            },
+            required: ["identifier"]
+          }
+        },
+        {
+          name: "elevate_apply_updates",
+          description: "Applies targeted dependency updates to a module, installs packages, and executes automatic build & test verification.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              ecosystem: {
+                type: "string",
+                enum: ["npm", "maven"],
+                description: "Target ecosystem (default: npm)"
+              },
+              moduleId: {
+                type: "string",
+                description: "Module ID or relative path of the target module"
+              },
+              updates: {
+                type: "array",
+                description: "List of packages to update with optional target versions",
+                items: {
+                  type: "object",
+                  properties: {
+                    identifier: { type: "string", description: "Package identifier" },
+                    targetVersion: {
+                      type: "string",
+                      description: 'Specific target version (e.g. "5.6.2" or "^3.2.0"). If omitted, updates to latest.'
+                    }
+                  },
+                  required: ["identifier"]
+                }
+              },
+              allowMajor: {
+                type: "boolean",
+                description: "Safety guardrail: Must be explicitly true to permit breaking major version upgrades."
+              },
+              dryRun: {
+                type: "boolean",
+                description: "If true, simulates planned changes without modifying any files."
+              },
+              skipVerification: {
+                type: "boolean",
+                description: "Skips the post-update build and test verification step."
+              }
+            },
+            required: ["moduleId", "updates"]
+          }
+        },
+        {
+          name: "elevate_verify",
+          description: "Runs module-specific verification and build checks (e.g. npm test, mvn test-compile).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              ecosystem: {
+                type: "string",
+                enum: ["npm", "maven"],
+                description: "Target ecosystem (default: npm)"
+              },
+              moduleId: {
+                type: "string",
+                description: "Module ID or relative path of the module to verify"
+              }
+            }
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+    const ecosystem = args.ecosystem || "npm";
+    const strategy = EcosystemFactory.getStrategy(ecosystem);
+    try {
+      if (name === "elevate_discover_modules") {
+        const modules = await strategy.discovery.discover(config.rootDir);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ecosystem,
+                  count: modules.length,
+                  modules: modules.map((m) => ({
+                    id: m.id,
+                    name: m.name,
+                    relPath: m.relPath,
+                    isRoot: m.isRoot
+                  }))
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "elevate_scan") {
+        const channel = args.channel || config.channel || "stable";
+        const modules = await strategy.discovery.discover(config.rootDir);
+        const internalIds = /* @__PURE__ */ new Set();
+        for (const m of modules) {
+          if (m.id) internalIds.add(m.id);
+          if (m.name) internalIds.add(m.name);
+        }
+        const targetModules = args.allModules ? modules : args.moduleId ? modules.filter(
+          (m) => m.id.toLowerCase() === String(args.moduleId).toLowerCase() || m.relPath.toLowerCase() === String(args.moduleId).toLowerCase() || m.path.toLowerCase().endsWith(String(args.moduleId).toLowerCase())
+        ) : [modules[0]];
+        if (targetModules.length === 0) {
+          throw new Error(`Module '${args.moduleId}' not found.`);
+        }
+        const results = [];
+        let totalCount = 0;
+        for (const mod of targetModules) {
+          const updates = await strategy.reader.scan(mod, config.excludeScopes, internalIds, channel);
+          totalCount += updates.length;
+          results.push({
+            moduleId: mod.id,
+            modulePath: mod.relPath,
+            updateCount: updates.length,
+            updates: updates.map((u) => ({
+              identifier: u.coordinate.identifier,
+              currentRange: u.currentRange,
+              currentClean: u.currentClean,
+              latest: u.latest,
+              newRange: u.newRange,
+              diff: u.diff,
+              scope: u.scope,
+              isPreRelease: u.isPreRelease ?? false,
+              preReleaseTag: u.preReleaseTag
+            }))
+          });
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ecosystem,
+                  channel,
+                  scannedModules: targetModules.length,
+                  totalUpdatesCount: totalCount,
+                  results
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "elevate_get_versions") {
+        const identifier = String(args.identifier);
+        let coordinate;
+        if (ecosystem === "maven") {
+          const parts = identifier.split(":");
+          coordinate = {
+            identifier,
+            group: parts[0],
+            artifact: parts[1] || parts[0],
+            ecosystem: "maven"
+          };
+        } else {
+          coordinate = {
+            identifier,
+            artifact: identifier,
+            ecosystem: "npm"
+          };
+        }
+        const versions = await strategy.registry.getAllVersions(coordinate);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ecosystem,
+                  package: identifier,
+                  totalCount: versions.length,
+                  latest: versions[0] || null,
+                  versions: versions.map((v) => ({
+                    version: v,
+                    isPreRelease: isPreReleaseVersion(v),
+                    tag: extractPreReleaseTag(v)
+                  }))
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "elevate_apply_updates") {
+        const modules = await strategy.discovery.discover(config.rootDir);
+        const mod = modules.find(
+          (m) => m.id.toLowerCase() === String(args.moduleId).toLowerCase() || m.relPath.toLowerCase() === String(args.moduleId).toLowerCase() || m.path.toLowerCase().endsWith(String(args.moduleId).toLowerCase())
+        );
+        if (!mod) {
+          throw new Error(`Module '${args.moduleId}' not found.`);
+        }
+        const internalIds = /* @__PURE__ */ new Set();
+        for (const m of modules) {
+          if (m.id) internalIds.add(m.id);
+          if (m.name) internalIds.add(m.name);
+        }
+        const availableUpdates = await strategy.reader.scan(mod, config.excludeScopes, internalIds, "stable");
+        const requestedUpdates = args.updates || [];
+        const updatesToApply = [];
+        for (const req of requestedUpdates) {
+          const found = availableUpdates.find((u) => u.coordinate.identifier === req.identifier);
+          if (found) {
+            const targetVer = req.targetVersion || found.latest;
+            const prefix = found.currentRange.startsWith("~") ? "~" : found.currentRange.startsWith("^") ? "^" : "";
+            const diff = semver6.valid(targetVer) && found.currentClean ? semver6.diff(found.currentClean, targetVer) || "minor" : found.diff;
+            if (diff === "major" && !args.allowMajor) {
+              throw new Error(
+                `Major update for '${req.identifier}' to ${targetVer} rejected. Set 'allowMajor: true' to permit breaking changes.`
+              );
+            }
+            updatesToApply.push({
+              ...found,
+              newRange: `${prefix}${targetVer}`,
+              diff,
+              selected: true
+            });
+          } else if (req.targetVersion) {
+            updatesToApply.push({
+              coordinate: {
+                identifier: req.identifier,
+                artifact: req.identifier,
+                ecosystem
+              },
+              currentRange: "unknown",
+              currentClean: "0.0.0",
+              latest: req.targetVersion,
+              newRange: req.targetVersion,
+              diff: "minor",
+              scope: "prod",
+              selected: true
+            });
+          }
+        }
+        if (args.dryRun) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    dryRun: true,
+                    targetModule: mod.relPath,
+                    ecosystem,
+                    updatesCount: updatesToApply.length,
+                    updates: updatesToApply.map((u) => ({
+                      identifier: u.coordinate.identifier,
+                      currentRange: u.currentRange,
+                      newRange: u.newRange,
+                      diff: u.diff
+                    }))
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        const updateResult = await strategy.updater.applyUpdates(mod, config.rootDir, updatesToApply, () => {
+        });
+        let verifyResult;
+        if (!args.skipVerification) {
+          verifyResult = await strategy.verifier.verify(
+            mod,
+            config.rootDir,
+            config.postUpdateScript,
+            config.postUpdateLabel
+          );
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: verifyResult?.status !== "warn",
+                  targetModule: mod.relPath,
+                  ecosystem,
+                  ...updateResult,
+                  verification: verifyResult
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (name === "elevate_verify") {
+        const modules = await strategy.discovery.discover(config.rootDir);
+        const mod = args.moduleId ? modules.find(
+          (m) => m.id.toLowerCase() === String(args.moduleId).toLowerCase() || m.relPath.toLowerCase() === String(args.moduleId).toLowerCase() || m.path.toLowerCase().endsWith(String(args.moduleId).toLowerCase())
+        ) : modules[0];
+        if (!mod) {
+          throw new Error(`Module '${args.moduleId || "default"}' not found.`);
+        }
+        const verifyResult = await strategy.verifier.verify(
+          mod,
+          config.rootDir,
+          config.postUpdateScript,
+          config.postUpdateLabel
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  module: mod.relPath,
+                  ecosystem,
+                  ...verifyResult
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      throw new Error(`Unknown tool: ${name}`);
+    } catch (err) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `\u274C Error executing tool '${name}': ${err.message || String(err)}`
+          }
+        ]
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/index.tsx
+import { jsx as jsx15 } from "react/jsx-runtime";
+async function main() {
+  const config = loadConfig();
+  const options = parseCliArgs(process.argv.slice(2));
+  if (options.subcommand === "help" || options.help) {
+    printCliHelp();
+    process.exit(0);
+  }
+  if (options.subcommand === "mcp") {
+    await startMcpServer(config);
+    return;
+  }
+  if (options.subcommand === "modules") {
+    const exitCode = await handleModulesCommand(options, config);
+    process.exit(exitCode);
+  }
+  if (options.subcommand === "scan") {
+    const exitCode = await handleScanCommand(options, config);
+    process.exit(exitCode);
+  }
+  if (options.subcommand === "versions") {
+    const exitCode = await handleVersionsCommand(options);
+    process.exit(exitCode);
+  }
+  if (options.subcommand === "update") {
+    const exitCode = await handleUpdateCommand(options, config);
+    process.exit(exitCode);
+  }
+  if (options.subcommand === "init") {
+    const exitCode = await handleInitCommand(options);
+    process.exit(exitCode);
+  }
+  if (process.stdout.isTTY) {
+    const minCols = 140;
+    const minRows = 38;
+    const cols = Math.max(process.stdout.columns || 80, minCols);
+    const rows = Math.max(process.stdout.rows || 24, minRows);
+    process.stdout.write(`\x1B[8;${rows};${cols}t`);
+  }
+  render(/* @__PURE__ */ jsx15(App, { config }));
+}
+main().catch((err) => {
+  console.error("\u274C Elevate fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map