@jskit-ai/jskit-cli 0.2.4

package/src/server/optionInterpolation.js

@@ -0,0 +1,408 @@
+import process from "node:process";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { createCliError } from "./cliError.js";
+import { ensureArray } from "./collectionUtils.js";
+
+const OPTION_INTERPOLATION_PATTERN = /\$\{option:([a-z][a-z0-9-]*)(\|[^}]*)?\}/gi;
+
+function normalizeSnippet(value) {
+  return String(value || "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .trimEnd();
+}
+
+function appendTextSnippet(content, snippet, position = "bottom") {
+  const normalizedContent = String(content || "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n");
+  const normalizedSnippet = normalizeSnippet(snippet);
+
+  if (!normalizedSnippet) {
+    return {
+      changed: false,
+      content: normalizedContent
+    };
+  }
+
+  if (normalizedContent.includes(normalizedSnippet)) {
+    return {
+      changed: false,
+      content: normalizedContent
+    };
+  }
+
+  if (!normalizedContent) {
+    return {
+      changed: true,
+      content: `${normalizedSnippet}\n`
+    };
+  }
+
+  if (position === "top") {
+    const nextContent = `${normalizedSnippet}\n\n${normalizedContent.replace(/^\n+/, "")}`.replace(/\n+$/, "\n");
+    return {
+      changed: true,
+      content: nextContent
+    };
+  }
+
+  const nextContent = `${normalizedContent.replace(/\n*$/, "\n\n")}${normalizedSnippet}\n`;
+  return {
+    changed: true,
+    content: nextContent
+  };
+}
+
+function normalizeSkipChecks(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+
+  if (value == null) {
+    return [];
+  }
+
+  const one = String(value || "").trim();
+  return one ? [one] : [];
+}
+
+function splitTextIntoWords(value) {
+  const normalized = String(value || "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[^A-Za-z0-9]+/g, " ")
+    .trim();
+  if (!normalized) {
+    return [];
+  }
+  return normalized
+    .split(/\s+/)
+    .map((entry) => entry.toLowerCase())
+    .filter(Boolean);
+}
+
+function wordsToPascal(words) {
+  return ensureArray(words)
+    .map((entry) => {
+      const value = String(entry || "").toLowerCase();
+      if (!value) {
+        return "";
+      }
+      return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+    })
+    .join("");
+}
+
+function wordsToCamel(words) {
+  const pascal = wordsToPascal(words);
+  if (!pascal) {
+    return "";
+  }
+  return `${pascal.slice(0, 1).toLowerCase()}${pascal.slice(1)}`;
+}
+
+function wordsToSnake(words) {
+  return ensureArray(words)
+    .map((entry) => String(entry || "").toLowerCase())
+    .filter(Boolean)
+    .join("_");
+}
+
+function wordsToKebab(words) {
+  return ensureArray(words)
+    .map((entry) => String(entry || "").toLowerCase())
+    .filter(Boolean)
+    .join("-");
+}
+
+function toSingularForm(value) {
+  const words = splitTextIntoWords(value);
+  if (words.length < 1) {
+    return "";
+  }
+
+  const lastIndex = words.length - 1;
+  const last = words[lastIndex];
+  if (!last) {
+    return wordsToKebab(words);
+  }
+
+  if (last.endsWith("ies") && last.length > 3) {
+    words[lastIndex] = `${last.slice(0, -3)}y`;
+    return wordsToKebab(words);
+  }
+  if (last.endsWith("sses") && last.length > 4) {
+    words[lastIndex] = last.slice(0, -2);
+    return wordsToKebab(words);
+  }
+  if (last.endsWith("s") && !last.endsWith("ss") && last.length > 1) {
+    words[lastIndex] = last.slice(0, -1);
+    return wordsToKebab(words);
+  }
+
+  return wordsToKebab(words);
+}
+
+function toPluralForm(value) {
+  const words = splitTextIntoWords(value);
+  if (words.length < 1) {
+    return "";
+  }
+
+  const lastIndex = words.length - 1;
+  const last = words[lastIndex];
+  if (!last) {
+    return wordsToKebab(words);
+  }
+
+  if (last.endsWith("s")) {
+    return wordsToKebab(words);
+  }
+  if (/(x|z|ch|sh)$/i.test(last)) {
+    words[lastIndex] = `${last}es`;
+    return wordsToKebab(words);
+  }
+  if (last.endsWith("y") && !/[aeiou]y$/i.test(last)) {
+    words[lastIndex] = `${last.slice(0, -1)}ies`;
+    return wordsToKebab(words);
+  }
+
+  words[lastIndex] = `${last}s`;
+  return wordsToKebab(words);
+}
+
+function normalizePathValue(value) {
+  return String(value || "")
+    .split("/")
+    .map((segment) => wordsToKebab(splitTextIntoWords(segment)))
+    .filter(Boolean)
+    .join("/");
+}
+
+function parseTransformSpec(transform) {
+  const normalized = String(transform || "").trim();
+  if (!normalized) {
+    return {
+      name: "",
+      args: []
+    };
+  }
+
+  const match = /^([a-z][a-z0-9-]*)(?:\((.*)\))?$/i.exec(normalized);
+  if (!match) {
+    return {
+      name: "",
+      args: []
+    };
+  }
+
+  const name = String(match[1] || "").trim().toLowerCase();
+  const rawArgs = String(match[2] || "").trim();
+  const args = rawArgs
+    ? rawArgs.split(",").map((entry) => String(entry || "").trim())
+    : [];
+
+  return {
+    name,
+    args
+  };
+}
+
+function applyOptionTransform(value, transform, ownerId, key, optionName) {
+  const spec = parseTransformSpec(transform);
+  const name = spec.name;
+  if (!name) {
+    return value;
+  }
+
+  if (name === "trim") {
+    return String(value || "").trim();
+  }
+  if (name === "lower") {
+    return String(value || "").toLowerCase();
+  }
+  if (name === "upper") {
+    return String(value || "").toUpperCase();
+  }
+  if (name === "kebab") {
+    return wordsToKebab(splitTextIntoWords(value));
+  }
+  if (name === "snake") {
+    return wordsToSnake(splitTextIntoWords(value));
+  }
+  if (name === "pascal") {
+    return wordsToPascal(splitTextIntoWords(value));
+  }
+  if (name === "camel") {
+    return wordsToCamel(splitTextIntoWords(value));
+  }
+  if (name === "singular") {
+    return toSingularForm(value);
+  }
+  if (name === "plural") {
+    return toPluralForm(value);
+  }
+  if (name === "path") {
+    return normalizePathValue(value);
+  }
+  if (name === "pathprefix") {
+    const normalizedPath = normalizePathValue(value);
+    return normalizedPath ? `${normalizedPath}/` : "";
+  }
+  if (name === "default") {
+    const fallback = String(spec.args[0] || "");
+    const normalized = String(value || "").trim();
+    return normalized ? value : fallback;
+  }
+  if (name === "prefix") {
+    const prefix = String(spec.args[0] || "");
+    return `${prefix}${String(value || "")}`;
+  }
+  if (name === "suffix") {
+    const suffix = String(spec.args[0] || "");
+    return `${String(value || "")}${suffix}`;
+  }
+
+  throw createCliError(
+    `Unknown option transform "${name}" while applying ${ownerId} mutation ${key} (option: ${optionName}).`
+  );
+}
+
+function applyOptionTransformPipeline(rawValue, rawPipeline, ownerId, key, optionName) {
+  let value = String(rawValue || "");
+  const pipeline = String(rawPipeline || "")
+    .split("|")
+    .map((entry) => String(entry || "").trim())
+    .filter(Boolean);
+
+  for (const transform of pipeline) {
+    value = applyOptionTransform(value, transform, ownerId, key, optionName);
+  }
+
+  return value;
+}
+
+function interpolateOptionValue(rawValue, options, ownerId, key) {
+  return String(rawValue || "").replace(OPTION_INTERPOLATION_PATTERN, (_, optionName, rawPipeline = "") => {
+    if (Object.prototype.hasOwnProperty.call(options, optionName)) {
+      return applyOptionTransformPipeline(String(options[optionName]), rawPipeline, ownerId, key, optionName);
+    }
+    throw createCliError(
+      `Missing required option ${optionName} while applying ${ownerId} mutation ${key}.`
+    );
+  });
+}
+
+function escapeRegExp(value) {
+  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function isSecretOptionInput(optionSchema) {
+  const inputType = String(optionSchema?.inputType || "").trim().toLowerCase();
+  if (inputType === "password" || inputType === "secret" || inputType === "hidden") {
+    return true;
+  }
+  return optionSchema?.sensitive === true || optionSchema?.secret === true;
+}
+
+function createMutedReadlineOutput(stdout) {
+  let muted = false;
+  const output = new Writable({
+    write(chunk, encoding, callback) {
+      if (!muted) {
+        stdout.write(chunk, encoding);
+      }
+      callback();
+    }
+  });
+
+  return {
+    output,
+    setMuted(nextMuted) {
+      muted = Boolean(nextMuted);
+    }
+  };
+}
+
+async function promptForRequiredOption({
+  ownerType,
+  ownerId,
+  optionName,
+  optionSchema,
+  stdin = process.stdin,
+  stdout = process.stdout
+}) {
+  const defaultValue = String(optionSchema?.defaultValue || "").trim();
+  const promptLabel = String(optionSchema?.promptLabel || "").trim();
+  const promptHint = String(optionSchema?.promptHint || "").trim();
+  const required = Boolean(optionSchema?.required);
+  const allowEmpty = optionSchema?.allowEmpty === true;
+
+  if (!stdin?.isTTY || !stdout?.isTTY) {
+    if (defaultValue) {
+      return defaultValue;
+    }
+    if (required) {
+      if (allowEmpty) {
+        return "";
+      }
+      throw createCliError(
+        `${ownerType} ${ownerId} requires option ${optionName}. Non-interactive mode requires --${optionName} <value>.`
+      );
+    }
+    return "";
+  }
+
+  const label = promptLabel || `Select ${optionName} for ${ownerType} ${ownerId}`;
+  const defaultHint = defaultValue ? ` [default: ${defaultValue}]` : "";
+  const hintSuffix = promptHint ? ` ${promptHint}` : "";
+  const promptText = `${label}${defaultHint}${hintSuffix}: `;
+
+  let answer = "";
+
+  if (isSecretOptionInput(optionSchema)) {
+    const outputController = createMutedReadlineOutput(stdout);
+    const rl = createInterface({
+      input: stdin,
+      output: outputController.output
+    });
+
+    try {
+      stdout.write(promptText);
+      outputController.setMuted(true);
+      answer = String(await rl.question("")).trim();
+    } finally {
+      outputController.setMuted(false);
+      stdout.write("\n");
+      rl.close();
+    }
+  } else {
+    const rl = createInterface({
+      input: stdin,
+      output: stdout
+    });
+
+    try {
+      answer = String(await rl.question(promptText)).trim();
+    } finally {
+      rl.close();
+    }
+  }
+
+  if (!answer && defaultValue) {
+    return defaultValue;
+  }
+  if (!answer && required && !allowEmpty) {
+    throw createCliError(`${ownerType} ${ownerId} requires option ${optionName}.`);
+  }
+  return answer || "";
+}
+
+export {
+  appendTextSnippet,
+  escapeRegExp,
+  interpolateOptionValue,
+  normalizeSkipChecks,
+  promptForRequiredOption
+};

package/src/server/outputFormatting.js

@@ -0,0 +1,103 @@
+import { ensureArray, ensureObject } from "./collectionUtils.js";
+
+const ANSI_RESET = "\u001b[0m";
+const ANSI_BOLD = "\u001b[1m";
+const ANSI_DIM = "\u001b[2m";
+const ANSI_CYAN = "\u001b[36m";
+const ANSI_GREEN = "\u001b[32m";
+const ANSI_YELLOW = "\u001b[33m";
+const ANSI_WHITE = "\u001b[97m";
+
+function createColorFormatter(stream) {
+  const noColor = Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+  const term = String(process.env.TERM || "").toLowerCase();
+  const forceColor = String(process.env.FORCE_COLOR || "").trim();
+  const enableColor = (() => {
+    if (forceColor === "0") {
+      return false;
+    }
+    if (forceColor) {
+      return true;
+    }
+    if (noColor || term === "dumb") {
+      return false;
+    }
+    return Boolean(stream && stream.isTTY);
+  })();
+
+  const paint = (text, sequence) => {
+    const value = String(text);
+    if (!enableColor) {
+      return value;
+    }
+    return `${sequence}${value}${ANSI_RESET}`;
+  };
+
+  return Object.freeze({
+    heading: (text) => paint(text, `${ANSI_BOLD}${ANSI_WHITE}`),
+    emphasis: (text) => paint(text, `${ANSI_BOLD}${ANSI_CYAN}`),
+    white: (text) => paint(text, ANSI_WHITE),
+    item: (text) => paint(text, ANSI_CYAN),
+    version: (text) => paint(text, ANSI_DIM),
+    installed: (text) => paint(text, ANSI_GREEN),
+    provider: (text) => paint(text, ANSI_YELLOW),
+    dim: (text) => paint(text, ANSI_DIM)
+  });
+}
+
+function resolveWrapWidth(stream, fallbackWidth = 80) {
+  const parsedFallback = Number(fallbackWidth);
+  const fallback = Number.isFinite(parsedFallback) ? Math.max(20, Math.floor(parsedFallback)) : 80;
+  const columns = Number(stream?.columns);
+  if (!Number.isFinite(columns) || columns < 20) {
+    return fallback;
+  }
+  return Math.floor(columns);
+}
+
+function writeWrappedItems({ stdout, heading, items, lineIndent = "  ", wrapWidth = 80 }) {
+  const records = ensureArray(items)
+    .map((entry) => {
+      const normalized = ensureObject(entry);
+      const text = String(normalized.text || "").trim();
+      const rendered = String(normalized.rendered || text);
+      if (!text) {
+        return null;
+      }
+      return { text, rendered };
+    })
+    .filter(Boolean);
+
+  if (records.length === 0) {
+    return;
+  }
+
+  stdout.write(`${heading}\n`);
+  const width = Math.max(20, Number(wrapWidth) || 80);
+  let line = lineIndent;
+  let lineLength = lineIndent.length;
+
+  for (const record of records) {
+    const separator = lineLength > lineIndent.length ? " " : "";
+    const addedLength = separator.length + record.text.length;
+    if (lineLength > lineIndent.length && lineLength + addedLength > width) {
+      stdout.write(`${line}\n`);
+      line = `${lineIndent}${record.rendered}`;
+      lineLength = lineIndent.length + record.text.length;
+      continue;
+    }
+
+    line = `${line}${separator}${record.rendered}`;
+    lineLength += addedLength;
+  }
+
+  if (lineLength > lineIndent.length) {
+    stdout.write(`${line}\n`);
+  }
+}
+
+export {
+  createColorFormatter,
+  resolveWrapWidth,
+  writeWrappedItems
+};

package/src/server/pathResolution.js

@@ -0,0 +1,106 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { createCliError } from "./cliError.js";
+
+const CLI_PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const require = createRequire(import.meta.url);
+
+function isWorkspaceRoot(candidateRoot) {
+  if (!candidateRoot) {
+    return false;
+  }
+  return (
+    existsSync(path.join(candidateRoot, "packages")) &&
+    existsSync(path.join(candidateRoot, "packages", "kernel")) &&
+    existsSync(path.join(candidateRoot, "tooling", "jskit-cli"))
+  );
+}
+
+function collectAncestorDirectories(startDirectory) {
+  const ancestors = [];
+  let current = path.resolve(startDirectory);
+  while (true) {
+    ancestors.push(current);
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return ancestors;
+}
+
+function resolveWorkspaceRoot() {
+  const candidates = [];
+  const seen = new Set();
+  const appendCandidate = (candidatePath) => {
+    const raw = String(candidatePath || "").trim();
+    if (!raw) {
+      return;
+    }
+    const absolute = path.resolve(raw);
+    if (seen.has(absolute)) {
+      return;
+    }
+    seen.add(absolute);
+    candidates.push(absolute);
+  };
+
+  appendCandidate(process.env.JSKIT_REPO_ROOT);
+  appendCandidate(path.resolve(CLI_PACKAGE_ROOT, "../.."));
+  appendCandidate(CLI_PACKAGE_ROOT);
+
+  const cwdAncestors = collectAncestorDirectories(process.cwd());
+  for (const ancestor of cwdAncestors) {
+    appendCandidate(ancestor);
+    appendCandidate(path.join(ancestor, "jskit-ai"));
+  }
+
+  for (const candidate of candidates) {
+    if (isWorkspaceRoot(candidate)) {
+      return candidate;
+    }
+  }
+
+  return "";
+}
+
+function resolveCatalogPackagesPath() {
+  const explicitPath = String(process.env.JSKIT_CATALOG_PACKAGES_PATH || "").trim();
+  if (explicitPath) {
+    return path.resolve(explicitPath);
+  }
+
+  let catalogPackageJsonPath = "";
+  try {
+    catalogPackageJsonPath = require.resolve("@jskit-ai/jskit-catalog/package.json");
+  } catch {}
+  if (catalogPackageJsonPath) {
+    return path.join(path.dirname(catalogPackageJsonPath), "catalog", "packages.json");
+  }
+
+  const workspaceCatalogPath = path.resolve(CLI_PACKAGE_ROOT, "../jskit-catalog/catalog/packages.json");
+  if (existsSync(workspaceCatalogPath)) {
+    return workspaceCatalogPath;
+  }
+
+  throw createCliError(
+    "Unable to resolve @jskit-ai/jskit-catalog. Install it alongside @jskit-ai/jskit-cli or set JSKIT_CATALOG_PACKAGES_PATH."
+  );
+}
+
+const WORKSPACE_ROOT = resolveWorkspaceRoot();
+const MODULES_ROOT = WORKSPACE_ROOT ? path.join(WORKSPACE_ROOT, "packages") : "";
+const BUNDLES_ROOT = path.join(CLI_PACKAGE_ROOT, "bundles");
+const CATALOG_PACKAGES_PATH = resolveCatalogPackagesPath();
+
+export {
+  CLI_PACKAGE_ROOT,
+  WORKSPACE_ROOT,
+  MODULES_ROOT,
+  BUNDLES_ROOT,
+  CATALOG_PACKAGES_PATH
+};