opkg 0.9.2 → 0.9.3

package/packages/cli/dist/uninstall-Q3CP4UN5.js

@@ -0,0 +1,539 @@
+#!/usr/bin/env node
+import {
+  classifySourceKey,
+  scanUntrackedFiles
+} from "./chunk-YXLKLL3V.js";
+import {
+  buildPreservedDirectoriesSet,
+  runSelectiveUninstallPipeline,
+  runUninstallPipeline
+} from "./chunk-D6LEPODL.js";
+import "./chunk-E2HYZWNV.js";
+import {
+  RESOURCE_TYPE_ORDER,
+  normalizeType,
+  toLabelPlural
+} from "./chunk-2PMMVTRN.js";
+import {
+  cleanupEmptyParents
+} from "./chunk-AMHDY5PC.js";
+import "./chunk-CVA64SXK.js";
+import "./chunk-TFQ4JBVO.js";
+import "./chunk-QURLGVA4.js";
+import {
+  getTargetPath
+} from "./chunk-SHKYQQJJ.js";
+import {
+  readWorkspaceIndex
+} from "./chunk-GP5FJYSS.js";
+import "./chunk-BCYZDID6.js";
+import "./chunk-V5OW4YEB.js";
+import {
+  deriveUntrackedResourceName
+} from "./chunk-6YZNE3MU.js";
+import "./chunk-Q2N6OZJC.js";
+import "./chunk-FRYA3JAQ.js";
+import {
+  formatPathForDisplay,
+  formatScopeTag
+} from "./chunk-4B5HJLP2.js";
+import {
+  createCliExecutionContext,
+  createExecutionContext,
+  resolveOutput,
+  resolvePrompt
+} from "./chunk-BROJ6OUT.js";
+import "./chunk-XEPVYZO3.js";
+import {
+  parsePackageYml
+} from "./chunk-QTQYI4L5.js";
+import "./chunk-VN22A7NW.js";
+import "./chunk-GKEHDSL4.js";
+import "./chunk-YMKK4XPN.js";
+import "./chunk-J4IFFBLP.js";
+import {
+  exists,
+  remove
+} from "./chunk-S47F4OG4.js";
+import {
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// src/commands/uninstall.ts
+import { join as join2 } from "path";
+
+// ../core/src/core/resources/resource-builder.ts
+async function buildWorkspaceResources(targetDir, scope) {
+  let { index } = await readWorkspaceIndex(targetDir), packages = index.packages || {}, resources = [], resolvedPackages = [];
+  for (let [pkgName, pkgEntry] of Object.entries(packages)) {
+    let filesMapping = pkgEntry.files || {}, resourceMap = /* @__PURE__ */ new Map(), allTargetFiles = [];
+    for (let [sourceKey, mappings] of Object.entries(filesMapping)) {
+      let { resourceType, resourceName } = classifySourceKey(sourceKey), key = resourceType === "other" ? "other::other" : `${resourceType}::${resourceName}`;
+      resourceMap.has(key) || resourceMap.set(key, { sourceKeys: /* @__PURE__ */ new Set(), targetFiles: [] });
+      let entry = resourceMap.get(key);
+      entry.sourceKeys.add(sourceKey);
+      for (let mapping of mappings) {
+        let target = getTargetPath(mapping);
+        entry.targetFiles.push(target), allTargetFiles.push(target);
+      }
+    }
+    for (let [key, entry] of resourceMap) {
+      let [resourceType, resourceName] = key.split("::");
+      resources.push({
+        kind: "tracked",
+        resourceName,
+        resourceType,
+        packageName: pkgName,
+        sourceKeys: entry.sourceKeys,
+        targetFiles: entry.targetFiles,
+        scope
+      });
+    }
+    resolvedPackages.push({
+      packageName: pkgName,
+      version: pkgEntry.version,
+      resourceCount: resourceMap.size,
+      targetFiles: allTargetFiles,
+      scope
+    });
+  }
+  let untrackedResult = await scanUntrackedFiles(targetDir), untrackedMap = /* @__PURE__ */ new Map();
+  for (let file of untrackedResult.files) {
+    let resourceType = normalizeType(file.category), resourceName = deriveUntrackedResourceName(file.workspacePath), key = `${resourceType}::${resourceName}`;
+    untrackedMap.has(key) || untrackedMap.set(key, []), untrackedMap.get(key).push(file.workspacePath);
+  }
+  for (let [key, targetFiles] of untrackedMap) {
+    let [resourceType, resourceName] = key.split("::");
+    resources.push({
+      kind: "untracked",
+      resourceName,
+      resourceType,
+      sourceKeys: /* @__PURE__ */ new Set(),
+      targetFiles,
+      scope
+    });
+  }
+  let typeOrderMap = new Map(RESOURCE_TYPE_ORDER.map((t, i) => [t, i]));
+  return resources.sort((a, b) => {
+    let orderA = typeOrderMap.get(a.resourceType) ?? 1 / 0, orderB = typeOrderMap.get(b.resourceType) ?? 1 / 0;
+    return orderA !== orderB ? orderA - orderB : a.resourceName.localeCompare(b.resourceName);
+  }), resolvedPackages.sort((a, b) => a.packageName.localeCompare(b.packageName)), { resources, packages: resolvedPackages };
+}
+
+// ../core/src/core/resources/resource-resolver.ts
+async function resolveByName(name, targetDir, scope) {
+  let workspace = await buildWorkspaceResources(targetDir, scope), candidates = [], nameLower = name.toLowerCase();
+  for (let resource of workspace.resources)
+    resource.resourceName.toLowerCase() === nameLower && candidates.push({ kind: "resource", resource });
+  for (let pkg of workspace.packages)
+    pkg.packageName === name && candidates.push({ kind: "package", package: pkg });
+  return { candidates };
+}
+
+// ../core/src/core/resources/scope-traversal.ts
+async function traverseScopes(options, callback) {
+  let results = [], cwd = options.programOpts?.cwd;
+  if (!options.globalOnly)
+    try {
+      let context = await createExecutionContext({ global: !1, cwd }), result = await callback({ scope: "project", context });
+      results.push({ scope: "project", result });
+    } catch (error) {
+      logger.debug("Project scope traversal skipped", {
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  if (!options.projectOnly)
+    try {
+      let context = await createExecutionContext({ global: !0, cwd }), result = await callback({ scope: "global", context });
+      results.push({ scope: "global", result });
+    } catch (error) {
+      logger.debug("Global scope traversal skipped", {
+        reason: error instanceof Error ? error.message : String(error)
+      });
+    }
+  return results;
+}
+async function traverseScopesFlat(options, callback) {
+  return (await traverseScopes(options, callback)).flatMap((sr) => sr.result);
+}
+
+// ../core/src/core/resources/disambiguation-prompt.ts
+async function disambiguate(name, candidates, formatChoice, options = {}, output, prompt) {
+  let {
+    notFoundMessage = `"${name}" not found.
+Run \`opkg ls\` to see installed resources.`,
+    ambiguousHeader = `
+"${name}" matches multiple items:
+`,
+    promptMessage = "Select which to act on:",
+    multi = !0
+  } = options, out = output ?? resolveOutput(), prm = prompt ?? resolvePrompt();
+  if (candidates.length === 0)
+    throw new ValidationError(
+      notFoundMessage.replace(/\$\{name\}/g, name)
+    );
+  if (candidates.length === 1)
+    return [candidates[0]];
+  let choices = candidates.map((c, i) => {
+    let choice = formatChoice(c, i);
+    return {
+      title: choice.title,
+      description: choice.description,
+      value: i
+    };
+  });
+  if (out.info(ambiguousHeader.replace(/\$\{name\}/g, name).trim()), multi) {
+    let selectedIndices = await prm.multiselect(
+      promptMessage,
+      choices
+    );
+    return !selectedIndices || selectedIndices.length === 0 ? [] : selectedIndices.map((i) => candidates[i]);
+  } else {
+    let selectedIndex = await prm.select(
+      promptMessage,
+      choices
+    );
+    return selectedIndex == null ? [] : [candidates[selectedIndex]];
+  }
+}
+
+// ../core/src/core/uninstall/uninstall-executor.ts
+import path from "path";
+
+// ../core/src/core/uninstall/uninstall-reporter.ts
+function reportUninstallResult(result, context, output) {
+  if (context?.outputMode === "rich") return;
+  let out = output ?? resolveOutput(), cwd = process.cwd();
+  if (out.success(`Uninstalled ${result.packageName}`), result.removedFiles.length > 0) {
+    out.success(`Removed files: ${result.removedFiles.length}`);
+    let sortedFiles = [...result.removedFiles].sort((a, b) => a.localeCompare(b)), displayFiles = sortedFiles.slice(0, 10);
+    for (let file of displayFiles)
+      out.info(`   \u251C\u2500\u2500 ${formatPathForDisplay(file, cwd)}`);
+    sortedFiles.length > 10 && out.info(`   ... and ${sortedFiles.length - 10} more`);
+  }
+  if (result.rootFilesUpdated.length > 0) {
+    out.success(`Updated root files: ${result.rootFilesUpdated.length}`);
+    let sortedFiles = [...result.rootFilesUpdated].sort((a, b) => a.localeCompare(b)), displayFiles = sortedFiles.slice(0, 10);
+    for (let file of displayFiles)
+      out.info(`   \u251C\u2500\u2500 ${formatPathForDisplay(file, cwd)}`);
+    sortedFiles.length > 10 && out.info(`   ... and ${sortedFiles.length - 10} more`);
+  }
+}
+function reportResourceUninstallResult(result, context, output) {
+  if (context?.outputMode === "rich") return;
+  let out = output ?? resolveOutput(), cwd = process.cwd(), fromPkg = result.packageName ? ` from ${result.packageName}` : "";
+  if (out.success(`Uninstalled ${result.resourceName}${fromPkg}`), result.removedFiles.length > 0) {
+    out.success(`Removed files: ${result.removedFiles.length}`);
+    let sortedFiles = [...result.removedFiles].sort((a, b) => a.localeCompare(b)), displayFiles = sortedFiles.slice(0, 10);
+    for (let file of displayFiles)
+      out.info(`   \u251C\u2500\u2500 ${formatPathForDisplay(file, cwd)}`);
+    sortedFiles.length > 10 && out.info(`   ... and ${sortedFiles.length - 10} more`);
+  }
+  if (result.rootFilesUpdated.length > 0) {
+    out.success(`Updated root files: ${result.rootFilesUpdated.length}`);
+    let sortedFiles = [...result.rootFilesUpdated].sort((a, b) => a.localeCompare(b)), displayFiles = sortedFiles.slice(0, 10);
+    for (let file of displayFiles)
+      out.info(`   \u251C\u2500\u2500 ${formatPathForDisplay(file, cwd)}`);
+    sortedFiles.length > 10 && out.info(`   ... and ${sortedFiles.length - 10} more`);
+  }
+}
+
+// ../core/src/core/uninstall/uninstall-executor.ts
+async function executeUninstallCandidate(candidate, options, execContext) {
+  if (candidate.kind === "package") {
+    let pkg = candidate.package, result = await runUninstallPipeline(pkg.packageName, options, execContext);
+    if (!result.success)
+      throw new ValidationError(result.error || `Uninstall failed for ${pkg.packageName}`);
+    reportUninstallResult({
+      packageName: pkg.packageName,
+      removedFiles: result.data?.removedFiles ?? [],
+      rootFilesUpdated: result.data?.rootFilesUpdated ?? []
+    }, execContext);
+    return;
+  }
+  let resource = candidate.resource;
+  if (resource.kind === "tracked") {
+    let result = await runSelectiveUninstallPipeline(
+      resource.packageName,
+      resource.sourceKeys,
+      options,
+      execContext
+    );
+    if (!result.success)
+      throw new ValidationError(result.error || `Uninstall failed for ${resource.resourceName}`);
+    reportResourceUninstallResult({
+      resourceName: resource.resourceName,
+      resourceType: resource.resourceType,
+      packageName: resource.packageName,
+      removedFiles: result.data?.removedFiles ?? [],
+      rootFilesUpdated: result.data?.rootFilesUpdated ?? []
+    }, execContext);
+    return;
+  }
+  let targetDir = execContext.targetDir, out = resolveOutput(execContext), removedFiles = [];
+  if (options.dryRun) {
+    out.info(`(dry-run) Would remove ${resource.targetFiles.length} file${resource.targetFiles.length === 1 ? "" : "s"}:`);
+    let displayFiles = resource.targetFiles.slice(0, 10);
+    for (let file of displayFiles)
+      out.message(`   \u251C\u2500\u2500 ${file}`);
+    resource.targetFiles.length > 10 && out.message(`   ... and ${resource.targetFiles.length - 10} more`);
+  }
+  for (let filePath of resource.targetFiles) {
+    let absPath = path.join(targetDir, filePath);
+    options.dryRun ? removedFiles.push(filePath) : await exists(absPath) && (await remove(absPath), removedFiles.push(filePath));
+  }
+  if (!options.dryRun && removedFiles.length > 0) {
+    let preservedDirs = buildPreservedDirectoriesSet(targetDir), deletedAbsPaths = removedFiles.map((f) => path.join(targetDir, f));
+    await cleanupEmptyParents(targetDir, deletedAbsPaths, preservedDirs);
+  }
+  reportResourceUninstallResult({
+    resourceName: resource.resourceName,
+    resourceType: resource.resourceType,
+    removedFiles,
+    rootFilesUpdated: []
+  }, execContext);
+}
+
+// ../core/src/core/uninstall/direct-uninstall-flow.ts
+function defaultFormatTitle(candidate) {
+  if (candidate.kind === "package") {
+    let pkg = candidate.package, version = pkg.version && pkg.version !== "0.0.0" ? ` (v${pkg.version})` : "", scopeTag2 = formatScopeTag(pkg.scope);
+    return `${pkg.packageName}${version} (package, ${pkg.resourceCount} resources)${scopeTag2}`;
+  }
+  let r = candidate.resource, fromPkg = r.packageName ? `, from ${r.packageName}` : "", scopeTag = formatScopeTag(r.scope);
+  return `${r.resourceName} (${r.resourceType}${fromPkg})${scopeTag}`;
+}
+function defaultFormatDescription(candidate) {
+  let files = candidate.kind === "package" ? candidate.package.targetFiles : candidate.resource.targetFiles;
+  if (files.length === 0) return "no files";
+  let displayFiles = files.slice(0, 5), remaining = files.length - displayFiles.length, desc = displayFiles.join(`
+`);
+  return remaining > 0 && (desc += `
++${remaining} more`), desc;
+}
+async function runDirectUninstallFlow(name, options, traverseOpts, createContext, formatters) {
+  let fmt = formatters ?? {
+    formatTitle: defaultFormatTitle,
+    formatDescription: defaultFormatDescription
+  }, candidates = await traverseScopesFlat(
+    traverseOpts,
+    async ({ scope, context }) => (await resolveByName(name, context.targetDir, scope)).candidates
+  ), disambiguationCtx = await createContext({
+    global: traverseOpts.globalOnly ?? !1,
+    cwd: traverseOpts.programOpts?.cwd,
+    interactive: !0
+  }), selected = await disambiguate(
+    name,
+    candidates,
+    (c) => ({
+      title: fmt.formatTitle(c),
+      description: fmt.formatDescription(c),
+      value: c
+    }),
+    {
+      notFoundMessage: `"${name}" not found as a resource or package.
+Run \`opkg ls\` to see installed resources.`,
+      promptMessage: "Select which to uninstall:"
+    },
+    resolveOutput(disambiguationCtx),
+    resolvePrompt(disambiguationCtx)
+  );
+  if (selected.length === 0)
+    return { uninstalledCount: 0, cancelled: !0 };
+  for (let candidate of selected) {
+    let ctx = await createContext({
+      global: candidate.resource?.scope === "global" || candidate.package?.scope === "global",
+      cwd: traverseOpts.programOpts?.cwd,
+      interactive: !1
+    });
+    await executeUninstallCandidate(candidate, options, ctx);
+  }
+  return { uninstalledCount: selected.length, cancelled: !1 };
+}
+
+// ../core/src/core/uninstall/workspace-resource-collector.ts
+import { join } from "path";
+async function collectWorkspaceResources(traverseOpts, packageFilter) {
+  let scopeToTargetDir = /* @__PURE__ */ new Map(), scopeResults = await traverseScopes(
+    traverseOpts,
+    async ({ scope, context }) => (scopeToTargetDir.set(scope, context.targetDir), buildWorkspaceResources(context.targetDir, scope))
+  ), allResources = scopeResults.flatMap((sr) => sr.result.resources), allPackages = scopeResults.flatMap((sr) => sr.result.packages);
+  return packageFilter && (allResources = allResources.filter((r) => r.packageName === packageFilter), allPackages = allPackages.filter((p) => p.packageName === packageFilter)), { allResources, allPackages, scopeToTargetDir };
+}
+async function buildGroupedUninstallOptions(collection, programOpts) {
+  let { allResources, allPackages, scopeToTargetDir } = collection, groupedOptions = {}, resourcesByPackageAndScope = /* @__PURE__ */ new Map(), untrackedResources = [];
+  for (let resource of allResources)
+    if (resource.kind === "tracked" && resource.packageName) {
+      let key = `${resource.packageName}::${resource.scope}`;
+      resourcesByPackageAndScope.has(key) || resourcesByPackageAndScope.set(key, []), resourcesByPackageAndScope.get(key).push(resource);
+    } else
+      untrackedResources.push(resource);
+  for (let pkg of allPackages) {
+    let key = `${pkg.packageName}::${pkg.scope}`;
+    resourcesByPackageAndScope.has(key) || resourcesByPackageAndScope.set(key, []);
+  }
+  let packageGroups = Array.from(resourcesByPackageAndScope.entries()).sort((a, b) => {
+    let [pkgA, scopeA] = a[0].split("::"), [pkgB, scopeB] = b[0].split("::"), nameCompare = pkgA.localeCompare(pkgB);
+    return nameCompare !== 0 ? nameCompare : scopeA === "project" ? -1 : 1;
+  }), totalItems = packageGroups.length + untrackedResources.length;
+  if (totalItems === 0)
+    return { groupedOptions, totalItems: 0 };
+  let packageDependencyCounts = await loadPackageDependencyCounts(
+    allPackages,
+    scopeToTargetDir,
+    programOpts
+  ), packageOptions = [];
+  for (let [key, resources] of packageGroups) {
+    let [pkgName, scope] = key.split("::"), pkg = allPackages.find((p) => p.packageName === pkgName && p.scope === scope), versionSuffix = pkg?.version && pkg.version !== "0.0.0" ? `@${pkg.version}` : "", scopeTag = pkg ? formatScopeTag(pkg.scope) : formatScopeTag(scope), resourceCount = resources.length, depCount = packageDependencyCounts.get(key) || 0, hint;
+    if (resourceCount === 0)
+      hint = depCount > 0 ? `No resources, declares ${depCount} ${depCount === 1 ? "dependency" : "dependencies"}` : "No resources";
+    else {
+      let totalFiles = resources.flatMap((r) => r.targetFiles).length;
+      hint = `${totalFiles} ${totalFiles === 1 ? "file" : "files"}`;
+    }
+    packageOptions.push({
+      value: { kind: "package", packageName: pkgName, scope, resources },
+      label: `${pkgName}${versionSuffix}${scopeTag} (${hint})`
+    });
+  }
+  packageOptions.length > 0 && (groupedOptions.Packages = packageOptions);
+  let untrackedByType = /* @__PURE__ */ new Map();
+  for (let resource of untrackedResources) {
+    let type = normalizeType(resource.resourceType);
+    untrackedByType.has(type) || untrackedByType.set(type, []), untrackedByType.get(type).push(resource);
+  }
+  for (let typeId of RESOURCE_TYPE_ORDER) {
+    let resources = untrackedByType.get(typeId);
+    if (!resources || resources.length === 0) continue;
+    let categoryName = toLabelPlural(typeId);
+    groupedOptions[categoryName] = resources.map((resource) => {
+      let scopeTag = formatScopeTag(resource.scope), fileCount = resource.targetFiles.length;
+      return {
+        value: { kind: "resource", resource },
+        label: `${resource.resourceName}${scopeTag} (${fileCount} ${fileCount === 1 ? "file" : "files"})`
+      };
+    });
+  }
+  return { groupedOptions, totalItems };
+}
+async function executeBatchUninstall(selected, options, collection, programOpts, createContext, executeCandidate) {
+  let { allPackages, scopeToTargetDir } = collection, typeCounts = /* @__PURE__ */ new Map(), uninstalledCount = 0, allRemovedFiles = [];
+  for (let selection of selected)
+    if (selection.kind === "package") {
+      let { packageName, scope, resources } = selection, targetDir = scopeToTargetDir.get(scope), pkg = allPackages.find((p) => p.packageName === packageName && p.scope === scope), execCtx = await createContext({
+        global: scope === "global",
+        cwd: programOpts.cwd,
+        interactive: !0
+      }), candidate = {
+        kind: "package",
+        package: {
+          packageName,
+          scope,
+          version: pkg?.version,
+          resourceCount: resources.length,
+          targetFiles: resources.flatMap((r) => r.targetFiles)
+        }
+      };
+      targetDir && candidate.package.targetFiles.forEach((f) => allRemovedFiles.push({ path: f, targetDir })), await executeCandidate(candidate, options, execCtx), typeCounts.set("packages", (typeCounts.get("packages") || 0) + 1), uninstalledCount++;
+    } else {
+      let resource = selection.resource, targetDir = scopeToTargetDir.get(resource.scope), candidate = { kind: "resource", resource }, execCtx = await createContext({
+        global: resource.scope === "global",
+        cwd: programOpts.cwd,
+        interactive: !0
+      });
+      targetDir && resource.targetFiles.forEach((f) => allRemovedFiles.push({ path: f, targetDir })), await executeCandidate(candidate, options, execCtx);
+      let typePlural = toLabelPlural(normalizeType(resource.resourceType)).toLowerCase();
+      typeCounts.set(typePlural, (typeCounts.get(typePlural) || 0) + 1), uninstalledCount++;
+    }
+  return { uninstalledCount, typeCounts, allRemovedFiles };
+}
+async function loadPackageDependencyCounts(packages, scopeToTargetDir, programOpts) {
+  let counts = /* @__PURE__ */ new Map();
+  for (let pkg of packages) {
+    let key = `${pkg.packageName}::${pkg.scope}`;
+    try {
+      let targetDir = scopeToTargetDir.get(pkg.scope);
+      if (!targetDir) continue;
+      let { index } = await readWorkspaceIndex(targetDir), pkgEntry = index.packages[pkg.packageName];
+      if (!pkgEntry?.path) continue;
+      let packagePath = pkgEntry.path.startsWith("~") ? pkgEntry.path.replace("~", programOpts.homeDir || process.env.HOME || process.env.USERPROFILE || "") : pkgEntry.path, manifestPath = join(packagePath, "openpackage.yml"), manifest = await parsePackageYml(manifestPath), depCount = (manifest.dependencies || []).length + (manifest["dev-dependencies"] || []).length;
+      counts.set(key, depCount);
+    } catch {
+      counts.set(key, 0);
+    }
+  }
+  return counts;
+}
+
+// src/commands/uninstall.ts
+async function uninstallCommand(nameArg, options, command) {
+  let programOpts = command.parent?.opts() || {}, traverseOpts = {
+    programOpts,
+    ...options.global ? { globalOnly: !0 } : { projectOnly: !0 }
+  };
+  if (options.interactive) {
+    await handleListUninstall(nameArg, options, programOpts, traverseOpts);
+    return;
+  }
+  if (!nameArg)
+    throw new ValidationError("Resource or package name is required. Use --interactive to interactively select.");
+  if ((await runDirectUninstallFlow(
+    nameArg,
+    options,
+    traverseOpts,
+    (opts) => createCliExecutionContext({ ...opts, outputMode: opts.interactive ? "rich" : "plain" })
+  )).cancelled) {
+    let ctx = await createCliExecutionContext({ interactive: !1, outputMode: "plain" });
+    resolveOutput(ctx).info("Uninstall cancelled");
+  }
+}
+async function handleListUninstall(packageFilter, options, programOpts, traverseOpts) {
+  let ctx = await createCliExecutionContext({ interactive: !0, outputMode: "rich" }), out = resolveOutput(ctx), prm = resolvePrompt(ctx), s = out.spinner();
+  s.start("Loading installed resources");
+  let collection = await collectWorkspaceResources(traverseOpts, packageFilter);
+  if (packageFilter && collection.allResources.length === 0 && collection.allPackages.length === 0)
+    throw s.stop("No resources found"), new ValidationError(`Package '${packageFilter}' not found.`);
+  let { groupedOptions, totalItems } = await buildGroupedUninstallOptions(collection, programOpts);
+  if (totalItems === 0) {
+    s.stop("No installed resources found"), out.note("Run `opkg install --interactive` to install resources.", "Info");
+    return;
+  }
+  s.stop(`Found ${totalItems} item${totalItems === 1 ? "" : "s"}`);
+  let selected = await prm.groupMultiselect(
+    "Select items to uninstall:",
+    groupedOptions
+  );
+  if (!selected || selected.length === 0) {
+    out.info("Uninstall cancelled");
+    return;
+  }
+  out.step(`Uninstalling ${selected.length} item${selected.length === 1 ? "" : "s"}`);
+  let summary = await executeBatchUninstall(
+    selected,
+    options,
+    collection,
+    programOpts,
+    (opts) => createCliExecutionContext({ ...opts, outputMode: opts.interactive ? "rich" : "plain" }),
+    executeUninstallCandidate
+  ), breakdown = Array.from(summary.typeCounts.entries()).sort((a, b) => b[1] - a[1]).map(([type, count]) => `${count} ${type}`).join(", ");
+  if (out.success(`Successfully uninstalled ${summary.uninstalledCount} item${summary.uninstalledCount === 1 ? "" : "s"} (${breakdown})`), summary.allRemovedFiles.length > 0) {
+    let cwd = process.cwd(), absolutePaths = [...new Set(
+      summary.allRemovedFiles.map(({ path: p, targetDir }) => join2(targetDir, p))
+    )].sort((a, b) => a.localeCompare(b)), fileLines = absolutePaths.slice(0, 10).map((f) => formatPathForDisplay(f, cwd)), more = absolutePaths.length > 10 ? `
+... and ${absolutePaths.length - 10} more` : "";
+    out.note(fileLines.join(`
+`) + more, "Removed files");
+  }
+  out.success("Uninstall complete");
+}
+async function setupUninstallCommand(args) {
+  let [nameArg, options, command] = args;
+  await uninstallCommand(nameArg, options, command);
+}
+export {
+  setupUninstallCommand
+};
+//# sourceMappingURL=uninstall-Q3CP4UN5.js.map