opkg 0.9.0 → 0.9.2

package/packages/cli/dist/add-AFORN4DK.js

@@ -0,0 +1,624 @@
+#!/usr/bin/env node
+import {
+  buildWorkspacePackageContext,
+  expandDirectorySelections,
+  hasDirectorySelections,
+  interactiveFileSelect,
+  resolveSourceOperationArguments
+} from "./chunk-BN3JSWOU.js";
+import {
+  resolveMutableSource
+} from "./chunk-QQFDQPT3.js";
+import {
+  assertMutableSourceOrThrow
+} from "./chunk-IBIYIU3K.js";
+import {
+  classifyInputBase,
+  isPlatformRootFile
+} from "./chunk-GJWX5XPU.js";
+import "./chunk-4TCVCEPB.js";
+import {
+  createInteractionPolicy
+} from "./chunk-SVEFLCC2.js";
+import {
+  applyMapPipeline,
+  createMapContext,
+  defaultTransformRegistry,
+  parseMarkdownDocument,
+  serializeMarkdownDocument,
+  splitMapPipeline
+} from "./chunk-IXOEIRDT.js";
+import "./chunk-E2DVTD75.js";
+import "./chunk-A6ISKBNM.js";
+import {
+  addPackageToYml,
+  createWorkspacePackageYml,
+  ensureLocalOpenPackageStructure
+} from "./chunk-WQG6LPP3.js";
+import "./chunk-DN7RINDJ.js";
+import {
+  detectPluginType
+} from "./chunk-TFQ4JBVO.js";
+import {
+  getLocalPackageYmlPath
+} from "./chunk-BCYZDID6.js";
+import {
+  isValidPackageDirectory
+} from "./chunk-V5OW4YEB.js";
+import "./chunk-Q2N6OZJC.js";
+import {
+  formatPathForYaml
+} from "./chunk-FRYA3JAQ.js";
+import {
+  formatPathForDisplay,
+  getTreeConnector
+} from "./chunk-J2OQQZFA.js";
+import {
+  createCliExecutionContext,
+  resolveOutput,
+  resolvePrompt
+} from "./chunk-GXPSKN7J.js";
+import "./chunk-XEPVYZO3.js";
+import {
+  parsePackageYml,
+  writePackageYml
+} from "./chunk-QTQYI4L5.js";
+import {
+  arePackageNamesEquivalent,
+  normalizePackageName
+} from "./chunk-VN22A7NW.js";
+import {
+  mapWorkspaceFileToUniversal
+} from "./chunk-GKEHDSL4.js";
+import {
+  normalizePathForProcessing
+} from "./chunk-YMKK4XPN.js";
+import {
+  FILE_PATTERNS
+} from "./chunk-J4IFFBLP.js";
+import {
+  ensureDir,
+  exists,
+  isDirectory,
+  isFile,
+  readTextFile,
+  walkFiles,
+  writeTextFile
+} from "./chunk-S47F4OG4.js";
+import {
+  UserCancellationError,
+  ValidationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// src/commands/add.ts
+import { join as join6, relative as relative2 } from "path";
+
+// ../core/src/core/add/add-to-source-pipeline.ts
+import { resolve as resolvePath, join as join2 } from "path";
+
+// ../core/src/core/add/source-collector.ts
+import { relative, basename } from "path";
+import { realpathSync } from "fs";
+async function collectSourceEntries(resolvedPath, cwd) {
+  let entries = [];
+  if (await isDirectory(resolvedPath)) {
+    for await (let filePath of walkFiles(resolvedPath)) {
+      let entry = deriveSourceEntry(filePath, cwd);
+      if (!entry)
+        throw new Error(`Unsupported file inside directory: ${relative(cwd, filePath)}`);
+      entries.push(entry);
+    }
+    return entries;
+  }
+  if (await isFile(resolvedPath)) {
+    let entry = deriveSourceEntry(resolvedPath, cwd);
+    if (!entry)
+      throw new Error(`Unsupported file: ${relative(cwd, resolvedPath)}`);
+    return entries.push(entry), entries;
+  }
+  throw new Error(`Unsupported path type: ${resolvedPath}`);
+}
+function deriveSourceEntry(absFilePath, cwd) {
+  let realFilePath = realpathSync(absFilePath), realCwd = realpathSync(cwd), relativePath = relative(realCwd, realFilePath), normalizedRelPath = normalizePathForProcessing(relativePath), mapping = mapWorkspaceFileToUniversal(absFilePath, cwd);
+  if (mapping) {
+    let registryPath = [mapping.subdir, mapping.relPath].filter(Boolean).join("/");
+    return {
+      sourcePath: absFilePath,
+      registryPath,
+      flow: mapping.flow
+    };
+  }
+  let fileName = basename(normalizedRelPath);
+  return fileName && isPlatformRootFile(fileName) && !normalizedRelPath.includes("/") ? {
+    sourcePath: absFilePath,
+    registryPath: fileName
+  } : {
+    sourcePath: absFilePath,
+    registryPath: `root/${normalizedRelPath}`
+  };
+}
+
+// ../core/src/core/add/add-conflict-handler.ts
+import { basename as basename2, dirname, extname, join, relative as pathRelative } from "path";
+function resolveTargetPath(packageContext, registryPath) {
+  return join(packageContext.packageRootDir, registryPath);
+}
+function transformMarkdownWithFlowMap(raw, entry, workspaceRoot) {
+  let flow = entry.flow;
+  if (!flow?.map || flow.map.length === 0)
+    return { transformed: !1, output: raw };
+  if (![".md", ".mdc"].includes(extname(entry.sourcePath).toLowerCase()))
+    return { transformed: !1, output: raw };
+  let parsed = parseMarkdownDocument(raw, { lenient: !0 });
+  if (!parsed.frontmatter)
+    return { transformed: !1, output: raw };
+  let mapContext = createMapContext({
+    filename: basename2(entry.sourcePath, extname(entry.sourcePath)),
+    dirname: basename2(dirname(entry.sourcePath)),
+    path: pathRelative(workspaceRoot, entry.sourcePath).replace(/\\/g, "/"),
+    ext: extname(entry.sourcePath)
+  }), { schemaOps, pipeOps } = splitMapPipeline(flow.map), nextFrontmatter = parsed.frontmatter;
+  return schemaOps.length > 0 && (nextFrontmatter = applyMapPipeline(nextFrontmatter, schemaOps, mapContext, defaultTransformRegistry)), pipeOps.length > 0 && (nextFrontmatter = applyMapPipeline(nextFrontmatter, pipeOps, mapContext, defaultTransformRegistry)), { transformed: !0, output: serializeMarkdownDocument({ frontmatter: nextFrontmatter, body: parsed.body }) };
+}
+async function copyFilesWithConflictResolution(packageContext, entries, options = {}) {
+  let changedFiles = [], { name } = packageContext, policy = options.execContext?.interactionPolicy, forceOverwrite = options.force ?? !1;
+  for (let entry of entries) {
+    let destination = resolveTargetPath(packageContext, entry.registryPath), sourceContent = await readTextFile(entry.sourcePath), contentToWrite = transformMarkdownWithFlowMap(sourceContent, entry, process.cwd()).output;
+    if (await exists(destination)) {
+      if (await readTextFile(destination).catch(() => "") === contentToWrite) {
+        logger.debug(`Skipping unchanged file: ${entry.registryPath}`);
+        continue;
+      }
+      let decision;
+      if (forceOverwrite)
+        decision = "overwrite";
+      else if (policy?.canPrompt(2 /* Confirmation */)) {
+        let effectivePrompt = options.prompt ?? options.execContext?.prompt;
+        decision = await promptConflictDecision(name, entry.registryPath, effectivePrompt);
+      } else {
+        resolveOutput().warn(`Skipping '${entry.registryPath}' (already exists). Use --force to overwrite.`);
+        continue;
+      }
+      if (decision === "keep-existing") {
+        logger.debug(`Kept existing file for ${entry.registryPath}`);
+        continue;
+      }
+    }
+    await ensureDir(dirname(destination)), await writeTextFile(destination, contentToWrite), changedFiles.push({
+      path: entry.registryPath,
+      content: contentToWrite,
+      encoding: "utf8"
+    });
+  }
+  return changedFiles;
+}
+async function promptConflictDecision(packageName, registryPath, prompt) {
+  let decision = await (prompt ?? resolvePrompt()).select(
+    `File '${registryPath}' already exists in package '${packageName}'. Choose how to proceed:`,
+    [
+      { title: "Keep existing file (skip)", value: "keep-existing" },
+      { title: "Replace with workspace file", value: "overwrite" },
+      { title: "Cancel operation", value: "cancel" }
+    ]
+  );
+  if (decision === "cancel")
+    throw new UserCancellationError();
+  return decision;
+}
+
+// ../core/src/core/add/add-to-source-pipeline.ts
+async function runAddToSourcePipeline(packageName, pathArg, options = {}) {
+  let cwd = process.cwd(), { resolvedPackageName, resolvedPath } = await resolveSourceOperationArguments(
+    cwd,
+    packageName,
+    pathArg,
+    { command: "add", checkWorkspaceRoot: !1 }
+  ), absInputPath = resolvePath(cwd, resolvedPath);
+  if (!await exists(absInputPath))
+    return { success: !1, error: `Path not found: ${resolvedPath}` };
+  let packageContext, sourceType, isWorkspaceRoot = resolvedPackageName === null;
+  if (isWorkspaceRoot)
+    try {
+      packageContext = await buildWorkspacePackageContext(cwd), sourceType = "workspace", logger.info("Adding files to workspace package", {
+        sourcePath: packageContext.packageRootDir,
+        inputPath: resolvedPath
+      });
+    } catch (error) {
+      return {
+        success: !1,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  else {
+    let source;
+    try {
+      source = await resolveMutableSource({ cwd, packageName: resolvedPackageName });
+    } catch (error) {
+      return { success: !1, error: error instanceof Error ? error.message : String(error) };
+    }
+    assertMutableSourceOrThrow(source.absolutePath, { packageName: source.packageName, command: "add" }), packageContext = await buildPackageContextFromSource(source), sourceType = source.absolutePath.includes(`${cwd}/.openpackage/packages/`) ? "workspace" : "global", logger.info("Adding files to package source", {
+      packageName: source.packageName,
+      sourcePath: source.absolutePath,
+      sourceType: source.sourceType,
+      inputPath: resolvedPath
+    });
+  }
+  let entries = await collectSourceEntries(absInputPath, cwd), changed = await copyFilesWithConflictResolution(packageContext, entries, options);
+  logger.info("Files copied to package source", {
+    packageName: packageContext.name,
+    filesAdded: changed.length
+  });
+  let addedFilePaths = changed.map((file) => join2(packageContext.packageRootDir, file.path));
+  return {
+    success: !0,
+    data: {
+      packageName: packageContext.name,
+      filesAdded: changed.length,
+      sourcePath: packageContext.packageRootDir,
+      sourceType,
+      isWorkspaceRoot,
+      addedFilePaths
+    }
+  };
+}
+async function runAddToSourcePipelineBatch(packageName, absPaths, cwd, options = {}) {
+  let packageContext, sourceType, isWorkspaceRoot = !packageName;
+  if (isWorkspaceRoot)
+    try {
+      packageContext = await buildWorkspacePackageContext(cwd), sourceType = "workspace";
+    } catch (error) {
+      return { success: !1, error: error instanceof Error ? error.message : String(error) };
+    }
+  else {
+    let source;
+    try {
+      source = await resolveMutableSource({ cwd, packageName }), assertMutableSourceOrThrow(source.absolutePath, { packageName: source.packageName, command: "add" }), packageContext = await buildPackageContextFromSource(source), sourceType = source.absolutePath.includes(`${cwd}/.openpackage/packages/`) ? "workspace" : "global";
+    } catch (error) {
+      return { success: !1, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  let allEntries = [], seenRegistryPaths = /* @__PURE__ */ new Set();
+  for (let absPath of absPaths) {
+    if (!await exists(absPath))
+      return { success: !1, error: `Path not found: ${absPath}` };
+    try {
+      let entries = await collectSourceEntries(absPath, cwd);
+      for (let entry of entries)
+        seenRegistryPaths.has(entry.registryPath) || (seenRegistryPaths.add(entry.registryPath), allEntries.push(entry));
+    } catch (error) {
+      return { success: !1, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  if (allEntries.length === 0)
+    return { success: !0, data: { packageName: packageContext.name, filesAdded: 0, sourcePath: packageContext.packageRootDir, sourceType, isWorkspaceRoot, addedFilePaths: [] } };
+  let changed = await copyFilesWithConflictResolution(packageContext, allEntries, options), addedFilePaths = changed.map((f) => join2(packageContext.packageRootDir, f.path));
+  return {
+    success: !0,
+    data: {
+      packageName: packageContext.name,
+      filesAdded: changed.length,
+      sourcePath: packageContext.packageRootDir,
+      sourceType,
+      isWorkspaceRoot,
+      addedFilePaths
+    }
+  };
+}
+async function buildPackageContextFromSource(source) {
+  let packageYmlPath = join2(source.absolutePath, FILE_PATTERNS.OPENPACKAGE_YML), config = await parsePackageYml(packageYmlPath);
+  return {
+    name: source.packageName,
+    version: config.version,
+    config,
+    packageYmlPath,
+    packageRootDir: source.absolutePath,
+    packageFilesDir: source.absolutePath
+  };
+}
+
+// ../core/src/core/add/add-orchestrator.ts
+import { join as join5, resolve as resolve2 } from "path";
+
+// ../core/src/core/add/add-input-classifier.ts
+import { join as join3, basename as basename3, resolve } from "path";
+async function classifyAddInput(input, cwd, options) {
+  if (options.copy)
+    return handleCopyMode(input, cwd);
+  if (input.endsWith("/")) {
+    let stripped = input.replace(/\/+$/, ""), resolvedPath = resolve(cwd, stripped);
+    if (await exists(resolvedPath)) {
+      if (await isDirectory(resolvedPath)) {
+        let localPathSpec = await buildLocalPathSpec(resolvedPath);
+        return enrichWithAddMode(localPathSpec);
+      }
+      throw new ValidationError(
+        `Path '${input}' is not a directory. Trailing slash indicates directory intent.`
+      );
+    }
+    throw new ValidationError(`Directory not found: ${input}`);
+  }
+  if (isBareNameWithExtension(input)) {
+    let resolvedPath = resolve(cwd, input);
+    if (await exists(resolvedPath))
+      return { mode: "copy", copySourcePath: resolvedPath };
+    throw new ValidationError(`File not found: ${input}`);
+  }
+  let base = await classifyInputBase(input, cwd);
+  return enrichWithAddMode(base);
+}
+function isBareNameWithExtension(input) {
+  if (input.startsWith("./") || input.startsWith("../") || input.startsWith("/") || input.startsWith("~") || input.includes("@") || input.includes("/") || input.endsWith(".tgz") || input.endsWith(".tar.gz"))
+    return !1;
+  let lastDot = input.lastIndexOf(".");
+  if (lastDot <= 0) return !1;
+  let ext = input.slice(lastDot + 1);
+  return ext.length >= 1 && ext.length <= 8 && /^[a-zA-Z0-9]+$/.test(ext);
+}
+async function buildLocalPathSpec(absolutePath) {
+  let isValid = await isValidPackageDirectory(absolutePath), pluginResult = await detectPluginType(absolutePath), packageName;
+  if (isValid || pluginResult.isPlugin)
+    try {
+      let manifestPath = join3(absolutePath, "openpackage.yml");
+      await exists(manifestPath) && (packageName = (await parsePackageYml(manifestPath)).name ?? basename3(absolutePath));
+    } catch {
+      packageName = basename3(absolutePath);
+    }
+  return {
+    type: "local-path",
+    absolutePath,
+    isDirectory: !0,
+    packageName,
+    isValidPackage: isValid || pluginResult.isPlugin
+  };
+}
+async function handleCopyMode(input, cwd) {
+  let resolvedAbsPath = resolve(cwd, input);
+  if (!await exists(resolvedAbsPath))
+    throw new ValidationError(
+      `Path not found: ${input}
+--copy requires an existing local path.`
+    );
+  return { mode: "copy", copySourcePath: resolvedAbsPath };
+}
+function enrichWithAddMode(base) {
+  switch (base.type) {
+    case "bulk":
+      throw new ValidationError("Add command requires an input argument");
+    case "git":
+      return {
+        mode: "dependency",
+        packageName: base.derivedName,
+        gitUrl: base.gitUrl,
+        gitRef: base.gitRef,
+        gitPath: base.gitPath
+      };
+    case "local-path":
+      return base.absolutePath.endsWith(".tgz") || base.absolutePath.endsWith(".tar.gz") ? {
+        mode: "dependency",
+        packageName: base.packageName ?? basename3(base.absolutePath).replace(/\.(tgz|tar\.gz)$/, ""),
+        localPath: base.absolutePath
+      } : base.isValidPackage ? (logger.debug("Classified local directory as dependency", {
+        packageName: base.packageName,
+        absolutePath: base.absolutePath
+      }), {
+        mode: "dependency",
+        packageName: base.packageName,
+        localPath: base.absolutePath
+      }) : {
+        mode: "copy",
+        copySourcePath: base.absolutePath
+      };
+    case "registry":
+      return {
+        mode: "dependency",
+        packageName: base.packageName,
+        version: base.version,
+        resourcePath: base.registryPath
+      };
+  }
+}
+
+// ../core/src/core/add/add-dependency-flow.ts
+import { join as join4 } from "path";
+async function runAddDependencyFlow(classification, options) {
+  let cwd = process.cwd(), isDev = options.dev ?? !1, section = isDev ? "dev-dependencies" : "dependencies", packageName = classification.packageName, isLocalPath = !!classification.localPath, localPath = classification.localPath ? formatPathForYaml(classification.localPath, cwd) : void 0, gitUrl;
+  classification.gitUrl && (gitUrl = classification.gitRef ? `${classification.gitUrl}#${classification.gitRef}` : classification.gitUrl);
+  let gitPath = classification.gitPath || classification.resourcePath;
+  if (options.to) {
+    let source = await resolveMutableSource({ cwd, packageName: options.to }), manifestPath = join4(source.absolutePath, FILE_PATTERNS.OPENPACKAGE_YML);
+    return await addDependencyToManifest(manifestPath, packageName, {
+      version: classification.version,
+      path: localPath,
+      url: gitUrl,
+      gitPath,
+      isDev
+    }), logger.info(`Added ${packageName} to ${manifestPath} [${section}]`), {
+      packageName,
+      targetManifest: manifestPath,
+      section,
+      isLocalPath,
+      wasAutoDetected: isLocalPath
+    };
+  }
+  let packageYmlPath = getLocalPackageYmlPath(cwd);
+  return await exists(packageYmlPath) || (await ensureLocalOpenPackageStructure(cwd), await createWorkspacePackageYml(cwd)), await addPackageToYml(
+    cwd,
+    packageName,
+    classification.version,
+    isDev,
+    void 0,
+    !0,
+    // silent — CLI layer handles display
+    localPath,
+    classification.gitUrl,
+    classification.gitRef,
+    gitPath,
+    void 0
+  ), logger.info(`Added ${packageName} to workspace manifest [${section}]`), {
+    packageName,
+    targetManifest: packageYmlPath,
+    section,
+    isLocalPath,
+    wasAutoDetected: isLocalPath
+  };
+}
+async function addDependencyToManifest(manifestPath, packageName, options) {
+  let config = await parsePackageYml(manifestPath);
+  config.dependencies || (config.dependencies = []), config["dev-dependencies"] || (config["dev-dependencies"] = []);
+  let normalized = normalizePackageName(packageName), dependency = {
+    name: normalized,
+    ...options.url ? { url: options.url } : {},
+    ...options.path && !options.url ? { path: options.path } : {},
+    ...options.version && !options.url && !options.path ? { version: options.version } : {},
+    ...options.gitPath && options.url ? { path: options.gitPath } : {}
+  }, targetKey = options.isDev ? "dev-dependencies" : "dependencies", otherKey = options.isDev ? "dependencies" : "dev-dependencies", otherArr = config[otherKey], otherIdx = otherArr.findIndex((d) => arePackageNamesEquivalent(d.name, normalized));
+  otherIdx >= 0 && otherArr.splice(otherIdx, 1);
+  let targetArr = config[targetKey], existingIdx = targetArr.findIndex((d) => arePackageNamesEquivalent(d.name, normalized));
+  existingIdx >= 0 ? targetArr[existingIdx] = dependency : targetArr.push(dependency), await writePackageYml(manifestPath, config);
+}
+
+// ../core/src/core/add/add-orchestrator.ts
+function isBareNameInput(input) {
+  return !input.startsWith("./") && !input.startsWith("../") && !input.startsWith("/") && !input.startsWith("~") && !input.endsWith("/");
+}
+async function processAddResource(resourceSpec, options, cwd, execContext) {
+  let classification = await classifyAddInput(resourceSpec, cwd, {
+    copy: options.copy,
+    dev: options.dev
+  });
+  if (classification.mode === "dependency") {
+    if (options.platformSpecific)
+      throw new Error("--platform-specific can only be used with --copy or when adding files");
+    try {
+      return { kind: "dependency", result: await runAddDependencyFlow(classification, {
+        dev: options.dev,
+        to: options.to
+      }), classification };
+    } catch (error) {
+      let msg = error instanceof Error ? error.message : String(error);
+      if (isBareNameInput(resourceSpec)) {
+        let localPath = resolve2(cwd, resourceSpec);
+        if (await exists(localPath))
+          throw new Error(
+            `${msg}
+
+A local path './${resourceSpec}' exists \u2014 did you mean:
+  opkg add ./${resourceSpec}`
+          );
+      }
+      throw error;
+    }
+  }
+  if (classification.mode === "workspace-resource") {
+    if (options.dev)
+      throw new Error("--dev can only be used when adding a dependency, not when copying files");
+    let resource = classification.resolvedResource, absPath = resource.sourcePath || join5(execContext.targetDir, resource.targetFiles[0]), result2 = await runAddToSourcePipeline(options.to, absPath, { ...options, execContext });
+    if (!result2.success)
+      throw new Error(result2.error || "Add operation failed");
+    return { kind: "workspace-resource", result: result2 };
+  }
+  if (options.dev)
+    throw new Error("--dev can only be used when adding a dependency, not when copying files");
+  let result = await runAddToSourcePipeline(options.to, classification.copySourcePath, { ...options, execContext });
+  if (!result.success)
+    throw new Error(result.error || "Add operation failed");
+  return { kind: "copy", result };
+}
+
+// src/commands/add.ts
+function displayAddResults(data, out, interactive, skipHeader = !1) {
+  let { filesAdded, packageName: resolvedName, addedFilePaths, isWorkspaceRoot, sourcePath } = data, target = isWorkspaceRoot ? "workspace package" : resolvedName;
+  if (interactive && !skipHeader) {
+    let pkgLabel = isWorkspaceRoot ? "workspace package" : resolvedName, displayPath = formatPathForDisplay(sourcePath, process.cwd());
+    out.info(`To: ${pkgLabel} (${displayPath})`);
+  }
+  if (filesAdded > 0) {
+    let count = filesAdded === 1 ? "1 file" : `${filesAdded} files`;
+    if (interactive)
+      out.success(`Added ${count} to ${target}`);
+    else {
+      let displayPath = formatPathForDisplay(sourcePath, process.cwd());
+      out.success(`Added ${count} to ${target} (${displayPath})`);
+    }
+    let relPaths = [...addedFilePaths || []].sort((a, b) => a.localeCompare(b)).map((f) => relative2(sourcePath, f).replace(/\\/g, "/"));
+    if (interactive) {
+      let displayPaths = relPaths.slice(0, 10), more = relPaths.length > 10 ? `
+... and ${relPaths.length - 10} more` : "";
+      out.note(displayPaths.join(`
+`) + more, "Added files");
+    } else
+      for (let i = 0; i < relPaths.length; i++) {
+        let connector = getTreeConnector(i === relPaths.length - 1);
+        out.message(`  ${connector}${relPaths[i]}`);
+      }
+  } else
+    out.success(`No new files added to ${target}`);
+}
+function displayDependencyResult(depResult, out, interactive) {
+  let { result: dep, classification } = depResult, displayPath = formatPathForDisplay(dep.targetManifest, process.cwd());
+  if (interactive) {
+    let header = `To: ${dep.packageName} (${displayPath})`;
+    out.info(header), dep.wasAutoDetected && (out.info(`Detected package at ${classification.localPath} \u2014 adding as dependency.`), out.message("To copy files instead, use --copy."));
+    let versionSuffix = classification.version ? `@${classification.version}` : "";
+    out.success(`Added ${dep.packageName}${versionSuffix} to ${dep.section}`);
+  } else {
+    out.success(`Added to ${dep.section} (${displayPath})`);
+    let versionSuffix = classification.version ? `@${classification.version}` : "", connector = getTreeConnector(!0);
+    out.message(`  ${connector}${dep.packageName}${versionSuffix}`), dep.wasAutoDetected && out.message("  Detected local package \u2014 use --copy to copy files instead.");
+  }
+}
+function displayResult(result, out, interactive, resourceSpec) {
+  switch (result.kind) {
+    case "dependency":
+      displayDependencyResult(result, out, interactive);
+      break;
+    case "workspace-resource":
+      result.result.data && (out.info(`Resolved "${resourceSpec}" from installed workspace resources.`), displayAddResults(result.result.data, out, interactive));
+      break;
+    case "copy":
+      result.result.data && displayAddResults(result.result.data, out, interactive);
+      break;
+  }
+}
+async function setupAddCommand(args) {
+  let [resource, options, command] = args, cwd = process.cwd(), programOpts = command.parent?.opts() || {}, interactive = !resource, execContext = await createCliExecutionContext({
+    global: !1,
+    cwd: programOpts.cwd,
+    interactive
+  }), policy = createInteractionPolicy({ interactive, force: options.force });
+  execContext.interactionPolicy = policy;
+  let out = resolveOutput(execContext);
+  if (!resource) {
+    if (!policy.canPrompt(4 /* OptionalMenu */))
+      throw new Error(
+        `<resource-spec> argument is required in non-interactive mode.
+Usage: opkg add <resource-spec> [options]`
+      );
+    let pkgLabel, sourcePath;
+    if (options.to) {
+      let source = await resolveMutableSource({ cwd, packageName: options.to });
+      pkgLabel = source.packageName, sourcePath = source.absolutePath;
+    } else {
+      let context = await buildWorkspacePackageContext(cwd);
+      pkgLabel = "workspace package", sourcePath = context.packageRootDir;
+    }
+    out.step(`To: ${pkgLabel} (${formatPathForDisplay(sourcePath, cwd)})`), out.connector();
+    let selectedFiles = await interactiveFileSelect({ cwd, includeDirs: !0 });
+    if (!selectedFiles || selectedFiles.length === 0) return;
+    let filesToProcess;
+    hasDirectorySelections(selectedFiles) ? (filesToProcess = await expandDirectorySelections(selectedFiles, cwd), out.info(`Found ${filesToProcess.length} total file${filesToProcess.length === 1 ? "" : "s"} to add`)) : filesToProcess = selectedFiles;
+    let absPaths = filesToProcess.map((f) => join6(cwd, f)), result2 = await runAddToSourcePipelineBatch(options.to, absPaths, cwd, { ...options, execContext });
+    if (!result2.success) throw new Error(result2.error || "Add operation failed");
+    result2.data && displayAddResults(result2.data, out, interactive, !0);
+    return;
+  }
+  let result = await processAddResource(resource, options, cwd, execContext);
+  displayResult(result, out, interactive, resource);
+}
+export {
+  setupAddCommand
+};
+//# sourceMappingURL=add-AFORN4DK.js.map