opkg 0.9.2 → 0.9.4

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

@@ -0,0 +1,631 @@
+#!/usr/bin/env node
+import {
+  UserCancellationError
+} from "./chunk-ID4SVDQZ.js";
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/ports/console-output.ts
+var consoleOutput = {
+  info(message) {
+    console.log(message);
+  },
+  step(message) {
+    console.log(message);
+  },
+  connector() {
+  },
+  message(message) {
+    console.log(message);
+  },
+  success(message) {
+    console.log(`\u2713 ${message}`);
+  },
+  error(message) {
+    console.log(`\u2717 ${message}`);
+  },
+  warn(message) {
+    console.log(`\u26A0 ${message}`);
+  },
+  note(content, title) {
+    let indented = content.split(`
+`).map((line) => `  ${line}`).join(`
+`);
+    console.log(title ? `
+${title}
+${indented}` : `
+${indented}`);
+  },
+  async confirm(_message, options) {
+    return options?.initial ?? !1;
+  },
+  spinner() {
+    let msg = "";
+    return {
+      start(message) {
+        msg = message, console.log(`\u2026 ${message}`);
+      },
+      stop(finalMessage) {
+        console.log(finalMessage ? `\u2713 ${finalMessage}` : `\u2713 ${msg}`);
+      },
+      message(text2) {
+        msg = text2;
+      }
+    };
+  }
+};
+
+// ../core/src/core/ports/console-prompt.ts
+var NonInteractivePromptError = class extends Error {
+  constructor(promptType) {
+    super(
+      `Cannot prompt for ${promptType} in non-interactive mode. Use specific flags or options to provide the required input.`
+    ), this.name = "NonInteractivePromptError";
+  }
+}, nonInteractivePrompt = {
+  async confirm(_message, _initial) {
+    throw new NonInteractivePromptError("confirmation");
+  },
+  async select(_message, _choices, _hint) {
+    throw new NonInteractivePromptError("selection");
+  },
+  async multiselect(_message, _choices) {
+    throw new NonInteractivePromptError("multi-selection");
+  },
+  async groupMultiselect(_message, _groups) {
+    throw new NonInteractivePromptError("group selection");
+  },
+  async text(_message, _options) {
+    throw new NonInteractivePromptError("text input");
+  }
+};
+
+// ../core/src/core/ports/resolve.ts
+function resolveOutput(ctx) {
+  return ctx?.output ?? consoleOutput;
+}
+function resolvePrompt(ctx) {
+  return ctx?.prompt ?? nonInteractivePrompt;
+}
+
+// ../core/src/core/execution-context.ts
+import { resolve as resolve2 } from "path";
+import { stat, access, constants as fsConstants } from "fs/promises";
+
+// ../core/src/utils/home-directory.ts
+import { homedir } from "os";
+import { resolve, normalize } from "path";
+function getHomeDirectory() {
+  return homedir();
+}
+function isHomeDirectory(path) {
+  let normalizedPath = normalize(resolve(path)), normalizedHome = normalize(getHomeDirectory());
+  return normalizedPath === normalizedHome;
+}
+function normalizePathWithTilde(path) {
+  let normalizedPath = normalize(resolve(path)), homeDir = getHomeDirectory(), normalizedHome = normalize(homeDir);
+  return normalizedPath === normalizedHome ? "~/" : normalizedPath.startsWith(normalizedHome + "/") ? "~/" + normalizedPath.slice(normalizedHome.length + 1) : normalizedPath;
+}
+
+// ../core/src/core/execution-context.ts
+async function createExecutionContext(options = {}) {
+  let sourceCwd = process.cwd(), targetDir, isGlobal;
+  options.global ? (targetDir = getHomeDirectory(), isGlobal = !0, options.cwd && logger.info("--global option present, ignoring --cwd", {
+    cwd: options.cwd,
+    targetDir
+  })) : options.cwd ? (targetDir = resolve2(sourceCwd, options.cwd), isGlobal = isHomeDirectory(targetDir)) : (targetDir = sourceCwd, isGlobal = isHomeDirectory(targetDir));
+  let context = {
+    sourceCwd,
+    targetDir,
+    isGlobal,
+    interactive: options.interactive
+  };
+  return await validateExecutionContext(context), logger.debug("Created execution context", {
+    sourceCwd: context.sourceCwd,
+    targetDir: context.targetDir,
+    isGlobal: context.isGlobal
+  }), context;
+}
+async function validateExecutionContext(context) {
+  try {
+    if (!(await stat(context.targetDir)).isDirectory())
+      throw new Error(`Target path is not a directory: ${context.targetDir}`);
+    await access(context.targetDir, fsConstants.W_OK);
+  } catch (error) {
+    throw error.code === "ENOENT" ? new Error(
+      `Target directory does not exist: ${context.targetDir}
+
+Hint: Create the directory or specify a different target with --cwd`
+    ) : error.code === "EACCES" ? new Error(
+      `Target directory is not writable: ${context.targetDir}
+
+Hint: Check directory permissions`
+    ) : new Error(
+      `Invalid target directory: ${context.targetDir}
+Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    if (!(await stat(context.sourceCwd)).isDirectory())
+      throw new Error(`Source working directory is not a directory: ${context.sourceCwd}`);
+    await access(context.sourceCwd, fsConstants.R_OK);
+  } catch (error) {
+    throw new Error(
+      `Invalid source working directory: ${context.sourceCwd}
+Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function getDisplayTargetDir(context) {
+  return normalizePathWithTilde(context.targetDir);
+}
+
+// src/cli/clack-output-adapter.ts
+import { log, spinner as clackSpinner, confirm as clackConfirm, note as clackNote, isCancel, cancel } from "@clack/prompts";
+
+// src/utils/spinner.ts
+var Spinner = class {
+  constructor(message = "Loading...") {
+    this.intervalId = null;
+    this.currentFrame = 0;
+    this.isRunning = !1;
+    this.message = message, this.frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  }
+  /**
+   * Start the spinner animation
+   */
+  start() {
+    this.isRunning || (this.isRunning = !0, this.currentFrame = 0, process.stdout.write("\x1B[?25l"), this.intervalId = setInterval(() => {
+      let frame = this.frames[this.currentFrame % this.frames.length];
+      process.stdout.write(`\r${frame} ${this.message}`), this.currentFrame++;
+    }, 80));
+  }
+  /**
+   * Update the spinner message
+   */
+  update(message) {
+    this.message = message;
+  }
+  /**
+   * Stop the spinner
+   */
+  stop() {
+    this.isRunning && (this.isRunning = !1, this.intervalId && (clearInterval(this.intervalId), this.intervalId = null), process.stdout.write("\r" + " ".repeat(process.stdout.columns || 80) + "\r"), process.stdout.write("\x1B[?25h"));
+  }
+};
+
+// src/cli/clack-output-adapter.ts
+function createClackOutput() {
+  return {
+    info(message) {
+      log.info(message);
+    },
+    step(message) {
+      log.step(message);
+    },
+    connector() {
+      log.message(" ", { spacing: 0 });
+    },
+    message(message) {
+      log.message(message, { spacing: 0 });
+    },
+    success(message) {
+      log.success(message);
+    },
+    error(message) {
+      log.error(message);
+    },
+    warn(message) {
+      log.warn(message);
+    },
+    note(content, title) {
+      clackNote(content, title ?? "");
+    },
+    async confirm(message, options) {
+      let result = await clackConfirm({
+        message,
+        initialValue: options?.initial ?? !1
+      });
+      if (isCancel(result)) {
+        cancel("Operation cancelled.");
+        let { UserCancellationError: UserCancellationError2 } = await import("./errors-X5KO3GTP.js");
+        throw new UserCancellationError2("Operation cancelled by user");
+      }
+      return result;
+    },
+    spinner() {
+      let s = clackSpinner(), isStarted = !1;
+      return {
+        start(message) {
+          isStarted || (s.start(message), isStarted = !0);
+        },
+        stop(finalMessage) {
+          isStarted && (finalMessage ? s.stop(finalMessage) : s.stop(), isStarted = !1);
+        },
+        message(text2) {
+          isStarted && s.message(text2);
+        }
+      };
+    }
+  };
+}
+function createPlainOutput() {
+  return {
+    info(message) {
+      console.log(message);
+    },
+    step(message) {
+      console.log(message);
+    },
+    connector() {
+    },
+    message(message) {
+      console.log(message);
+    },
+    success(message) {
+      console.log(`\u2713 ${message}`);
+    },
+    error(message) {
+      console.log(`\u274C ${message}`);
+    },
+    warn(message) {
+      console.log(`\u26A0\uFE0F  ${message}`);
+    },
+    note(content, title) {
+      let indented = content.split(`
+`).map((line) => `  ${line}`).join(`
+`);
+      console.log(title ? `
+${title}
+${indented}` : `
+${indented}`);
+    },
+    async confirm(_message, options) {
+      return console.log(`${_message} ${options?.initial ? "(Y)" : "(N)"}`), options?.initial ?? !1;
+    },
+    spinner() {
+      let s = null;
+      return {
+        start(message) {
+          s = new Spinner(message), s.start();
+        },
+        stop(finalMessage) {
+          s && (s.stop(), finalMessage && console.log(`\u2713 ${finalMessage}`), s = null);
+        },
+        message(text2) {
+          s && s.update(text2);
+        }
+      };
+    }
+  };
+}
+
+// src/cli/clack-prompt-adapter.ts
+import * as clack from "@clack/prompts";
+function handleCancel(result) {
+  if (clack.isCancel(result))
+    throw clack.cancel("Operation cancelled."), new UserCancellationError("Operation cancelled by user");
+}
+function createClackPrompt() {
+  return {
+    async confirm(message, initial) {
+      let result = await clack.confirm({
+        message,
+        initialValue: initial ?? !1
+      });
+      return handleCancel(result), result;
+    },
+    async select(message, choices, hint) {
+      let result = await clack.select({
+        message,
+        options: choices.map((c) => ({
+          label: c.title,
+          value: c.value,
+          ...c.description ? { hint: c.description } : {}
+        }))
+      });
+      return handleCancel(result), result;
+    },
+    async multiselect(message, choices, options) {
+      let result = await clack.multiselect({
+        message,
+        options: choices.map((c) => ({
+          label: c.title,
+          value: c.value,
+          ...c.description ? { hint: c.description } : {}
+        })),
+        required: options?.min ? options.min > 0 : !1
+      });
+      return handleCancel(result), result;
+    },
+    async groupMultiselect(message, groups) {
+      let result = await clack.groupMultiselect({
+        message,
+        options: groups
+      });
+      return handleCancel(result), result;
+    },
+    async text(message, options) {
+      let userValidate = options?.validate, isAsync = !1, syncValidate = userValidate ? (value) => {
+        let r = userValidate(value ?? "");
+        if (r && typeof r.then == "function") {
+          isAsync = !0;
+          return;
+        }
+        if (!(r === !0 || r === void 0))
+          return r;
+      } : void 0;
+      for (; ; ) {
+        let result = await clack.text({
+          message,
+          placeholder: options?.placeholder,
+          defaultValue: options?.initial,
+          validate: syncValidate
+        });
+        if (handleCancel(result), isAsync && userValidate) {
+          let asyncResult = await userValidate(result ?? "");
+          if (asyncResult !== !0 && asyncResult !== void 0) {
+            clack.log.error(asyncResult), isAsync = !1;
+            continue;
+          }
+        }
+        return result;
+      }
+    }
+  };
+}
+
+// src/cli/plain-prompt-adapter.ts
+import prompts from "prompts";
+function onCancel() {
+  throw new UserCancellationError("Prompt cancelled");
+}
+function createPlainPrompt() {
+  return {
+    // ── confirm ──────────────────────────────────────────────────────
+    async confirm(message, initial) {
+      let { value } = await prompts(
+        {
+          type: "confirm",
+          name: "value",
+          message,
+          initial: initial ?? !1
+        },
+        { onCancel }
+      );
+      return value;
+    },
+    // ── select ───────────────────────────────────────────────────────
+    async select(message, choices, hint) {
+      let { value } = await prompts(
+        {
+          type: "select",
+          name: "value",
+          message,
+          choices: choices.map((c) => ({
+            title: c.title,
+            value: c.value,
+            description: c.description
+          })),
+          hint
+        },
+        { onCancel }
+      );
+      return value;
+    },
+    // ── multiselect ──────────────────────────────────────────────────
+    async multiselect(message, choices, options) {
+      let { value } = await prompts(
+        {
+          type: "multiselect",
+          name: "value",
+          message,
+          choices: choices.map((c) => ({
+            title: c.title,
+            value: c.value,
+            description: c.description
+          })),
+          hint: options?.hint ?? "- Space: select/deselect, Enter: confirm",
+          min: options?.min
+        },
+        { onCancel }
+      );
+      return value;
+    },
+    // ── groupMultiselect ─────────────────────────────────────────────
+    async groupMultiselect(message, groups) {
+      let flatChoices = [];
+      for (let [groupLabel, items] of Object.entries(groups))
+        for (let item of items)
+          flatChoices.push({
+            title: `${groupLabel} / ${item.label}`,
+            value: item.value
+          });
+      let { value } = await prompts(
+        {
+          type: "multiselect",
+          name: "value",
+          message,
+          choices: flatChoices.map((c) => ({
+            title: c.title,
+            value: c.value
+          })),
+          hint: "- Space: select/deselect, Enter: confirm"
+        },
+        { onCancel }
+      );
+      return value;
+    },
+    // ── text ─────────────────────────────────────────────────────────
+    async text(message, options) {
+      let userValidate = options?.validate, isAsync = !1, syncValidate = userValidate ? (value) => {
+        let r = userValidate(value);
+        return r && typeof r.then == "function" ? (isAsync = !0, !0) : r === !0 || r === void 0 ? !0 : r;
+      } : void 0;
+      for (; ; ) {
+        let { value } = await prompts(
+          {
+            type: "text",
+            name: "value",
+            message,
+            initial: options?.initial,
+            validate: syncValidate
+          },
+          { onCancel }
+        ), result = value ?? "";
+        if (isAsync && userValidate) {
+          let asyncResult = await userValidate(result);
+          if (asyncResult !== !0 && asyncResult !== void 0) {
+            console.error(`  Error: ${asyncResult}`), isAsync = !1;
+            continue;
+          }
+        }
+        return result;
+      }
+    }
+  };
+}
+
+// src/cli/clack-progress-adapter.ts
+import { log as log3 } from "@clack/prompts";
+function createClackProgress() {
+  return {
+    emit(event) {
+      switch (event.type) {
+        case "install:start":
+          log3.step(`Installing ${event.packages.length} package(s)`);
+          break;
+        case "install:resolve":
+          event.status === "failed" && log3.warn(`Failed to resolve ${event.package}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "install:download":
+          event.status === "failed" && log3.warn(`Failed to download ${event.package}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "install:extract":
+          event.status === "failed" && log3.warn(`Failed to extract ${event.package}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "install:complete": {
+          let { installed, failed, skipped } = event.summary;
+          failed > 0 ? log3.warn(`Install complete: ${installed} installed, ${failed} failed, ${skipped} skipped`) : log3.info(`Install complete: ${installed} installed${skipped > 0 ? `, ${skipped} skipped` : ""}`);
+          break;
+        }
+        case "publish:start":
+          log3.step(`Publishing ${event.package}@${event.version}`);
+          break;
+        case "publish:upload":
+          event.status === "failed" && log3.warn(`Upload failed for ${event.package}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "publish:complete":
+          event.success ? log3.info(`Published ${event.package}`) : log3.warn(`Failed to publish ${event.package}`);
+          break;
+        case "uninstall:start":
+          log3.step(`Uninstalling ${event.packages.length} package(s)`);
+          break;
+        case "uninstall:remove":
+          event.status === "failed" && log3.warn(`Failed to remove ${event.package}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "uninstall:complete": {
+          let { removed, failed } = event.summary;
+          failed > 0 ? log3.warn(`Uninstall complete: ${removed} removed, ${failed} failed`) : log3.info(`Uninstall complete: ${removed} removed`);
+          break;
+        }
+        case "search:start":
+          break;
+        case "search:scanning":
+          break;
+        case "search:complete":
+          log3.info(`Found ${event.resultCount} result(s)`);
+          break;
+        case "pipeline:start":
+          log3.step(`${event.pipeline}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "pipeline:step":
+          log3.info(`${event.step}${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        case "pipeline:complete":
+          event.success || log3.warn(`${event.pipeline} failed${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+      }
+    },
+    log(level, message) {
+      switch (level) {
+        case "debug":
+          break;
+        case "info":
+          log3.info(message);
+          break;
+        case "warn":
+          log3.warn(message);
+          break;
+        case "error":
+          log3.error(message);
+          break;
+      }
+    }
+  };
+}
+function createPlainProgress() {
+  return {
+    emit(event) {
+      switch (event.type) {
+        case "install:complete":
+          console.log(`Installed: ${event.summary.installed}, failed: ${event.summary.failed}, skipped: ${event.summary.skipped}`);
+          break;
+        case "publish:complete":
+          console.log(`Publish ${event.package}: ${event.success ? "success" : "failed"}`);
+          break;
+        case "uninstall:complete":
+          console.log(`Removed: ${event.summary.removed}, failed: ${event.summary.failed}`);
+          break;
+        case "search:complete":
+          console.log(`Found ${event.resultCount} result(s)`);
+          break;
+        case "pipeline:complete":
+          event.success || console.log(`${event.pipeline} failed${event.detail ? `: ${event.detail}` : ""}`);
+          break;
+        default:
+          break;
+      }
+    },
+    log(level, message) {
+      switch (level) {
+        case "debug":
+        case "info":
+          break;
+        case "warn":
+          console.warn(message);
+          break;
+        case "error":
+          console.error(message);
+          break;
+      }
+    }
+  };
+}
+
+// src/cli/context.ts
+var cachedClackOutput, cachedPlainOutput, cachedClackPrompt, cachedPlainPrompt, cachedClackProgress, cachedPlainProgress;
+function detectInteractive() {
+  return process.stdin.isTTY === !0 && process.env.CI !== "true";
+}
+function applyOutputMode(ctx, mode, isTTY) {
+  ctx.outputMode = mode, mode === "rich" ? (ctx.output = cachedClackOutput ?? (cachedClackOutput = createClackOutput()), ctx.prompt = isTTY ? cachedClackPrompt ?? (cachedClackPrompt = createClackPrompt()) : nonInteractivePrompt, ctx.progress = cachedClackProgress ?? (cachedClackProgress = createClackProgress())) : (ctx.output = cachedPlainOutput ?? (cachedPlainOutput = createPlainOutput()), ctx.prompt = isTTY ? cachedPlainPrompt ?? (cachedPlainPrompt = createPlainPrompt()) : nonInteractivePrompt, ctx.progress = cachedPlainProgress ?? (cachedPlainProgress = createPlainProgress()));
+}
+async function createCliExecutionContext(options = {}) {
+  let ctx = await createExecutionContext(options), isTTY = detectInteractive(), initialMode = options.outputMode ?? "plain";
+  return applyOutputMode(ctx, initialMode, isTTY), ctx.commitOutputMode = (mode) => {
+    ctx.outputMode !== mode && applyOutputMode(ctx, mode, isTTY);
+  }, ctx;
+}
+
+export {
+  normalizePathWithTilde,
+  consoleOutput,
+  resolveOutput,
+  resolvePrompt,
+  createExecutionContext,
+  getDisplayTargetDir,
+  createCliExecutionContext
+};
+//# sourceMappingURL=chunk-RAKMX654.js.map