opkg 0.9.2 → 0.9.4

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

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import {
+  getLocalOpenPackageDir
+} from "./chunk-VXNS3X5O.js";
+import {
+  normalizePathForProcessing
+} from "./chunk-YMKK4XPN.js";
+import {
+  FILE_PATTERNS
+} from "./chunk-IHVZ5AUJ.js";
+import {
+  ensureDir,
+  exists,
+  readTextFile,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/utils/workspace-index-yml.ts
+import { dirname, join } from "path";
+import * as yaml from "js-yaml";
+var HEADER_COMMENT = "# This file is managed by OpenPackage. Do not edit manually.";
+function getWorkspaceIndexPath(targetDir) {
+  return join(getLocalOpenPackageDir(targetDir), FILE_PATTERNS.OPENPACKAGE_INDEX_YML);
+}
+function sortAndDedupeStrings(values) {
+  return Array.from(new Set(values)).sort();
+}
+function sortFilesMapping(files) {
+  let sorted = {}, keys = Object.keys(files).sort();
+  for (let key of keys) {
+    let values = files[key] ?? [];
+    values.some((v) => typeof v == "object" && v !== null) ? sorted[key] = values.sort((a, b) => {
+      let targetA = typeof a == "string" ? a : a.target, targetB = typeof b == "string" ? b : b.target;
+      return targetA.localeCompare(targetB);
+    }) : sorted[key] = sortAndDedupeStrings(values);
+  }
+  return sorted;
+}
+function sanitizeWorkspaceIndexPackage(entry) {
+  if (!entry || typeof entry != "object") return null;
+  let rawPath = entry.path;
+  if (typeof rawPath != "string" || rawPath.trim().length === 0)
+    return null;
+  let pkg = {
+    path: rawPath,
+    files: {}
+  }, rawVersion = entry.version;
+  typeof rawVersion == "string" && rawVersion.trim().length > 0 && (pkg.version = rawVersion);
+  let rawDeps = entry.dependencies;
+  if (Array.isArray(rawDeps)) {
+    let deps = rawDeps.filter((d) => typeof d == "string" && d.trim().length > 0);
+    deps.length > 0 && (pkg.dependencies = sortAndDedupeStrings(deps));
+  }
+  let rawFiles = entry.files;
+  if (rawFiles && typeof rawFiles == "object") {
+    let files = {};
+    for (let [k, v] of Object.entries(rawFiles)) {
+      if (typeof k != "string" || !Array.isArray(v)) continue;
+      let normalizedKey = normalizePathForProcessing(k), targets = [];
+      for (let item of v) {
+        if (typeof item == "string") {
+          let trimmed = item.trim();
+          if (!trimmed) continue;
+          targets.push(normalizePathForProcessing(trimmed));
+          continue;
+        }
+        if (item && typeof item == "object") {
+          let rawTarget = item.target;
+          if (typeof rawTarget != "string" || rawTarget.trim().length === 0) continue;
+          let mapping = {
+            target: normalizePathForProcessing(rawTarget)
+          }, rawMerge = item.merge;
+          (rawMerge === "deep" || rawMerge === "shallow" || rawMerge === "replace" || rawMerge === "composite") && (mapping.merge = rawMerge);
+          let rawKeys = item.keys;
+          if (Array.isArray(rawKeys)) {
+            let cleanedKeys = rawKeys.filter((x) => typeof x == "string" && x.trim().length > 0);
+            cleanedKeys.length > 0 && (mapping.keys = cleanedKeys);
+          }
+          targets.push(mapping);
+        }
+      }
+      targets.length !== 0 && (files[normalizedKey] = targets);
+    }
+    pkg.files = sortFilesMapping(files);
+  }
+  let rawMarketplace = entry.marketplace;
+  if (rawMarketplace && typeof rawMarketplace == "object") {
+    let url = rawMarketplace.url, commitSha = rawMarketplace.commitSha, pluginName = rawMarketplace.pluginName;
+    typeof url == "string" && url.trim().length > 0 && typeof commitSha == "string" && commitSha.trim().length > 0 && typeof pluginName == "string" && pluginName.trim().length > 0 && (pkg.marketplace = { url, commitSha, pluginName });
+  }
+  return pkg;
+}
+function sanitizeWorkspaceIndexData(data) {
+  if (!data || typeof data != "object") return null;
+  let packagesSection = data.packages;
+  if (!packagesSection || typeof packagesSection != "object")
+    return { packages: {} };
+  let packages = {};
+  for (let [pkgName, pkgEntry] of Object.entries(packagesSection)) {
+    if (typeof pkgName != "string" || pkgName.trim().length === 0) continue;
+    let sanitized = sanitizeWorkspaceIndexPackage(pkgEntry);
+    sanitized && (packages[pkgName] = sanitized);
+  }
+  return { packages };
+}
+async function readWorkspaceIndex(targetDir) {
+  let indexPath = getWorkspaceIndexPath(targetDir);
+  if (!await exists(indexPath))
+    return {
+      path: indexPath,
+      index: { packages: {} }
+    };
+  try {
+    let content = await readTextFile(indexPath), parsed = yaml.load(content), sanitized = sanitizeWorkspaceIndexData(parsed);
+    return sanitized ? { path: indexPath, index: migrateGitHubPackageNames(sanitized) } : (logger.warn(`Invalid workspace index detected at ${indexPath}, returning empty.`), { path: indexPath, index: { packages: {} } });
+  } catch (error) {
+    return logger.warn(`Failed to read workspace index at ${indexPath}: ${error}`), { path: indexPath, index: { packages: {} } };
+  }
+}
+function migrateGitHubPackageNames(index) {
+  let migratedPackages = {};
+  for (let [pkgName, pkgData] of Object.entries(index.packages)) {
+    let normalizedPath = pkgData.path.replace(/\\/g, "/"), isGitSource = !pkgData.version, isGitCache = normalizedPath.includes("/.openpackage/cache/git/") || normalizedPath.includes(".openpackage/cache/git/");
+    if (!isGitSource && !isGitCache) {
+      migratedPackages[pkgName] = pkgData;
+      continue;
+    }
+    let actualSubpath = normalizedPath.match(/\.openpackage\/cache\/git\/[^\/]+\/[^\/]+(?:\/(.+))?$/)?.[1] || void 0, username, repo, nameHasGhPrefix = !1, nameSubpathFromName;
+    if (pkgName.startsWith("gh@")) {
+      nameHasGhPrefix = !0;
+      let ghMatch = pkgName.match(/^gh@([^\/]+)\/([^\/]+)(?:\/(.+))?$/);
+      ghMatch && (username = ghMatch[1], repo = ghMatch[2], nameSubpathFromName = ghMatch[3] || void 0);
+    } else if (pkgName.startsWith("@")) {
+      let atMatch = pkgName.match(/^@([^\/]+)\/([^\/]+)(?:\/(.+))?$/);
+      atMatch && (username = atMatch[1], repo = atMatch[2], nameSubpathFromName = atMatch[3] || void 0);
+    } else {
+      let noAtMatch = pkgName.match(/^([^\/]+)\/([^\/]+)(?:\/(.+))?$/);
+      noAtMatch && (username = noAtMatch[1], repo = noAtMatch[2], nameSubpathFromName = noAtMatch[3] || void 0);
+    }
+    if (!username || !repo) {
+      migratedPackages[pkgName] = pkgData;
+      continue;
+    }
+    let nameSubpath = nameSubpathFromName, targetSubpath = actualSubpath;
+    if (actualSubpath && nameSubpath) {
+      let actualNorm = actualSubpath.replace(/\\/g, "/"), nameNorm = nameSubpath.replace(/\\/g, "/");
+      nameNorm === actualNorm || actualNorm.endsWith(`/${nameNorm}`) ? targetSubpath = actualSubpath : (nameNorm.startsWith(`${actualNorm}/`), targetSubpath = nameSubpath);
+    } else !actualSubpath && nameSubpath ? targetSubpath = nameSubpath : actualSubpath && !nameSubpath && (targetSubpath = actualSubpath);
+    let correctName = targetSubpath ? `gh@${username}/${repo}/${targetSubpath}` : `gh@${username}/${repo}`;
+    migratedPackages[correctName] = pkgData;
+  }
+  return { packages: migratedPackages };
+}
+async function writeWorkspaceIndex(record) {
+  let indexPath = record.path, packages = migrateGitHubPackageNames(record.index).packages ?? {}, sortedPackages = {};
+  for (let pkgName of Object.keys(packages).sort()) {
+    let pkg = packages[pkgName], sortedPkg = {
+      path: pkg.path,
+      files: sortFilesMapping(pkg.files ?? {})
+    };
+    pkg.version && (sortedPkg.version = pkg.version), pkg.dependencies && pkg.dependencies.length > 0 && (sortedPkg.dependencies = sortAndDedupeStrings(pkg.dependencies)), pkg.marketplace && (sortedPkg.marketplace = pkg.marketplace), sortedPackages[pkgName] = sortedPkg;
+  }
+  await ensureDir(dirname(indexPath));
+  let body = yaml.dump(
+    {
+      packages: sortedPackages
+    },
+    {
+      lineWidth: 120,
+      sortKeys: !0
+    }
+  ), serialized = `${HEADER_COMMENT}
+
+${body}`;
+  await writeTextFile(indexPath, serialized);
+}
+
+export {
+  getWorkspaceIndexPath,
+  readWorkspaceIndex,
+  writeWorkspaceIndex
+};
+//# sourceMappingURL=chunk-DEC24S7E.js.map

package/packages/cli/dist/chunk-DEC24S7E.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../core/src/utils/workspace-index-yml.ts"],
+  "sourcesContent": ["import { dirname, join } from 'path';\nimport * as yaml from 'js-yaml';\nimport { FILE_PATTERNS } from '../constants/index.js';\nimport { getLocalOpenPackageDir } from './paths.js';\nimport { exists, ensureDir, readTextFile, writeTextFile } from './fs.js';\nimport { normalizePathForProcessing } from './path-normalization.js';\nimport { logger } from './logger.js';\nimport { WorkspaceIndex, WorkspaceIndexPackage } from '../types/workspace-index.js';\nimport type { WorkspaceIndexFileMapping } from '../types/workspace-index.js';\n\nconst HEADER_COMMENT = '# This file is managed by OpenPackage. Do not edit manually.';\n\nexport interface WorkspaceIndexRecord {\n  path: string;\n  index: WorkspaceIndex;\n}\n\nexport function getWorkspaceIndexPath(targetDir: string): string {\n  return join(getLocalOpenPackageDir(targetDir), FILE_PATTERNS.OPENPACKAGE_INDEX_YML);\n}\n\nfunction sortAndDedupeStrings(values: string[]): string[] {\n  return Array.from(new Set(values)).sort();\n}\n\nfunction sortFilesMapping(files: Record<string, any[]>): Record<string, any[]> {\n  const sorted: Record<string, any[]> = {};\n  const keys = Object.keys(files).sort();\n  for (const key of keys) {\n    const values = files[key] ?? [];\n    // Handle both string[] and (string | WorkspaceIndexFileMapping)[]\n    const hasComplex = values.some(v => typeof v === 'object' && v !== null);\n    if (hasComplex) {\n      // Complex mappings - sort by target path\n      sorted[key] = values.sort((a, b) => {\n        const targetA = typeof a === 'string' ? a : a.target;\n        const targetB = typeof b === 'string' ? b : b.target;\n        return targetA.localeCompare(targetB);\n      });\n    } else {\n      // Simple string array\n      sorted[key] = sortAndDedupeStrings(values as string[]);\n    }\n  }\n  return sorted;\n}\n\nfunction sanitizeWorkspaceIndexPackage(entry: any): WorkspaceIndexPackage | null {\n  if (!entry || typeof entry !== 'object') return null;\n\n  const rawPath = (entry as { path?: unknown }).path;\n  if (typeof rawPath !== 'string' || rawPath.trim().length === 0) {\n    return null;\n  }\n\n  const pkg: WorkspaceIndexPackage = {\n    path: rawPath,\n    files: {}\n  };\n\n  const rawVersion = (entry as { version?: unknown }).version;\n  if (typeof rawVersion === 'string' && rawVersion.trim().length > 0) {\n    pkg.version = rawVersion;\n  }\n\n  const rawDeps = (entry as { dependencies?: unknown }).dependencies;\n  if (Array.isArray(rawDeps)) {\n    const deps = rawDeps.filter((d): d is string => typeof d === 'string' && d.trim().length > 0);\n    if (deps.length > 0) {\n      pkg.dependencies = sortAndDedupeStrings(deps);\n    }\n  }\n\n  const rawFiles = (entry as { files?: unknown }).files;\n  if (rawFiles && typeof rawFiles === 'object') {\n    const files: Record<string, (string | WorkspaceIndexFileMapping)[]> = {};\n    for (const [k, v] of Object.entries(rawFiles as Record<string, unknown>)) {\n      if (typeof k !== 'string' || !Array.isArray(v)) continue;\n      const normalizedKey = normalizePathForProcessing(k);\n      const targets: (string | WorkspaceIndexFileMapping)[] = [];\n      for (const item of v as unknown[]) {\n        if (typeof item === 'string') {\n          const trimmed = item.trim();\n          if (!trimmed) continue;\n          targets.push(normalizePathForProcessing(trimmed));\n          continue;\n        }\n        if (item && typeof item === 'object') {\n          const rawTarget = (item as any).target;\n          if (typeof rawTarget !== 'string' || rawTarget.trim().length === 0) continue;\n          const mapping: WorkspaceIndexFileMapping = {\n            target: normalizePathForProcessing(rawTarget)\n          };\n          const rawMerge = (item as any).merge;\n          if (rawMerge === 'deep' || rawMerge === 'shallow' || rawMerge === 'replace' || rawMerge === 'composite') {\n            mapping.merge = rawMerge;\n          }\n          const rawKeys = (item as any).keys;\n          if (Array.isArray(rawKeys)) {\n            const cleanedKeys = rawKeys.filter((x: any) => typeof x === 'string' && x.trim().length > 0);\n            if (cleanedKeys.length > 0) {\n              mapping.keys = cleanedKeys;\n            }\n          }\n          targets.push(mapping);\n        }\n      }\n      if (targets.length === 0) continue;\n      files[normalizedKey] = targets;\n    }\n    pkg.files = sortFilesMapping(files);\n  }\n\n  // Parse marketplace metadata if present\n  const rawMarketplace = (entry as { marketplace?: unknown }).marketplace;\n  if (rawMarketplace && typeof rawMarketplace === 'object') {\n    const url = (rawMarketplace as any).url;\n    const commitSha = (rawMarketplace as any).commitSha;\n    const pluginName = (rawMarketplace as any).pluginName;\n    \n    if (typeof url === 'string' && url.trim().length > 0 &&\n        typeof commitSha === 'string' && commitSha.trim().length > 0 &&\n        typeof pluginName === 'string' && pluginName.trim().length > 0) {\n      pkg.marketplace = { url, commitSha, pluginName };\n    }\n  }\n\n  return pkg;\n}\n\nfunction sanitizeWorkspaceIndexData(data: any): WorkspaceIndex | null {\n  if (!data || typeof data !== 'object') return null;\n  const packagesSection = (data as { packages?: unknown }).packages;\n  if (!packagesSection || typeof packagesSection !== 'object') {\n    return { packages: {} };\n  }\n\n  const packages: Record<string, WorkspaceIndexPackage> = {};\n  for (const [pkgName, pkgEntry] of Object.entries(packagesSection as Record<string, unknown>)) {\n    if (typeof pkgName !== 'string' || pkgName.trim().length === 0) continue;\n    const sanitized = sanitizeWorkspaceIndexPackage(pkgEntry);\n    if (sanitized) {\n      packages[pkgName] = sanitized;\n    }\n  }\n\n  return { packages };\n}\n\nexport async function readWorkspaceIndex(targetDir: string): Promise<WorkspaceIndexRecord> {\n  const indexPath = getWorkspaceIndexPath(targetDir);\n\n  if (!(await exists(indexPath))) {\n    return {\n      path: indexPath,\n      index: { packages: {} }\n    };\n  }\n\n  try {\n    const content = await readTextFile(indexPath);\n    const parsed = yaml.load(content) as any;\n    const sanitized = sanitizeWorkspaceIndexData(parsed);\n    if (!sanitized) {\n      logger.warn(`Invalid workspace index detected at ${indexPath}, returning empty.`);\n      return { path: indexPath, index: { packages: {} } };\n    }\n    \n    // Migrate in-memory on read so consumers see a unified key format.\n    // (Disk is only updated when writeWorkspaceIndex is called.)\n    return { path: indexPath, index: migrateGitHubPackageNames(sanitized) };\n  } catch (error) {\n    logger.warn(`Failed to read workspace index at ${indexPath}: ${error}`);\n    return { path: indexPath, index: { packages: {} } };\n  }\n}\n\n/**\n * Migrate old GitHub package names to new format.\n * Converts:\n * - @username/repo \u2192 gh@username/repo\n * - @username/repo/path \u2192 gh@username/repo/path\n * \n * Also normalizes package names to use full path from git cache location.\n * For example: gh@user/repo/basename \u2192 gh@user/repo/full/path\n */\nfunction migrateGitHubPackageNames(index: WorkspaceIndex): WorkspaceIndex {\n  const migratedPackages: Record<string, WorkspaceIndexPackage> = {};\n  \n  for (const [pkgName, pkgData] of Object.entries(index.packages)) {\n    const normalizedPath = pkgData.path.replace(/\\\\/g, '/');\n    \n    // Detect if this is a git source by checking:\n    // 1. No version field (git sources don't have semver versions)\n    // 2. Path contains git cache location marker\n    const isGitSource = !pkgData.version;\n    const isGitCache = normalizedPath.includes('/.openpackage/cache/git/') || \n                       normalizedPath.includes('.openpackage/cache/git/');\n    \n    if (!isGitSource && !isGitCache) {\n      // Not a git source, keep as-is\n      migratedPackages[pkgName] = pkgData;\n      continue;\n    }\n    \n    // Extract the actual path from git cache location\n    // Format: .openpackage/cache/git/{url-hash}/{commit-hash}/{optional-subpath}\n    const gitCacheMatch = normalizedPath.match(/\\.openpackage\\/cache\\/git\\/[^\\/]+\\/[^\\/]+(?:\\/(.+))?$/);\n    const actualSubpath = gitCacheMatch?.[1] || undefined;\n    \n    // Parse package name to extract username/repo\n    let username: string | undefined;\n    let repo: string | undefined;\n    let nameHasGhPrefix = false;\n    let nameSubpathFromName: string | undefined;\n    \n    // Check for gh@ prefix first\n    if (pkgName.startsWith('gh@')) {\n      nameHasGhPrefix = true;\n      const ghMatch = pkgName.match(/^gh@([^\\/]+)\\/([^\\/]+)(?:\\/(.+))?$/);\n      if (ghMatch) {\n        username = ghMatch[1];\n        repo = ghMatch[2];\n        nameSubpathFromName = ghMatch[3] || undefined;\n      }\n    }\n    // Check for @ prefix (old format)\n    else if (pkgName.startsWith('@')) {\n      const atMatch = pkgName.match(/^@([^\\/]+)\\/([^\\/]+)(?:\\/(.+))?$/);\n      if (atMatch) {\n        username = atMatch[1];\n        repo = atMatch[2];\n        nameSubpathFromName = atMatch[3] || undefined;\n      }\n    }\n    // Check for no prefix (missing @)\n    else {\n      const noAtMatch = pkgName.match(/^([^\\/]+)\\/([^\\/]+)(?:\\/(.+))?$/);\n      if (noAtMatch) {\n        username = noAtMatch[1];\n        repo = noAtMatch[2];\n        nameSubpathFromName = noAtMatch[3] || undefined;\n      }\n    }\n    \n    // If we couldn't extract username/repo, keep original\n    if (!username || !repo) {\n      migratedPackages[pkgName] = pkgData;\n      continue;\n    }\n\n    // Decide whether to migrate the subpath portion.\n    // IMPORTANT: Never \"collapse\" a more-specific resource name to a less-specific path.\n    // Example: keep gh@u/r/plugins/x/skills/y even if cache path is plugins/x.\n    const nameSubpath = nameSubpathFromName;\n\n    let targetSubpath: string | undefined = actualSubpath;\n    if (actualSubpath && nameSubpath) {\n      const actualNorm = actualSubpath.replace(/\\\\/g, '/');\n      const nameNorm = nameSubpath.replace(/\\\\/g, '/');\n\n      if (nameNorm === actualNorm) {\n        // exact match, ok\n        targetSubpath = actualSubpath;\n      } else if (actualNorm.endsWith(`/${nameNorm}`)) {\n        // Old basename-style name: gh@u/r/basename \u2192 gh@u/r/full/path\n        targetSubpath = actualSubpath;\n      } else if (nameNorm.startsWith(`${actualNorm}/`)) {\n        // Resource-scoped install: keep the more-specific name\n        targetSubpath = nameSubpath;\n      } else {\n        // Unknown relationship: prefer not to rewrite (avoid data loss)\n        targetSubpath = nameSubpath;\n      }\n    } else if (!actualSubpath && nameSubpath) {\n      // No cache subpath detected, keep explicit name subpath\n      targetSubpath = nameSubpath;\n    } else if (actualSubpath && !nameSubpath) {\n      // Name has no subpath but cache does \u2192 upgrade to include subpath\n      targetSubpath = actualSubpath;\n    }\n\n    // Build the correct package name (at minimum, normalize to gh@ prefix)\n    const correctName = targetSubpath\n      ? `gh@${username}/${repo}/${targetSubpath}`\n      : `gh@${username}/${repo}`;\n    \n    // Use the correct name (which might be the same as original if already correct)\n    migratedPackages[correctName] = pkgData;\n  }\n  \n  return { packages: migratedPackages };\n}\n\nexport async function writeWorkspaceIndex(record: WorkspaceIndexRecord): Promise<void> {\n  const indexPath = record.path;\n  \n  // Migrate package names before writing\n  const migrated = migrateGitHubPackageNames(record.index);\n  const packages = migrated.packages ?? {};\n\n  const sortedPackages: Record<string, WorkspaceIndexPackage> = {};\n  for (const pkgName of Object.keys(packages).sort()) {\n    const pkg = packages[pkgName];\n    const sortedPkg: WorkspaceIndexPackage = {\n      path: pkg.path,\n      files: sortFilesMapping(pkg.files ?? {})\n    };\n    if (pkg.version) {\n      sortedPkg.version = pkg.version;\n    }\n    if (pkg.dependencies && pkg.dependencies.length > 0) {\n      sortedPkg.dependencies = sortAndDedupeStrings(pkg.dependencies);\n    }\n    if (pkg.marketplace) {\n      sortedPkg.marketplace = pkg.marketplace;\n    }\n    sortedPackages[pkgName] = sortedPkg;\n  }\n\n  await ensureDir(dirname(indexPath));\n\n  const body = yaml.dump(\n    {\n      packages: sortedPackages\n    },\n    {\n      lineWidth: 120,\n      sortKeys: true\n    }\n  );\n\n  const serialized = `${HEADER_COMMENT}\\n\\n${body}`;\n  await writeTextFile(indexPath, serialized);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import {
+  walkFiles
+} from "./chunk-A6ISKBNM.js";
+import {
+  createWorkspacePackageYml,
+  ensureLocalOpenPackageStructure
+} from "./chunk-D3O7LY2Q.js";
+import {
+  getLocalOpenPackageDir
+} from "./chunk-VXNS3X5O.js";
+import {
+  parsePackageYml
+} from "./chunk-427DCURL.js";
+import {
+  FILE_PATTERNS
+} from "./chunk-IHVZ5AUJ.js";
+import {
+  exists
+} from "./chunk-S47F4OG4.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/workspace-package-context.ts
+import { join, basename } from "path";
+async function buildWorkspacePackageContext(cwd) {
+  await ensureLocalOpenPackageStructure(cwd), await createWorkspacePackageYml(cwd);
+  let openpackageDir = getLocalOpenPackageDir(cwd), packageYmlPath = join(openpackageDir, FILE_PATTERNS.OPENPACKAGE_YML), config;
+  try {
+    config = await parsePackageYml(packageYmlPath);
+  } catch (error) {
+    throw new Error(
+      `Failed to read workspace manifest at ${packageYmlPath}: ${error}`
+    );
+  }
+  return {
+    name: config.name || basename(cwd),
+    version: config.version,
+    config,
+    packageYmlPath,
+    packageRootDir: openpackageDir,
+    packageFilesDir: openpackageDir
+  };
+}
+
+// ../core/src/utils/expand-directory-selections.ts
+import { join as join2, relative } from "path";
+import { promises as fs } from "fs";
+import { isJunk } from "junk";
+async function expandDirectorySelections(selectedPaths, basePath) {
+  let expandedFiles = [], seenFiles = /* @__PURE__ */ new Set();
+  for (let path of selectedPaths)
+    if (path.endsWith("/")) {
+      let dirPath = path.slice(0, -1), absDirPath = join2(basePath, dirPath);
+      try {
+        if (!(await fs.stat(absDirPath)).isDirectory())
+          continue;
+      } catch {
+        continue;
+      }
+      let filter = (filePath, isDirectory) => {
+        if (isDirectory)
+          return !0;
+        let segments = filePath.split("/"), basename2 = segments[segments.length - 1];
+        return !isJunk(basename2);
+      };
+      for await (let filePath of walkFiles(absDirPath, { filter })) {
+        let relativePath = relative(basePath, filePath);
+        seenFiles.has(relativePath) || (seenFiles.add(relativePath), expandedFiles.push(relativePath));
+      }
+    } else
+      seenFiles.has(path) || (seenFiles.add(path), expandedFiles.push(path));
+  return expandedFiles;
+}
+function hasDirectorySelections(selectedPaths) {
+  return selectedPaths.some((path) => path.endsWith("/"));
+}
+function countSelectionTypes(selectedPaths) {
+  let dirs = 0, files = 0;
+  for (let path of selectedPaths)
+    path.endsWith("/") ? dirs++ : files++;
+  return { dirs, files };
+}
+
+// src/utils/interactive-file-selector.ts
+import { note, log } from "@clack/prompts";
+
+// src/utils/file-selector-with-header.ts
+import { AutocompletePrompt, isCancel } from "@clack/core";
+import { search } from "fast-fuzzy";
+import pico from "picocolors";
+var FileSelectorWithHeader = class extends AutocompletePrompt {
+  constructor(options) {
+    let fileOptions = options.files.map((file) => ({
+      value: file,
+      label: file
+    }));
+    super({
+      options: fileOptions,
+      multiple: !0,
+      render() {
+        return this.renderWithHeader();
+      }
+    }), this.allFiles = options.files, this.message = options.message, this.placeholder = options.placeholder || "Type to search...", this.maxVisibleItems = options.maxItems || 10, this.fuzzyThreshold = options.fuzzyThreshold || 0.5, this.setupFuzzyFiltering(), this.setupNoOverscroll();
+  }
+  /**
+   * Prevent wrap-around: stay at top when pressing up at first item (don't jump to last)
+   */
+  setupNoOverscroll() {
+    this.on("key", (_char, key) => {
+      let len = this.filteredOptions.length;
+      len <= 1 || key.name === "up" && this.cursor === len - 1 && this.emit("key", void 0, { name: "down", ctrl: !1, meta: !1, shift: !1 });
+    });
+  }
+  /**
+   * Setup fuzzy filtering based on user input
+   */
+  setupFuzzyFiltering() {
+    this.on("userInput", () => {
+      this.updateFilteredOptions();
+    });
+  }
+  /**
+   * Update filtered options based on current user input
+   */
+  updateFilteredOptions() {
+    let input = this.userInput, filteredFiles;
+    !input || input.trim() === "" ? filteredFiles = this.allFiles : filteredFiles = search(input, this.allFiles, {
+      threshold: this.fuzzyThreshold,
+      ignoreCase: !0,
+      returnMatchData: !1
+    }), this.filteredOptions = filteredFiles.map((file) => ({
+      value: file,
+      label: file
+    }));
+  }
+  /**
+   * Main render method with dynamic header
+   */
+  renderWithHeader() {
+    if (this.state === "cancel")
+      return this.renderCancelled();
+    if (this.state === "submit")
+      return this.selectedValues.length === 0 ? this.renderCancelled() : this.renderSubmitted();
+    let sections = [];
+    return sections.push(this.renderSelectedFilesHeader()), sections.push(this.renderSearchSection()), sections.push(this.renderOptionsList()), sections.push(this.renderFooter()), sections.join(`
+`);
+  }
+  /**
+   * Get a smart label for the current selection (e.g., "2 dirs, 1 file" or "3 files")
+   */
+  getSelectionLabel() {
+    let count = this.selectedValues.length, dirs = this.selectedValues.filter((v) => v.endsWith("/")).length, files = count - dirs;
+    return dirs === 0 ? `${files} file${files === 1 ? "" : "s"}` : files === 0 ? `${dirs} dir${dirs === 1 ? "" : "s"}` : `${dirs} dir${dirs === 1 ? "" : "s"}, ${files} file${files === 1 ? "" : "s"}`;
+  }
+  /**
+   * Render the selected files header using Clack's simple log-style format
+   */
+  renderSelectedFilesHeader() {
+    let count = this.selectedValues.length, lines = [], title = count === 0 ? `Selected: ${pico.dim("none (use Space to select)")}` : `Selected: ${pico.cyan(this.getSelectionLabel())}`;
+    if (lines.push(`${pico.cyan("\u25C6")}  ${title}`), count > 0) {
+      let displayCount = Math.min(5, count);
+      for (let i = 0; i < displayCount; i++) {
+        let file = this.selectedValues[i];
+        lines.push(`${pico.cyan("\u2502")}  ${pico.dim("\u2713 " + file)}`);
+      }
+      count > displayCount && lines.push(`${pico.cyan("\u2502")}  ${pico.dim(`... and ${count - displayCount} more`)}`);
+    }
+    return lines.push(pico.cyan("\u2502")), lines.join(`
+`);
+  }
+  /**
+   * Render the search section
+   */
+  renderSearchSection() {
+    let matchCount = this.filteredOptions.length, totalCount = this.allFiles.length, stateSymbol = pico.cyan("\u25C6"), searchLabel = pico.dim("Search:"), input = this.userInput || pico.gray(this.placeholder), cursor = this.state === "active" ? pico.cyan("\u2588") : "", matches = matchCount !== totalCount ? pico.dim(` (${matchCount} ${matchCount === 1 ? "match" : "matches"})`) : "";
+    return `${stateSymbol}  ${this.message}
+${pico.cyan("\u2502")}  ${searchLabel} ${input}${cursor}${matches}`;
+  }
+  /**
+   * Render the options list with sliding window to keep cursor in view
+   */
+  renderOptionsList() {
+    let lines = [], totalOptions = this.filteredOptions.length, maxItems = this.maxVisibleItems;
+    if (totalOptions === 0)
+      return lines.push(`${pico.cyan("\u2502")}  ${pico.gray("No matches found")}`), lines.join(`
+`);
+    let visibleStart = 0;
+    this.cursor >= maxItems - 3 && (visibleStart = Math.max(0, Math.min(this.cursor - maxItems + 3, totalOptions - maxItems)));
+    let visibleEnd = Math.min(visibleStart + maxItems, totalOptions), visibleOptions = this.filteredOptions.slice(visibleStart, visibleEnd);
+    visibleStart > 0 && lines.push(`${pico.cyan("\u2502")}  ${pico.gray(`... ${visibleStart} above`)}`);
+    for (let i = 0; i < visibleOptions.length; i++) {
+      let option = visibleOptions[i], isSelected = this.selectedValues.includes(option.value), isCursor = visibleStart + i === this.cursor, checkbox = isSelected ? pico.cyan("\u25FC") : pico.dim("\u25FB"), cursorMark = isCursor ? pico.cyan("\u25B8") : " ", fileName = option.label;
+      isCursor ? fileName = pico.cyan(fileName) : isSelected ? fileName = pico.white(fileName) : fileName = pico.dim(fileName), lines.push(`${pico.cyan("\u2502")} ${cursorMark} ${checkbox} ${fileName}`);
+    }
+    if (visibleEnd < totalOptions) {
+      let remaining = totalOptions - visibleEnd;
+      lines.push(`${pico.cyan("\u2502")}  ${pico.gray(`... ${remaining} more`)}`);
+    }
+    return lines.join(`
+`);
+  }
+  /**
+   * Render the footer with hints
+   */
+  renderFooter() {
+    let hints = pico.dim("Space: select \u2022 Enter: confirm \u2022 Esc: cancel");
+    return `${pico.cyan("\u2514")}  ${hints}`;
+  }
+  /**
+   * Render the collapsed cancelled state
+   */
+  renderCancelled() {
+    let symbol = pico.red("\u25A0"), end = pico.gray("\u2514");
+    return `${symbol}  ${this.message}
+${end}  ${pico.dim("Operation cancelled")}`;
+  }
+  /**
+   * Render the collapsed submitted state (for successful selection)
+   */
+  renderSubmitted() {
+    let symbol = pico.green("\u25C7"), bar = pico.gray("\u2502"), status = pico.dim(this.getSelectionLabel() + " selected");
+    return `${symbol}  ${this.message}
+${bar}  ${status}`;
+  }
+};
+async function promptFileSelector(options) {
+  let result = await new FileSelectorWithHeader(options).prompt();
+  return isCancel(result) ? null : result;
+}
+
+// ../core/src/utils/file-scanner.ts
+import { relative as relative2 } from "path";
+import { isJunk as isJunk2 } from "junk";
+var DEFAULT_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".turbo",
+  "dist",
+  "build",
+  "out",
+  ".cache",
+  "coverage",
+  ".nyc_output",
+  ".parcel-cache",
+  ".webpack",
+  ".vscode",
+  ".idea",
+  "__pycache__",
+  "target",
+  "vendor"
+]);
+function isExcludedDir(fullPath, excludeDirs) {
+  let segments = fullPath.split("/");
+  for (let segment of segments)
+    if (excludeDirs.has(segment))
+      return !0;
+  return !1;
+}
+async function scanWorkspaceFiles(options = {}) {
+  let {
+    cwd = process.cwd(),
+    basePath,
+    excludeDirs = [],
+    maxFiles = 1e4,
+    followSymlinks = !1,
+    includeDirs = !1
+  } = options, scanDir = basePath || cwd, allExcludeDirs = /* @__PURE__ */ new Set([
+    ...DEFAULT_EXCLUDE_DIRS,
+    ...excludeDirs
+  ]), files = [], dirs = [], fileCount = 0;
+  try {
+    let filter = (path, isDirectory) => {
+      let segments = path.split("/"), basename2 = segments[segments.length - 1];
+      return !(isJunk2(basename2) || isExcludedDir(path, allExcludeDirs));
+    };
+    for await (let filePath of walkFiles(scanDir, { filter, followSymlinks, includeDirs })) {
+      if (fileCount >= maxFiles) {
+        logger.debug(`File scan limit reached: ${maxFiles} files`);
+        break;
+      }
+      let relativePath = relative2(scanDir, filePath);
+      !relativePath || relativePath === "." || (includeDirs && (await (await import("fs")).promises.stat(filePath)).isDirectory() ? dirs.push(relativePath + "/") : files.push(relativePath), fileCount++);
+    }
+    let allItems = [...dirs.sort(), ...files.sort()];
+    return allItems.sort((a, b) => {
+      let aPath = a.endsWith("/") ? a.slice(0, -1) : a, bPath = b.endsWith("/") ? b.slice(0, -1) : b, aDepth = aPath.split("/").length, bDepth = bPath.split("/").length;
+      return aDepth !== bDepth ? aDepth - bDepth : a.localeCompare(b);
+    }), logger.debug(`Scanned ${allItems.length} items in workspace`, { scanDir, includeDirs }), allItems;
+  } catch (error) {
+    throw logger.error("Error scanning workspace files", { error, scanDir }), new Error(`Failed to scan workspace files: ${error}`);
+  }
+}
+
+// src/utils/interactive-file-selector.ts
+async function interactiveFileSelect(options = {}) {
+  let {
+    cwd = process.cwd(),
+    basePath,
+    message,
+    placeholder,
+    maxItems = 10,
+    excludeDirs = [],
+    fuzzyThreshold = 0.5,
+    includeDirs = !1
+  } = options, finalMessage = message || (includeDirs ? "Select files or directories to add" : "Select files to add"), finalPlaceholder = placeholder || (includeDirs ? "Type to search..." : "Type to search files..."), scanDir = basePath || cwd;
+  try {
+    logger.debug("Scanning workspace for files", { scanDir });
+    let allFiles = await scanWorkspaceFiles({ cwd, basePath, excludeDirs, includeDirs });
+    if (allFiles.length === 0)
+      return logger.warn("No files found in workspace"), note("No files found in the workspace directory", "No Files"), null;
+    logger.debug(`Found ${allFiles.length} files to display`);
+    let selectedFiles = await promptFileSelector({
+      message: finalMessage,
+      files: allFiles,
+      placeholder: finalPlaceholder,
+      maxItems,
+      fuzzyThreshold
+    });
+    if (!selectedFiles || selectedFiles.length === 0)
+      return logger.debug("No files selected or user cancelled"), null;
+    logger.debug(`User selected ${selectedFiles.length} file(s)`, { selectedFiles });
+    let fileList = selectedFiles.length <= 5 ? selectedFiles.join(`
+`) : selectedFiles.slice(0, 5).join(`
+`) + `
+... and ${selectedFiles.length - 5} more`, countLabel = includeDirs ? (() => {
+      let { dirs, files } = countSelectionTypes(selectedFiles), parts = [];
+      return dirs > 0 && parts.push(`${dirs} dir${dirs === 1 ? "" : "s"}`), files > 0 && parts.push(`${files} file${files === 1 ? "" : "s"}`), parts.join(" and ");
+    })() : `${selectedFiles.length} file${selectedFiles.length === 1 ? "" : "s"}`;
+    return log.success(`Selected ${countLabel}:
+${fileList}`), selectedFiles;
+  } catch (error) {
+    throw logger.error("Error during file selection", { error }), new Error(`File selection failed: ${error}`);
+  }
+}
+
+// ../core/src/utils/source-operation-arguments.ts
+import { resolve as resolvePath, join as join3 } from "path";
+async function resolveSourceOperationArguments(cwd, packageName, pathArg, options) {
+  let { command, checkWorkspaceRoot = !1 } = options, flagName = command === "add" ? "--to" : "--from";
+  if (packageName && pathArg)
+    return { resolvedPackageName: packageName, resolvedPath: pathArg };
+  let singleArg = packageName || pathArg;
+  if (!singleArg)
+    throw new Error(`Path argument is required for ${command}.`);
+  let absPath = resolvePath(cwd, singleArg), pathExists = await exists(absPath);
+  if (!pathExists && checkWorkspaceRoot) {
+    let openpackageDir = getLocalOpenPackageDir(cwd), workspaceRootPath = join3(openpackageDir, singleArg);
+    pathExists = await exists(workspaceRootPath);
+  }
+  if (pathExists)
+    return { resolvedPackageName: null, resolvedPath: singleArg };
+  if (checkWorkspaceRoot && command === "remove")
+    return { resolvedPackageName: null, resolvedPath: singleArg };
+  throw new Error(
+    `Path '${singleArg}' not found.
+
+If you meant to specify a package name, use: opkg ${command} <path> ${flagName} ${singleArg}`
+  );
+}
+
+export {
+  resolveSourceOperationArguments,
+  buildWorkspacePackageContext,
+  expandDirectorySelections,
+  hasDirectorySelections,
+  interactiveFileSelect
+};
+//# sourceMappingURL=chunk-FMVVJH5M.js.map