opkg 0.9.0 → 0.9.2

package/packages/cli/dist/chunk-SSHWUJEG.js

@@ -0,0 +1,788 @@
+#!/usr/bin/env node
+import {
+  flattenResourceGroups,
+  getChildPrefix,
+  renderFlatResourceList
+} from "./chunk-V2JKF46L.js";
+import {
+  classifySourceKey,
+  scanUntrackedFiles
+} from "./chunk-YXLKLL3V.js";
+import {
+  RESOURCE_TYPE_ORDER,
+  RESOURCE_TYPE_ORDER_PLURAL,
+  getResourceTypeDef,
+  normalizeType,
+  toPluralKey
+} from "./chunk-2PMMVTRN.js";
+import {
+  getTargetPath
+} from "./chunk-SHKYQQJJ.js";
+import {
+  getWorkspaceIndexPath,
+  readWorkspaceIndex
+} from "./chunk-GP5FJYSS.js";
+import {
+  getLocalOpenPackageDir,
+  getLocalPackageYmlPath
+} from "./chunk-BCYZDID6.js";
+import {
+  stripExtension
+} from "./chunk-6YZNE3MU.js";
+import {
+  resolveDeclaredPath
+} from "./chunk-FRYA3JAQ.js";
+import {
+  formatPathForDisplay,
+  formatScopeBadge
+} from "./chunk-CBLKT6WA.js";
+import {
+  getDisplayTargetDir,
+  resolveOutput
+} from "./chunk-MLYYVOS3.js";
+import {
+  parsePackageYml
+} from "./chunk-QTQYI4L5.js";
+import {
+  stripPlatformSuffixFromFilename
+} from "./chunk-UDAWJRKD.js";
+import {
+  getAllPlatforms,
+  getPlatformDefinition,
+  isPlatformId,
+  normalizePlatforms
+} from "./chunk-GKEHDSL4.js";
+import {
+  DIR_TO_TYPE
+} from "./chunk-J4IFFBLP.js";
+import {
+  exists,
+  isDirectory
+} from "./chunk-S47F4OG4.js";
+import {
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/list/list-pipeline.ts
+import path from "path";
+
+// ../core/src/core/resources/resource-namespace.ts
+function getPathUnderCategory(path2, categoryDir) {
+  let parts = path2.replace(/\\/g, "/").replace(/\/$/, "").split("/"), idx = parts.indexOf(categoryDir);
+  if (idx < 0) return null;
+  let remaining = parts.slice(idx + 1);
+  return remaining.length > 0 ? remaining.join("/") : "";
+}
+function deriveNamespace(pathUnderCategory, resourceType) {
+  if (!pathUnderCategory || pathUnderCategory === "") return "unnamed";
+  let parts = pathUnderCategory.split("/");
+  if (resourceType === "skill")
+    return parts[0] || "unnamed";
+  let strippedParts = stripPlatformSuffixFromFilename(pathUnderCategory).split("/"), lastSegment = strippedParts[strippedParts.length - 1] ?? "", nameWithoutExt = stripExtension(lastSegment);
+  if (strippedParts.length === 1)
+    return nameWithoutExt || lastSegment;
+  let subpath = strippedParts.slice(0, -1).join("/");
+  return subpath ? `${subpath}/${nameWithoutExt}` : nameWithoutExt;
+}
+function deriveResourceFullName(path2, resourceType) {
+  let normalizedType = resourceType;
+  if (normalizedType === "mcp")
+    return "mcps/configs";
+  if (normalizedType === "other")
+    return "other";
+  let categoryDir = getResourceTypeDef(normalizedType).dirName;
+  if (!categoryDir)
+    return `other/${deriveNamespace(path2, "other")}`;
+  let pathUnder = getPathUnderCategory(path2, categoryDir);
+  if (pathUnder === null) {
+    let pluralKey2 = toPluralKey(normalizedType), fallback = path2.replace(/\\/g, "/").split("/").pop() ?? "unnamed";
+    return `${pluralKey2}/${stripExtension(fallback)}`;
+  }
+  let namespace = deriveNamespace(pathUnder, normalizedType);
+  return `${toPluralKey(normalizedType)}/${namespace}`;
+}
+
+// ../core/src/core/list/list-pipeline.ts
+function extractRootPrefixFromToPattern(pattern) {
+  let parts = pattern.replace(/\\/g, "/").split("/");
+  if (parts.length < 2 || !parts[0].startsWith(".")) return null;
+  let nonGlobParts = [];
+  for (let part of parts) {
+    if (part.includes("*") || part.includes("{")) break;
+    nonGlobParts.push(part);
+  }
+  if (nonGlobParts.length < 2) return nonGlobParts.length === 1 ? nonGlobParts[0] : null;
+  let resourceDirs = new Set(Object.keys(DIR_TO_TYPE)), prefixParts = [];
+  for (let part of nonGlobParts) {
+    if (resourceDirs.has(part) || part.includes(".") && part !== nonGlobParts[0]) break;
+    prefixParts.push(part);
+  }
+  return prefixParts.length > 0 ? prefixParts.join("/") : null;
+}
+function collectToPatternsFromFlow(toField) {
+  if (typeof toField == "string") return [toField];
+  if (typeof toField == "object" && toField !== null) {
+    if ("$switch" in toField) {
+      let sw = toField.$switch, patterns = [];
+      for (let c of sw?.cases ?? []) {
+        let v = c.value;
+        typeof v == "string" ? patterns.push(v) : typeof v == "object" && v && "pattern" in v && patterns.push(v.pattern);
+      }
+      let d = sw?.default;
+      return typeof d == "string" ? patterns.push(d) : typeof d == "object" && d && "pattern" in d && patterns.push(d.pattern), patterns;
+    }
+    if ("pattern" in toField && typeof toField.pattern == "string")
+      return [toField.pattern];
+  }
+  return [];
+}
+var rootDirCacheMap = /* @__PURE__ */ new Map();
+function getRootDirToPlatformMap(targetDir) {
+  let cached = rootDirCacheMap.get(targetDir);
+  if (cached) return cached;
+  let map = /* @__PURE__ */ new Map();
+  for (let platform of getAllPlatforms({ includeDisabled: !0 }, targetDir)) {
+    let definition = getPlatformDefinition(platform, targetDir);
+    if (definition.export)
+      for (let flow of definition.export)
+        for (let pattern of collectToPatternsFromFlow(flow.to)) {
+          let prefix = extractRootPrefixFromToPattern(pattern);
+          prefix && !map.has(prefix) && map.set(prefix, platform);
+        }
+  }
+  return rootDirCacheMap.set(targetDir, map), map;
+}
+function extractPlatformFromPath(targetPath, targetDir) {
+  let normalized = targetPath.replace(/\\/g, "/"), sortedEntries = [...getRootDirToPlatformMap(targetDir).entries()].sort((a, b) => b[0].length - a[0].length);
+  for (let [rootDir, platform] of sortedEntries)
+    if (normalized === rootDir || normalized.startsWith(rootDir + "/"))
+      return platform;
+  let parts = normalized.split("/"), nameParts = parts[parts.length - 1].split(".");
+  if (nameParts.length >= 3) {
+    let possiblePlatform = nameParts[nameParts.length - 2];
+    if (isPlatformId(possiblePlatform, targetDir))
+      return possiblePlatform;
+  }
+  return null;
+}
+function groupFilesIntoResources(fileList) {
+  let resourceMap = /* @__PURE__ */ new Map();
+  for (let file of fileList) {
+    let { resourceType } = classifySourceKey(file.source), fullName = deriveResourceFullName(file.source, resourceType), key = fullName;
+    resourceMap.has(key) || resourceMap.set(key, {
+      name: fullName,
+      resourceType,
+      files: []
+    }), resourceMap.get(key).files.push(file);
+  }
+  let typeGroupMap = /* @__PURE__ */ new Map();
+  for (let resource of resourceMap.values())
+    typeGroupMap.has(resource.resourceType) || typeGroupMap.set(resource.resourceType, []), typeGroupMap.get(resource.resourceType).push(resource);
+  let typeOrder = RESOURCE_TYPE_ORDER, groups = [];
+  for (let type of typeOrder) {
+    let resources = typeGroupMap.get(type);
+    if (!resources || resources.length === 0) continue;
+    resources.sort((a, b) => a.name.localeCompare(b.name));
+    for (let resource of resources)
+      resource.files.sort((a, b) => a.target.localeCompare(b.target));
+    let pluralLabel = toPluralKey(type);
+    groups.push({ resourceType: pluralLabel, resources });
+  }
+  for (let [type, resources] of typeGroupMap)
+    if (!typeOrder.includes(type)) {
+      resources.sort((a, b) => a.name.localeCompare(b.name));
+      for (let resource of resources)
+        resource.files.sort((a, b) => a.target.localeCompare(b.target));
+      groups.push({ resourceType: `${type}s`, resources });
+    }
+  return groups;
+}
+async function checkPackageStatus(targetDir, pkgName, entry, includeFileList = !1, platformsFilter) {
+  let totalTargets = entry.files ? Object.values(entry.files).reduce((s, arr) => s + (Array.isArray(arr) ? arr.length : 0), 0) : 0, sourceRoot = resolveDeclaredPath(entry.path, targetDir).absolute, sourceExists = await exists(sourceRoot), canDeriveFromFiles = totalTargets > 0;
+  if (!sourceExists && !canDeriveFromFiles)
+    return {
+      name: pkgName,
+      version: entry.version,
+      path: entry.path,
+      state: "missing",
+      totalFiles: 0,
+      existingFiles: 0,
+      fileList: includeFileList ? [] : void 0
+    };
+  let totalFiles = 0, existingFiles = 0, fileList = [], filesMapping = entry.files || {}, normalizedPlatforms = platformsFilter ? normalizePlatforms(platformsFilter) : null;
+  for (let [sourceKey, targets] of Object.entries(filesMapping))
+    if (!(!Array.isArray(targets) || targets.length === 0))
+      for (let mapping of targets) {
+        let targetPath = getTargetPath(mapping);
+        if (normalizedPlatforms && normalizedPlatforms.length > 0) {
+          let filePlatform = extractPlatformFromPath(targetPath, targetDir);
+          if (filePlatform && !normalizedPlatforms.includes(filePlatform.toLowerCase()))
+            continue;
+        }
+        let absPath = path.join(targetDir, targetPath);
+        totalFiles++;
+        let fileExists = await exists(absPath);
+        fileExists && existingFiles++, includeFileList && fileList.push({
+          source: sourceKey,
+          target: targetPath,
+          exists: fileExists
+        });
+      }
+  let state = existingFiles === totalFiles ? "synced" : "partial", dependencies = entry.dependencies;
+  if (!dependencies || dependencies.length === 0)
+    try {
+      let pkgManifestPath = path.join(sourceRoot, "openpackage.yml");
+      if (await exists(pkgManifestPath)) {
+        let pkgManifest = await parsePackageYml(pkgManifestPath);
+        dependencies = [
+          ...pkgManifest.dependencies || [],
+          ...pkgManifest["dev-dependencies"] || []
+        ].map((dep) => dep.name);
+      }
+    } catch (error) {
+      logger.debug(`Failed to read package manifest for ${pkgName}: ${error}`);
+    }
+  let allFilesForGrouping = includeFileList ? fileList : [];
+  if (!includeFileList) {
+    for (let [sourceKey, targets] of Object.entries(filesMapping))
+      if (!(!Array.isArray(targets) || targets.length === 0))
+        for (let mapping of targets) {
+          let targetPath = getTargetPath(mapping);
+          if (normalizedPlatforms && normalizedPlatforms.length > 0) {
+            let filePlatform = extractPlatformFromPath(targetPath, targetDir);
+            if (filePlatform && !normalizedPlatforms.includes(filePlatform.toLowerCase()))
+              continue;
+          }
+          allFilesForGrouping.push({
+            source: sourceKey,
+            target: targetPath,
+            exists: !0
+          });
+        }
+  }
+  let resourceGroups = allFilesForGrouping.length > 0 ? groupFilesIntoResources(allFilesForGrouping) : void 0;
+  return {
+    name: pkgName,
+    version: entry.version,
+    path: entry.path,
+    state,
+    totalFiles,
+    existingFiles,
+    fileList: includeFileList ? fileList : void 0,
+    resourceGroups,
+    dependencies
+  };
+}
+function buildDependencyTree(rootNames, reportMap, all) {
+  let visited = /* @__PURE__ */ new Set();
+  function buildNode(pkgName, depth) {
+    let report = reportMap.get(pkgName);
+    if (!report) return null;
+    if (visited.has(pkgName))
+      return {
+        report: { ...report, name: `${report.name} (circular)` },
+        children: []
+      };
+    visited.add(pkgName);
+    let children = [];
+    return all && report.dependencies && report.dependencies.length > 0 && (children = report.dependencies.map((depName) => buildNode(depName, depth + 1)).filter((node) => node !== null)), visited.delete(pkgName), { report, children };
+  }
+  return rootNames.map((name) => buildNode(name, 0)).filter((node) => node !== null);
+}
+async function runListPipeline(packageName, execContext, options = {}) {
+  let { includeFiles = !1, all = !1, tracked = !1, untracked = !1, platforms } = options, targetDir = execContext.targetDir, indexPath = getWorkspaceIndexPath(targetDir);
+  if (tracked && untracked)
+    throw new ValidationError("Cannot use --tracked and --untracked together.");
+  if (untracked) {
+    if (!await exists(indexPath))
+      throw new ValidationError(
+        `No workspace index found at ${indexPath}. Cannot scan for untracked files.`
+      );
+    let untrackedFiles2 = await scanUntrackedFiles(targetDir, platforms);
+    return {
+      success: !0,
+      data: {
+        packages: [],
+        tree: [],
+        rootPackageNames: [],
+        trackedCount: 0,
+        missingCount: 0,
+        untrackedCount: untrackedFiles2.totalFiles,
+        untrackedFiles: untrackedFiles2
+      }
+    };
+  }
+  let 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 } = await readWorkspaceIndex(targetDir), packages = index.packages || {}, reports = [], reportMap = /* @__PURE__ */ new Map(), rootPackageNames = [], workspacePackageName;
+  try {
+    let config = await parsePackageYml(manifestPath);
+    workspacePackageName = config.name, rootPackageNames = [
+      ...config.dependencies || [],
+      ...config["dev-dependencies"] || []
+    ].map((dep) => dep.name), workspacePackageName && packages[workspacePackageName] && (rootPackageNames = [workspacePackageName, ...rootPackageNames]);
+  } catch (error) {
+    logger.warn(`Failed to read workspace manifest: ${error}`);
+  }
+  if (packageName) {
+    let pkgEntry = packages[packageName];
+    if (!pkgEntry)
+      return {
+        success: !0,
+        data: { packages: [], rootPackageNames: [], trackedCount: 0, missingCount: 0, untrackedCount: 0 }
+      };
+    let targetPackage;
+    try {
+      targetPackage = await checkPackageStatus(targetDir, packageName, pkgEntry, !0, platforms), reports.push(targetPackage), reportMap.set(packageName, targetPackage);
+    } catch (error) {
+      logger.warn(`Failed to check package ${packageName}: ${error}`), targetPackage = {
+        name: packageName,
+        version: pkgEntry?.version,
+        path: pkgEntry?.path ?? "",
+        state: "missing",
+        totalFiles: 0,
+        existingFiles: 0,
+        fileList: [],
+        dependencies: pkgEntry?.dependencies
+      }, reports.push(targetPackage), reportMap.set(packageName, targetPackage);
+    }
+    let depNames = targetPackage.dependencies || [];
+    for (let depName of depNames) {
+      if (reportMap.has(depName)) continue;
+      let depEntry = packages[depName];
+      if (depEntry)
+        try {
+          let depReport = await checkPackageStatus(targetDir, depName, depEntry, includeFiles, platforms);
+          reportMap.set(depName, depReport);
+        } catch (error) {
+          logger.debug(`Failed to load dependency ${depName}: ${error}`);
+        }
+    }
+    if (all) {
+      let loadNestedDeps = async (names) => {
+        for (let name of names) {
+          let report = reportMap.get(name);
+          if (report?.dependencies)
+            for (let nestedDepName of report.dependencies) {
+              if (reportMap.has(nestedDepName)) continue;
+              let nestedEntry = packages[nestedDepName];
+              if (nestedEntry)
+                try {
+                  let nestedReport = await checkPackageStatus(targetDir, nestedDepName, nestedEntry, includeFiles, platforms);
+                  reportMap.set(nestedDepName, nestedReport), nestedReport.dependencies && nestedReport.dependencies.length > 0 && await loadNestedDeps([nestedDepName]);
+                } catch (error) {
+                  logger.debug(`Failed to load nested dependency ${nestedDepName}: ${error}`);
+                }
+            }
+        }
+      };
+      await loadNestedDeps(depNames);
+    }
+    let tree2 = buildDependencyTree(depNames, reportMap, all), treeWithTarget = [{
+      report: targetPackage,
+      children: tree2
+    }], trackedCount2 = reports.reduce((sum, r) => sum + r.existingFiles, 0), missingCount2 = reports.reduce((sum, r) => sum + (r.totalFiles - r.existingFiles), 0), untrackedFiles2, untrackedCount2 = 0;
+    return tracked || (untrackedFiles2 = await scanUntrackedFiles(targetDir, platforms), untrackedCount2 = untrackedFiles2.totalFiles), {
+      success: !0,
+      data: { packages: reports, tree: treeWithTarget, rootPackageNames: depNames, targetPackage, trackedCount: trackedCount2, missingCount: missingCount2, untrackedCount: untrackedCount2, untrackedFiles: untrackedFiles2 }
+    };
+  }
+  for (let [pkgName, pkgEntry] of Object.entries(packages))
+    try {
+      let report = await checkPackageStatus(targetDir, pkgName, pkgEntry, includeFiles, platforms);
+      reports.push(report), reportMap.set(pkgName, report);
+    } catch (error) {
+      logger.warn(`Failed to check package ${pkgName}: ${error}`);
+      let errorReport = {
+        name: pkgName,
+        version: pkgEntry?.version,
+        path: pkgEntry?.path ?? "",
+        state: "missing",
+        totalFiles: 0,
+        existingFiles: 0,
+        dependencies: pkgEntry?.dependencies
+      };
+      reports.push(errorReport), reportMap.set(pkgName, errorReport);
+    }
+  let tree = buildDependencyTree(rootPackageNames, reportMap, all), trackedCount = reports.reduce((sum, r) => sum + r.existingFiles, 0), missingCount = reports.reduce((sum, r) => sum + (r.totalFiles - r.existingFiles), 0), untrackedFiles, untrackedCount = 0;
+  return tracked || (untrackedFiles = await scanUntrackedFiles(targetDir, platforms), untrackedCount = untrackedFiles.totalFiles), {
+    success: !0,
+    data: { packages: reports, tree, rootPackageNames, trackedCount, missingCount, untrackedCount, untrackedFiles }
+  };
+}
+
+// ../core/src/utils/entity-detector.ts
+import { join } from "path";
+async function detectEntityType(path2) {
+  let workspaceMarker = join(path2, ".openpackage", "openpackage.yml");
+  if (await exists(workspaceMarker))
+    return "workspace";
+  let packageMarker = join(path2, "openpackage.yml");
+  if (await exists(packageMarker))
+    return "package";
+  let claudePluginMarker = join(path2, ".claude-plugin", "plugin.json");
+  if (await exists(claudePluginMarker))
+    return "package";
+  let packageDirs = ["agents", "skills", "commands", "rules", "hooks"];
+  for (let dir of packageDirs) {
+    let dirPath = join(path2, dir);
+    if (await exists(dirPath) && await isDirectory(dirPath))
+      return "package";
+  }
+  return "resource";
+}
+async function getEntityDisplayName(path2, fallbackName) {
+  let entityType = await detectEntityType(path2);
+  if (entityType === "package" || entityType === "workspace")
+    try {
+      let { parsePackageYml: parsePackageYml2 } = await import("./package-yml-33CZZC3T.js"), manifestPath = entityType === "workspace" ? join(path2, ".openpackage", "openpackage.yml") : join(path2, "openpackage.yml");
+      if (await exists(manifestPath)) {
+        let manifest = await parsePackageYml2(manifestPath);
+        if (manifest.name)
+          return manifest.name;
+      }
+    } catch {
+    }
+  return fallbackName;
+}
+
+// ../core/src/core/list/scope-data-collector.ts
+async function runScopeList(packageName, execContext, options) {
+  let skipLocal = options.remote && !!packageName, packages = [], tree = [], data;
+  if (!skipLocal) {
+    let result = await runListPipeline(packageName, execContext, {
+      includeFiles: options.files || !!packageName,
+      all: options.all,
+      tracked: options.tracked,
+      untracked: options.untracked,
+      platforms: options.platforms
+    });
+    packages = result.data?.packages ?? [], tree = result.data?.tree ?? [], data = result.data;
+  }
+  let hasUntrackedData = data?.untrackedFiles && data.untrackedFiles.totalFiles > 0;
+  if (packageName && packages.length === 0 || !data || packages.length === 0 && !hasUntrackedData && !packageName)
+    return null;
+  let headerName = "Unnamed", headerVersion, headerPath, headerType;
+  if (packageName && data.targetPackage) {
+    let targetPkg = data.targetPackage, absolutePath = resolveDeclaredPath(targetPkg.path, execContext.targetDir).absolute;
+    headerType = await detectEntityType(absolutePath), headerName = await getEntityDisplayName(absolutePath, targetPkg.name), headerVersion = targetPkg.version, headerPath = formatPathForDisplay(absolutePath);
+  } else {
+    headerPath = getDisplayTargetDir(execContext), headerType = await detectEntityType(execContext.targetDir);
+    let manifestPath = getLocalPackageYmlPath(execContext.targetDir);
+    try {
+      let manifest = await parsePackageYml(manifestPath);
+      headerName = manifest.name || "Unnamed", headerVersion = manifest.version;
+    } catch (error) {
+      logger.debug(`Failed to read workspace manifest: ${error}`);
+    }
+  }
+  return { headerName, headerVersion, headerPath, headerType, tree, data };
+}
+async function collectScopedData(packageName, options, createContext) {
+  let results = [];
+  if (options.showProject) {
+    let projectContext = await createContext({
+      global: !1,
+      cwd: options.cwd
+    });
+    try {
+      let projectResult = await runScopeList(packageName, projectContext, options.pipelineOptions);
+      projectResult && results.push({ scope: "project", result: projectResult });
+    } catch (error) {
+      logger.debug(`Failed to list project scope${packageName ? ` for package '${packageName}'` : ""}: ${error}`);
+    }
+  }
+  if (options.showGlobal) {
+    let globalContext = await createContext({
+      global: !0,
+      cwd: options.cwd
+    });
+    try {
+      let globalResult = await runScopeList(packageName, globalContext, options.pipelineOptions);
+      globalResult && results.push({ scope: "global", result: globalResult });
+    } catch (error) {
+      logger.debug(`Failed to list global scope${packageName ? ` for package '${packageName}'` : ""}: ${error}`);
+    }
+  }
+  return results;
+}
+function normalizeCategory(category) {
+  return toPluralKey(normalizeType(category));
+}
+function calculateResourceStatus(files) {
+  if (files.length === 0) return "untracked";
+  let hasTracked = files.some((f) => f.status === "tracked"), hasUntracked = files.some((f) => f.status === "untracked"), hasMissing = files.some((f) => f.status === "missing");
+  return hasUntracked && !hasTracked && !hasMissing ? "untracked" : hasTracked && !hasUntracked && !hasMissing ? "tracked" : hasTracked && hasMissing && !hasUntracked ? "partial" : "mixed";
+}
+function mergeTrackedAndUntrackedResources(tree, untrackedFiles, scope) {
+  let typeMap = /* @__PURE__ */ new Map();
+  function collectFromNode(node) {
+    if (node.report.resourceGroups)
+      for (let group of node.report.resourceGroups) {
+        typeMap.has(group.resourceType) || typeMap.set(group.resourceType, /* @__PURE__ */ new Map());
+        let resourcesMap = typeMap.get(group.resourceType);
+        for (let resource of group.resources) {
+          let pkgName = node.report.name;
+          if (resourcesMap.has(resource.name)) {
+            let existing = resourcesMap.get(resource.name);
+            existing.packages || (existing.packages = /* @__PURE__ */ new Set()), existing.packages.add(pkgName);
+          } else {
+            let enhancedFiles = resource.files.map((f) => ({
+              ...f,
+              status: f.exists ? "tracked" : "missing",
+              scope
+            }));
+            resourcesMap.set(resource.name, {
+              name: resource.name,
+              resourceType: resource.resourceType,
+              files: enhancedFiles,
+              status: "tracked",
+              scopes: /* @__PURE__ */ new Set([scope]),
+              packages: /* @__PURE__ */ new Set([pkgName])
+            });
+          }
+        }
+      }
+    node.children.forEach(collectFromNode);
+  }
+  if (tree.forEach(collectFromNode), untrackedFiles && untrackedFiles.files.length > 0)
+    for (let file of untrackedFiles.files) {
+      let singularType = normalizeType(file.category), fullName = deriveResourceFullName(file.workspacePath, singularType), normalizedType = normalizeCategory(file.category);
+      typeMap.has(normalizedType) || typeMap.set(normalizedType, /* @__PURE__ */ new Map());
+      let resourcesMap = typeMap.get(normalizedType), enhancedFile = {
+        source: file.workspacePath,
+        target: file.workspacePath,
+        exists: !0,
+        status: "untracked",
+        scope
+      };
+      resourcesMap.has(fullName) ? resourcesMap.get(fullName).files.push(enhancedFile) : resourcesMap.set(fullName, {
+        name: fullName,
+        resourceType: normalizedType,
+        files: [enhancedFile],
+        status: "untracked",
+        scopes: /* @__PURE__ */ new Set([scope])
+        // no packages for untracked resources
+      });
+    }
+  for (let resourcesMap of typeMap.values())
+    for (let resource of resourcesMap.values())
+      resource.status = calculateResourceStatus(resource.files);
+  let groups = [];
+  for (let type of RESOURCE_TYPE_ORDER_PLURAL) {
+    let resourcesMap = typeMap.get(type);
+    if (resourcesMap && resourcesMap.size > 0) {
+      let resources = Array.from(resourcesMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+      groups.push({ resourceType: type, resources });
+    }
+  }
+  for (let [type, resourcesMap] of typeMap) {
+    if (RESOURCE_TYPE_ORDER_PLURAL.includes(type)) continue;
+    let resources = Array.from(resourcesMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    groups.push({ resourceType: type, resources });
+  }
+  return groups;
+}
+function mergeResourcesAcrossScopes(scopedResources) {
+  let typeMap = /* @__PURE__ */ new Map();
+  for (let { scope, groups: groups2 } of scopedResources)
+    for (let group of groups2) {
+      typeMap.has(group.resourceType) || typeMap.set(group.resourceType, /* @__PURE__ */ new Map());
+      let resourcesMap = typeMap.get(group.resourceType);
+      for (let resource of group.resources)
+        if (!resourcesMap.has(resource.name))
+          resourcesMap.set(resource.name, {
+            ...resource,
+            scopes: /* @__PURE__ */ new Set([scope]),
+            files: [...resource.files],
+            packages: resource.packages ? new Set(resource.packages) : void 0
+          });
+        else {
+          let existing = resourcesMap.get(resource.name);
+          if (existing.scopes.add(scope), existing.files.push(...resource.files), existing.status = calculateResourceStatus(existing.files), resource.packages) {
+            existing.packages = existing.packages ?? /* @__PURE__ */ new Set();
+            for (let pkg of resource.packages)
+              existing.packages.add(pkg);
+          }
+        }
+    }
+  let groups = [];
+  for (let type of RESOURCE_TYPE_ORDER_PLURAL) {
+    let resourcesMap = typeMap.get(type);
+    if (resourcesMap && resourcesMap.size > 0) {
+      let resources = Array.from(resourcesMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+      groups.push({ resourceType: type, resources });
+    }
+  }
+  for (let [type, resourcesMap] of typeMap) {
+    if (RESOURCE_TYPE_ORDER_PLURAL.includes(type)) continue;
+    let resources = Array.from(resourcesMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+    groups.push({ resourceType: type, resources });
+  }
+  return groups;
+}
+async function resolveWorkspaceHeader(execContext) {
+  let workspacePath = getDisplayTargetDir(execContext), manifestPath = getLocalPackageYmlPath(execContext.targetDir), name = "Unnamed", version;
+  try {
+    let manifest = await parsePackageYml(manifestPath);
+    name = manifest.name || "Unnamed", version = manifest.version;
+  } catch {
+  }
+  let headerType = await detectEntityType(execContext.targetDir);
+  return { name, version, path: workspacePath, type: headerType };
+}
+
+// ../core/src/core/list/view-metadata.ts
+function extractMetadataFromManifest(manifest) {
+  let entries = [], push = (key, value) => {
+    value != null && value !== "" && entries.push({ key, value });
+  };
+  if (push("name", manifest.name), push("version", manifest.version), push("description", manifest.description), push("keywords", manifest.keywords), push("author", manifest.author), push("license", manifest.license), push("homepage", manifest.homepage), manifest.repository) {
+    let repo = manifest.repository, repoStr = repo.directory ? `${repo.url} (${repo.directory})` : repo.url;
+    push("repository", repoStr);
+  }
+  return manifest.private === !0 && push("private", !0), manifest.partial === !0 && push("partial", !0), entries;
+}
+
+// ../core/src/core/list/list-printers.ts
+function printMetadataSection(metadata, output) {
+  let out = output ?? resolveOutput();
+  out.info(sectionHeader("Metadata", metadata.length)), metadata.forEach((entry) => {
+    let valueStr = Array.isArray(entry.value) ? entry.value.join(", ") : String(entry.value);
+    out.info(`${dim(entry.key + ":")} ${valueStr}`);
+  });
+}
+var DIM = "\x1B[2m", RESET = "\x1B[0m", RED = "\x1B[31m", CYAN = "\x1B[36m";
+function dim(text) {
+  return `${DIM}${text}${RESET}`;
+}
+function cyan(text) {
+  return `${CYAN}${text}${RESET}`;
+}
+function red(text) {
+  return `${RED}${text}${RESET}`;
+}
+function sectionHeader(title, count) {
+  return `${cyan(`[${title}]`)} ${dim(`(${count})`)}`;
+}
+function formatPackageLine(pkg) {
+  let version = pkg.version && pkg.version !== "0.0.0" ? `@${pkg.version}` : "", stateSuffix = "";
+  return pkg.state === "missing" && (stateSuffix = dim(" (missing)")), `${pkg.name}${version}${stateSuffix}`;
+}
+function formatFilePath(file) {
+  return file.scope === "global" && !file.target.startsWith("~") ? `~/${file.target}` : file.target;
+}
+function printFileList(files, prefix, out) {
+  let sortedFiles = [...files].sort((a, b) => a.target.localeCompare(b.target));
+  for (let i = 0; i < sortedFiles.length; i++) {
+    let file = sortedFiles[i], connector = i === sortedFiles.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ", label = file.exists ? dim(file.target) : `${dim(file.target)} ${red("[MISSING]")}`;
+    out.info(`${prefix}${connector}${label}`);
+  }
+}
+var LIST_FILE_CONFIG = {
+  formatPath: (file) => file.target,
+  isMissing: (file) => !file.exists,
+  sortFiles: (a, b) => a.target.localeCompare(b.target)
+};
+function printResourceGroups(groups, prefix, showFiles) {
+  let flatResources = flattenResourceGroups(groups);
+  renderFlatResourceList(flatResources, prefix, showFiles, LIST_FILE_CONFIG);
+}
+function printRemotePackageDetail(result, showFiles, showDeps, output) {
+  let out = output ?? resolveOutput(), pkg = result.package;
+  out.info(`${formatPackageLine(pkg)} ${dim(`(${result.sourceLabel})`)} ${dim("[remote]")}`);
+  let metadata = result.metadata ?? [];
+  printMetadataSection(metadata, out);
+  let resourceCount = pkg.resourceGroups && pkg.resourceGroups.length > 0 ? flattenResourceGroups(pkg.resourceGroups).length : pkg.fileList?.length ?? 0;
+  out.info(sectionHeader("Resources", resourceCount)), pkg.resourceGroups && pkg.resourceGroups.length > 0 ? printResourceGroups(pkg.resourceGroups, "", showFiles) : pkg.fileList && pkg.fileList.length > 0 ? printFileList(pkg.fileList, "", out) : pkg.totalFiles === 0 && out.info(dim("\u2514\u2500\u2500 (no files)")), showDeps && (out.info(sectionHeader("Dependencies", result.dependencies.length)), result.dependencies.forEach((dep, index) => {
+    let connector = index === result.dependencies.length - 1 ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ", versionSuffix = dep.version ? `@${dep.version}` : "";
+    out.info(`${connector}${dep.name}${versionSuffix}`);
+  }));
+}
+function printDepTreeNode(node, prefix, isLast, showFiles, out) {
+  let hasChildren = node.children.length > 0, hasFiles = showFiles && node.report.fileList && node.report.fileList.length > 0, hasBranches = hasChildren || hasFiles, connector = isLast ? hasBranches ? "\u2514\u2500\u252C " : "\u2514\u2500\u2500 " : hasBranches ? "\u251C\u2500\u252C " : "\u251C\u2500\u2500 ", childPrefix = getChildPrefix(prefix, isLast);
+  out.info(`${prefix}${connector}${formatPackageLine(node.report)}`), hasFiles && printFileList(node.report.fileList, childPrefix, out), node.children.forEach((child, index) => {
+    let isLastChild = index === node.children.length - 1;
+    printDepTreeNode(child, childPrefix, isLastChild, showFiles, out);
+  });
+}
+function printDepsView(results, showFiles, headerInfo, output) {
+  let out = output ?? resolveOutput(), packageMap = /* @__PURE__ */ new Map();
+  for (let { scope, result } of results)
+    for (let node of result.tree) {
+      let key = node.report.name;
+      packageMap.has(key) ? packageMap.get(key).scopes.add(scope) : packageMap.set(key, {
+        report: node.report,
+        children: node.children,
+        scopes: /* @__PURE__ */ new Set([scope])
+      });
+    }
+  if (packageMap.size === 0) {
+    out.info(dim("No packages installed."));
+    return;
+  }
+  let workspaceEntry;
+  if (headerInfo?.type === "workspace" && headerInfo.name && (workspaceEntry = packageMap.get(headerInfo.name), workspaceEntry && packageMap.delete(headerInfo.name)), headerInfo) {
+    let version = headerInfo.version ? `@${headerInfo.version}` : "", typeTag = dim(`[${headerInfo.type}]`);
+    out.info(`${headerInfo.name}${version} ${dim(`(${headerInfo.path})`)} ${typeTag}`);
+  } else if (results.length > 0) {
+    let firstResult = results[0].result, version = firstResult.headerVersion ? `@${firstResult.headerVersion}` : "", typeTag = dim(`[${firstResult.headerType}]`);
+    out.info(`${firstResult.headerName}${version} ${dim(`(${firstResult.headerPath})`)} ${typeTag}`);
+  }
+  let entries = Array.from(packageMap.values()).sort((a, b) => a.report.name.localeCompare(b.report.name));
+  out.info(sectionHeader("Dependencies", entries.length)), workspaceEntry && showFiles && workspaceEntry.report.fileList && workspaceEntry.report.fileList.length > 0 && printFileList(workspaceEntry.report.fileList, "", out);
+  for (let i = 0; i < entries.length; i++) {
+    let entry = entries[i], isLast = i === entries.length - 1, hasChildren = entry.children.length > 0, hasFiles = showFiles && entry.report.fileList && entry.report.fileList.length > 0, hasBranches = hasChildren || hasFiles, scopeBadge = dim(formatScopeBadge(entry.scopes)), connector = isLast ? hasBranches ? "\u2514\u2500\u252C " : "\u2514\u2500\u2500 " : hasBranches ? "\u251C\u2500\u252C " : "\u251C\u2500\u2500 ", childPrefix = getChildPrefix("", isLast);
+    out.info(`${connector}${formatPackageLine(entry.report)} ${scopeBadge}`), hasFiles && printFileList(entry.report.fileList, childPrefix, out);
+    for (let ci = 0; ci < entry.children.length; ci++) {
+      let child = entry.children[ci], isLastChild = ci === entry.children.length - 1;
+      printDepTreeNode(child, childPrefix, isLastChild, showFiles, out);
+    }
+  }
+}
+function printResourcesView(groups, showFiles, headerInfo, options, output) {
+  let out = output ?? resolveOutput();
+  if (headerInfo) {
+    let version = headerInfo.version ? `@${headerInfo.version}` : "", typeTag = dim(`[${headerInfo.type}]`);
+    out.info(`${headerInfo.name}${version} ${dim(`(${headerInfo.path})`)} ${typeTag}`);
+  }
+  options?.metadata !== void 0 && printMetadataSection(options.metadata, out);
+  let showScopeBadges = options?.showScopeBadges !== !1, pathBase = options?.pathBaseForDisplay, showPackageLabels = headerInfo?.type !== "package" && process.env.OPKG_LIST_SHOW_PACKAGE_LABELS === "true", config = {
+    formatPath: (file) => pathBase ? formatPathForDisplay(file.target, pathBase) : formatFilePath(file),
+    isMissing: (file) => file.status === "missing",
+    sortFiles: (a, b) => {
+      let pathA = pathBase ? formatPathForDisplay(a.target, pathBase) : formatFilePath(a), pathB = pathBase ? formatPathForDisplay(b.target, pathBase) : formatFilePath(b);
+      return pathA.localeCompare(pathB);
+    },
+    ...showScopeBadges && {
+      getResourceBadge: (scopes) => scopes ? dim(formatScopeBadge(scopes)) : ""
+    },
+    ...showPackageLabels && {
+      getResourcePackageLabels: (packages) => !packages || packages.size === 0 ? [] : Array.from(packages).sort().map((pkg) => dim(`(${pkg})`))
+    }
+  }, flatResources = flattenResourceGroups(groups);
+  out.info(sectionHeader("Installed", flatResources.length)), renderFlatResourceList(flatResources, "", showFiles, config);
+}
+
+export {
+  groupFilesIntoResources,
+  detectEntityType,
+  collectScopedData,
+  mergeTrackedAndUntrackedResources,
+  mergeResourcesAcrossScopes,
+  resolveWorkspaceHeader,
+  extractMetadataFromManifest,
+  printMetadataSection,
+  dim,
+  sectionHeader,
+  printRemotePackageDetail,
+  printDepsView,
+  printResourcesView
+};
+//# sourceMappingURL=chunk-SSHWUJEG.js.map