opkg 0.9.0 → 0.9.2

package/packages/cli/dist/uninstall-7EJCVTLD.js

@@ -0,0 +1,868 @@
+#!/usr/bin/env node
+import {
+  classifySourceKey,
+  scanUntrackedFiles
+} from "./chunk-YXLKLL3V.js";
+import {
+  cleanupEmptyParents
+} from "./chunk-AMHDY5PC.js";
+import {
+  isDirKey,
+  removeWorkspaceIndexEntry,
+  removeWorkspaceIndexFileKeys
+} from "./chunk-UVWARZQC.js";
+import {
+  getPlatformRootFileNames
+} from "./chunk-E2HYZWNV.js";
+import {
+  RESOURCE_TYPE_ORDER,
+  normalizeType,
+  toLabelPlural
+} from "./chunk-2PMMVTRN.js";
+import {
+  removePackageFromOpenpackageYml
+} from "./chunk-OFM3UWJJ.js";
+import "./chunk-DN7RINDJ.js";
+import "./chunk-TFQ4JBVO.js";
+import {
+  CLOSE_MARKER_REGEX,
+  buildOpenMarkerRegex,
+  deleteNestedKey,
+  isEffectivelyEmpty
+} from "./chunk-QURLGVA4.js";
+import {
+  getTargetPath
+} from "./chunk-SHKYQQJJ.js";
+import {
+  readWorkspaceIndex,
+  writeWorkspaceIndex
+} from "./chunk-GP5FJYSS.js";
+import {
+  getLocalOpenPackageDir,
+  getLocalPackageYmlPath
+} from "./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-CBLKT6WA.js";
+import {
+  createCliExecutionContext,
+  createExecutionContext,
+  resolveOutput,
+  resolvePrompt
+} from "./chunk-MLYYVOS3.js";
+import "./chunk-XEPVYZO3.js";
+import {
+  parsePackageYml
+} from "./chunk-QTQYI4L5.js";
+import "./chunk-VN22A7NW.js";
+import {
+  getAllPlatforms,
+  getPlatformDefinition
+} from "./chunk-GKEHDSL4.js";
+import "./chunk-YMKK4XPN.js";
+import {
+  FILE_PATTERNS
+} from "./chunk-J4IFFBLP.js";
+import {
+  exists,
+  readTextFile,
+  remove,
+  walkFiles,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// src/commands/uninstall.ts
+import { join as join4 } 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 path3 from "path";
+
+// ../core/src/core/platform/directory-preservation.ts
+import path from "path";
+function extractDirectoryFromPattern(pattern, targetDir) {
+  let normalized = pattern.replace(/\\/g, "/"), hasExtension = !/^\.[^./]+$/.test(normalized) && /\.[a-z0-9]+$/i.test(normalized), isDirectory = normalized.endsWith("/") || !hasExtension, dirPath;
+  if (isDirectory)
+    dirPath = normalized.replace(/\/$/, "");
+  else {
+    let lastSlash = normalized.lastIndexOf("/");
+    dirPath = lastSlash >= 0 ? normalized.substring(0, lastSlash) : "";
+  }
+  let absPath = dirPath ? path.join(targetDir, dirPath) : targetDir;
+  return absPath === targetDir ? null : absPath;
+}
+function buildPreservedDirectoriesSet(targetDir) {
+  let preserved = /* @__PURE__ */ new Set(), platforms = getAllPlatforms(void 0, targetDir);
+  for (let platform of platforms) {
+    let definition = getPlatformDefinition(platform, targetDir);
+    if (definition.detection && definition.detection.length > 0)
+      for (let pattern of definition.detection) {
+        let dirToPreserve = extractDirectoryFromPattern(pattern, targetDir);
+        dirToPreserve && preserved.add(dirToPreserve);
+      }
+    else if (definition.rootDir) {
+      let rootPath = path.join(targetDir, definition.rootDir);
+      rootPath !== targetDir && preserved.add(rootPath);
+    }
+  }
+  return preserved;
+}
+
+// ../core/src/core/uninstall/uninstall-pipeline.ts
+import path2 from "path";
+
+// ../core/src/core/platform/root-file-uninstaller.ts
+import { join } from "path";
+function stripPackageSection(content, packageName) {
+  if (!content) return { changed: !1, content };
+  let openRe = buildOpenMarkerRegex(packageName), closeRe = CLOSE_MARKER_REGEX, openMatch = openRe.exec(content);
+  if (!openMatch) return { changed: !1, content };
+  let before = content.slice(0, openMatch.index), rest = content.slice(openMatch.index + openMatch[0].length), closeMatch = closeRe.exec(rest);
+  if (!closeMatch) return { changed: !1, content };
+  let after = rest.slice(closeMatch.index + closeMatch[0].length);
+  return { changed: !0, content: before + after };
+}
+function stripMultiplePackageSections(content, packageNames) {
+  let changed = !1, current = content;
+  for (let name of packageNames) {
+    let result = stripPackageSection(current, name);
+    result.changed && (changed = !0), current = result.content;
+  }
+  return { changed, content: current };
+}
+function getUniqueRootFilenames() {
+  let set = /* @__PURE__ */ new Set([FILE_PATTERNS.AGENTS_MD]);
+  for (let platform of getAllPlatforms()) {
+    let def = getPlatformDefinition(platform);
+    def.rootFile && set.add(def.rootFile);
+  }
+  return Array.from(set);
+}
+async function processRootFileRemovals(targetDir, packageNames, options = {}) {
+  let updated = [], rootFiles = getUniqueRootFilenames();
+  for (let filename of rootFiles) {
+    let absPath = join(targetDir, filename);
+    if (!await exists(absPath)) continue;
+    let original = await readTextFile(absPath), { changed, content } = stripMultiplePackageSections(original, packageNames);
+    changed && (options.dryRun || (await writeTextFile(absPath, content), logger.debug(`Updated root file: ${absPath}`)), updated.push(filename));
+  }
+  return { updated };
+}
+
+// ../core/src/core/uninstall/flow-aware-uninstaller.ts
+import { join as join2 } from "path";
+import yaml from "js-yaml";
+import * as TOML from "smol-toml";
+function detectFileFormat(filePath) {
+  switch (filePath.toLowerCase().split(".").pop()) {
+    case "json":
+      return "json";
+    case "jsonc":
+      return "jsonc";
+    case "yaml":
+    case "yml":
+      return "yaml";
+    case "toml":
+      return "toml";
+    default:
+      return "text";
+  }
+}
+function parseContent(content, format) {
+  try {
+    switch (format) {
+      case "json":
+      case "jsonc":
+        let cleaned = format === "jsonc" ? content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "") : content;
+        return JSON.parse(cleaned);
+      case "yaml":
+      case "yml":
+        return yaml.load(content);
+      case "toml":
+        return TOML.parse(content);
+      default:
+        return content;
+    }
+  } catch (error) {
+    throw new Error(`Failed to parse ${format} file: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function serializeContent(data, format) {
+  try {
+    switch (format) {
+      case "json":
+      case "jsonc":
+        return JSON.stringify(data, null, 2);
+      case "yaml":
+      case "yml":
+        return yaml.dump(data, { indent: 2, flowLevel: 1, lineWidth: -1 });
+      case "toml":
+        return TOML.stringify(data);
+      default:
+        return typeof data == "string" ? data : JSON.stringify(data, null, 2);
+    }
+  } catch (error) {
+    throw new Error(`Failed to serialize ${format} file: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function removeKeysFromMergedFile(targetDir, targetPath, keysToRemove) {
+  let absPath = join2(targetDir, targetPath);
+  if (!await exists(absPath))
+    return { deleted: !1, updated: !1 };
+  let content = await readTextFile(absPath), format = detectFileFormat(targetPath), data;
+  try {
+    data = parseContent(content, format);
+  } catch (error) {
+    return logger.warn(`Failed to parse ${targetPath} for key removal: ${error instanceof Error ? error.message : String(error)}`), { deleted: !1, updated: !1 };
+  }
+  let hasNestedKeyPath = (obj, keyPath) => {
+    if (!obj || typeof obj != "object") return !1;
+    let parts = keyPath.split(".").filter(Boolean), current = obj;
+    for (let part of parts) {
+      if (!current || typeof current != "object" || !(part in current)) return !1;
+      current = current[part];
+    }
+    return !0;
+  }, existingBefore = keysToRemove.filter((k) => typeof k == "string" && hasNestedKeyPath(data, k)).length;
+  for (let key of keysToRemove)
+    deleteNestedKey(data, key);
+  if (isEffectivelyEmpty(data))
+    return await remove(absPath), logger.info(`Removed empty file: ${targetPath}`), { deleted: !0, updated: !1 };
+  let serialized = serializeContent(data, format);
+  return await writeTextFile(absPath, serialized), logger.info(`Updated ${targetPath}: removed ${keysToRemove.length} keys`), { deleted: !1, updated: !0 };
+}
+async function removeFileMapping(targetDir, mapping, packageName) {
+  let removed = [], updated = [];
+  if (typeof mapping == "string") {
+    let absPath = join2(targetDir, mapping);
+    await exists(absPath) && (await remove(absPath), removed.push(mapping), logger.debug(`Removed file: ${mapping}`));
+  } else {
+    let targetPath = mapping.target;
+    if (mapping.merge === "composite")
+      logger.debug(`Skipping composite merge file (handled by root file logic): ${targetPath}`);
+    else if (mapping.keys && mapping.keys.length > 0) {
+      let result = await removeKeysFromMergedFile(targetDir, targetPath, mapping.keys);
+      result.deleted ? removed.push(targetPath) : result.updated && updated.push(targetPath), logger.debug(
+        `Removed ${mapping.keys.length} keys from ${targetPath}: ${mapping.keys.join(", ")}`
+      );
+    } else if (mapping.merge === "deep" || mapping.merge === "shallow")
+      logger.warn(
+        `Cannot precisely remove ${targetPath} for ${packageName} - no key tracking available. File may contain content from other packages.`
+      );
+    else {
+      let absPath = join2(targetDir, targetPath);
+      await exists(absPath) && (await remove(absPath), removed.push(targetPath), logger.debug(`Removed file: ${targetPath}`));
+    }
+  }
+  return { removed, updated };
+}
+
+// ../core/src/core/uninstall/uninstall-pipeline.ts
+function isRootFileKey(key, rootNames) {
+  let normalized = key.replace(/\\/g, "/");
+  return rootNames.has(normalized);
+}
+async function processFileMappings(filesMapping, targetDir, packageName, rootNames, options = {}) {
+  let removed = [], updated = [], seenPaths = /* @__PURE__ */ new Set();
+  for (let [rawKey, mappings] of Object.entries(filesMapping || {})) {
+    if (!Array.isArray(mappings) || mappings.length === 0) continue;
+    if (isDirKey(rawKey)) {
+      for (let mapping of mappings) {
+        let targetPath = getTargetPath(mapping), absDir = path2.join(targetDir, targetPath);
+        if (await exists(absDir))
+          if (options.dryRun)
+            for await (let filePath of walkFiles(absDir))
+              seenPaths.has(filePath) || (seenPaths.add(filePath), removed.push(filePath));
+          else {
+            let result = await removeFileMapping(targetDir, mapping, packageName);
+            removed.push(...result.removed), updated.push(...result.updated);
+          }
+      }
+      continue;
+    }
+    if (!isRootFileKey(rawKey, rootNames))
+      for (let mapping of mappings) {
+        let targetPath = getTargetPath(mapping), absPath = path2.join(targetDir, targetPath);
+        if (options.dryRun)
+          seenPaths.has(absPath) || (seenPaths.add(absPath), removed.push(absPath));
+        else {
+          let result = await removeFileMapping(targetDir, mapping, packageName);
+          removed.push(...result.removed), updated.push(...result.updated);
+        }
+      }
+  }
+  return { removed, updated };
+}
+async function runUninstallPipeline(packageName, options = {}, execContext) {
+  let targetDir = execContext.targetDir, openpkgDir = getLocalOpenPackageDir(targetDir), manifestPath = getLocalPackageYmlPath(targetDir);
+  if (!await exists(openpkgDir) || !await exists(manifestPath))
+    throw new ValidationError(
+      `No .openpackage/openpackage.yml found in ${targetDir}.`
+    );
+  let { index, path: indexPath } = await readWorkspaceIndex(targetDir), pkgEntry = index.packages?.[packageName];
+  if (!pkgEntry)
+    return { success: !1, error: `Package '${packageName}' not found in workspace index.` };
+  let rootNames = getPlatformRootFileNames(getAllPlatforms(void 0, targetDir), targetDir);
+  if (options.dryRun) {
+    let out = resolveOutput(execContext), plannedRemovals = await processFileMappings(
+      pkgEntry.files || {},
+      targetDir,
+      packageName,
+      rootNames,
+      { dryRun: !0 }
+    ), rootPlan = await processRootFileRemovals(targetDir, [packageName], { dryRun: !0 });
+    out.info(`(dry-run) Would remove ${plannedRemovals.removed.length} files for ${packageName}`);
+    for (let filePath of plannedRemovals.removed)
+      out.info(` - ${filePath}`);
+    return rootPlan.updated.length > 0 && (out.info("Root files to update:"), rootPlan.updated.forEach((f) => out.info(` - ${f}`))), {
+      success: !0,
+      data: {
+        removedFiles: plannedRemovals.removed,
+        rootFilesUpdated: rootPlan.updated
+      }
+    };
+  }
+  let { removed: deleted, updated } = await processFileMappings(
+    pkgEntry.files || {},
+    targetDir,
+    packageName,
+    rootNames,
+    { dryRun: !1 }
+  ), rootResult = await processRootFileRemovals(targetDir, [packageName]);
+  removeWorkspaceIndexEntry(index, packageName), await writeWorkspaceIndex({ path: indexPath, index }), fetch("http://127.0.0.1:7243/ingest/f66bae36-2cc1-4c38-8529-d173654652f4", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "uninstall-pipeline.ts:runUninstallPipeline", message: "calling removePackageFromOpenpackageYml", data: { packageName }, timestamp: Date.now(), hypothesisId: "C", runId: "post-fix" }) }).catch(() => {
+  }), await removePackageFromOpenpackageYml(targetDir, packageName);
+  let preservedDirs = buildPreservedDirectoriesSet(targetDir), deletedAbsolutePaths = deleted.map((relativePath) => path2.join(targetDir, relativePath));
+  return await cleanupEmptyParents(targetDir, deletedAbsolutePaths, preservedDirs), logger.info(`Uninstalled ${packageName}: removed ${deleted.length} files, updated ${updated.length} merged files`), {
+    success: !0,
+    data: {
+      removedFiles: deleted,
+      rootFilesUpdated: [...rootResult.updated, ...updated]
+    }
+  };
+}
+async function runSelectiveUninstallPipeline(packageName, sourceKeysToRemove, options = {}, execContext) {
+  let targetDir = execContext.targetDir, openpkgDir = getLocalOpenPackageDir(targetDir), manifestPath = getLocalPackageYmlPath(targetDir);
+  if (!await exists(openpkgDir) || !await exists(manifestPath))
+    throw new ValidationError(
+      `No .openpackage/openpackage.yml found in ${targetDir}.`
+    );
+  let { index, path: indexPath } = await readWorkspaceIndex(targetDir), pkgEntry = index.packages?.[packageName];
+  if (!pkgEntry)
+    return { success: !1, error: `Package '${packageName}' not found in workspace index.` };
+  let filteredFiles = {};
+  for (let key of sourceKeysToRemove)
+    pkgEntry.files[key] && (filteredFiles[key] = pkgEntry.files[key]);
+  let rootNames = getPlatformRootFileNames(getAllPlatforms(void 0, targetDir), targetDir);
+  if (options.dryRun) {
+    let out = resolveOutput(execContext), plannedRemovals = await processFileMappings(
+      filteredFiles,
+      targetDir,
+      packageName,
+      rootNames,
+      { dryRun: !0 }
+    );
+    out.info(`(dry-run) Would remove ${plannedRemovals.removed.length} files for ${packageName}`);
+    for (let filePath of plannedRemovals.removed)
+      out.info(` - ${filePath}`);
+    return {
+      success: !0,
+      data: {
+        removedFiles: plannedRemovals.removed,
+        rootFilesUpdated: []
+      }
+    };
+  }
+  let { removed: deleted, updated } = await processFileMappings(
+    filteredFiles,
+    targetDir,
+    packageName,
+    rootNames,
+    { dryRun: !1 }
+  );
+  removeWorkspaceIndexFileKeys(index, packageName, sourceKeysToRemove), await writeWorkspaceIndex({ path: indexPath, index }), fetch("http://127.0.0.1:7243/ingest/f66bae36-2cc1-4c38-8529-d173654652f4", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ location: "uninstall-pipeline.ts:runSelectiveUninstallPipeline", message: "selective uninstall done - NO removePackageFromOpenpackageYml", data: { packageName }, timestamp: Date.now(), hypothesisId: "D" }) }).catch(() => {
+  });
+  let preservedDirs = buildPreservedDirectoriesSet(targetDir), deletedAbsolutePaths = deleted.map((relativePath) => path2.join(targetDir, relativePath));
+  return await cleanupEmptyParents(targetDir, deletedAbsolutePaths, preservedDirs), logger.info(`Selectively uninstalled from ${packageName}: removed ${deleted.length} files, updated ${updated.length} merged files`), {
+    success: !0,
+    data: {
+      removedFiles: deleted,
+      rootFilesUpdated: updated
+    }
+  };
+}
+
+// ../core/src/core/uninstall/uninstall-reporter.ts
+function reportUninstallResult(result, context, output) {
+  if (context?.interactive) 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?.interactive) 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 = path3.join(targetDir, filePath);
+    options.dryRun && !execContext.interactive ? 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) => path3.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
+  ), 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:"
+    }
+  );
+  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 as join3 } 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 = join3(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)
+  )).cancelled) {
+    let ctx = await createCliExecutionContext({ interactive: !1 });
+    resolveOutput(ctx).info("Uninstall cancelled");
+  }
+}
+async function handleListUninstall(packageFilter, options, programOpts, traverseOpts) {
+  let ctx = await createCliExecutionContext({ interactive: !0 }), 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),
+    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 }) => join4(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-7EJCVTLD.js.map