@jskit-ai/jskit-cli 0.2.41 → 0.2.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.41",
+  "version": "0.2.42",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -20,8 +20,8 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.40",
-    "@jskit-ai/kernel": "0.1.32"
+    "@jskit-ai/jskit-catalog": "0.1.41",
+    "@jskit-ai/kernel": "0.1.33"
   },
   "engines": {
     "node": "20.x"

package/src/server/cliRuntime/mutations/textMutations.js

@@ -118,25 +118,30 @@ async function applyTextMutations(packageEntry, appRoot, textMutations, options,
     const operation = String(mutation?.op || "").trim();
     if (operation === "upsert-env") {
       const relativeFile = String(mutation?.file || "").trim();
-      const key = String(mutation?.key || "").trim();
-      if (!relativeFile || !key) {
+      const rawKey = String(mutation?.key || "").trim();
+      if (!relativeFile || !rawKey) {
         throw createCliError(`Invalid upsert-env mutation in ${packageEntry.packageId}: "file" and "key" are required.`);
       }
 
+      const resolvedKey = interpolateOptionValue(rawKey, options, packageEntry.packageId, `${rawKey}.key`).trim();
+      if (!resolvedKey) {
+        throw createCliError(`Invalid upsert-env mutation in ${packageEntry.packageId}: resolved key is empty.`);
+      }
+
       const absoluteFile = path.join(appRoot, relativeFile);
       const previous = await readFileBufferIfExists(absoluteFile);
       const previousContent = previous.exists ? previous.buffer.toString("utf8") : "";
-      const resolvedValue = interpolateOptionValue(mutation?.value || "", options, packageEntry.packageId, key);
-      const upserted = upsertEnvValue(previousContent, key, resolvedValue);
+      const resolvedValue = interpolateOptionValue(mutation?.value || "", options, packageEntry.packageId, resolvedKey);
+      const upserted = upsertEnvValue(previousContent, resolvedKey, resolvedValue);
 
       await mkdir(path.dirname(absoluteFile), { recursive: true });
       await writeFile(absoluteFile, upserted.content, "utf8");
 
-      const recordKey = `${relativeFile}::${String(mutation?.id || key)}`;
+      const recordKey = `${relativeFile}::${String(mutation?.id || resolvedKey)}`;
       managedText[recordKey] = {
         file: relativeFile,
         op: "upsert-env",
-        key,
+        key: resolvedKey,
         value: resolvedValue,
         hadPrevious: upserted.hadPrevious,
         previousValue: upserted.previousValue,

package/src/server/cliRuntime/packageOptions.js

@@ -91,6 +91,7 @@ function resolveSurfaceDefinitionsForOptionPolicy(configContext = {}) {
 
     normalizedDefinitions[definitionId] = Object.freeze({
       id: definitionId,
+      label: String(definition.label || "").trim(),
       enabled: definition.enabled !== false,
       requiresWorkspace: definition.requiresWorkspace === true
     });
@@ -251,6 +252,23 @@ async function validateResolvedOptionPolicies({
   });
 }
 
+function resolvePromptChoicesForOption({ schema = {}, configContext = {} } = {}) {
+  const validationType = normalizeResolvedOptionValue(schema.validationType);
+  if (validationType !== OPTION_VALIDATION_ENABLED_SURFACE_ID) {
+    return [];
+  }
+
+  const surfaceDefinitions = resolveSurfaceDefinitionsForOptionPolicy(configContext);
+  return Object.values(surfaceDefinitions)
+    .filter((entry) => entry.enabled === true)
+    .map((entry) => Object.freeze({
+      value: entry.id,
+      label: entry.label && entry.label.toLowerCase() !== entry.id.toLowerCase()
+        ? `${entry.id} (${entry.label})`
+        : entry.id
+    }));
+}
+
 async function validateOptionValuesForPackage({
   packageEntry,
   resolvedOptions = {},
@@ -379,11 +397,13 @@ async function resolvePackageOptions(packageEntry, inlineOptions, io, { appRoot
     }
 
     if (schema.required) {
+      const promptConfigContext = appRoot ? await loadConfigContext() : {};
       assignResolvedOption(await promptForRequiredOption({
         ownerType: "package",
         ownerId: packageEntry.packageId,
         optionName,
         optionSchema: schema,
+        promptChoices: resolvePromptChoicesForOption({ schema, configContext: promptConfigContext }),
         stdin: io.stdin,
         stdout: io.stdout
       }));

package/src/server/commandHandlers/packageCommands/generate.js

@@ -73,40 +73,11 @@ function mapDescriptorBackedSubcommandArgsToInlineOptions(
 }
 
 function resolveSubcommandRequiresInput(packageEntry = {}, subcommandName = "") {
-  const descriptor = packageEntry?.descriptor && typeof packageEntry.descriptor === "object"
-    ? packageEntry.descriptor
-    : {};
-  const optionSchemas = descriptor?.options && typeof descriptor.options === "object"
-    ? descriptor.options
-    : {};
   const subcommandDefinition = resolveGeneratorSubcommandDefinitionMetadata(packageEntry, subcommandName);
   const positionalArgs = Array.isArray(subcommandDefinition?.positionalArgs)
     ? subcommandDefinition.positionalArgs
     : [];
-  if (positionalArgs.length > 0) {
-    return true;
-  }
-  const requiredOptionNames = Array.isArray(subcommandDefinition?.requiredOptionNames)
-    ? subcommandDefinition.requiredOptionNames
-    : [];
-  if (requiredOptionNames.some((optionName) => String(optionName || "").trim().length > 0)) {
-    return true;
-  }
-
-  const optionNames = Array.isArray(subcommandDefinition?.optionNames) && subcommandDefinition.optionNames.length > 0
-    ? subcommandDefinition.optionNames
-    : Object.keys(optionSchemas);
-  for (const optionName of optionNames) {
-    const normalizedOptionName = String(optionName || "").trim();
-    if (!normalizedOptionName) {
-      continue;
-    }
-    const schema = optionSchemas[normalizedOptionName];
-    if (schema && typeof schema === "object" && schema.required === true) {
-      return true;
-    }
-  }
-  return false;
+  return positionalArgs.some((arg) => arg && typeof arg === "object" && arg.required !== false);
 }
 
 function collectUnexpectedGeneratorSubcommandOptionNames(packageEntry = {}, subcommandName = "", inlineOptions = {}) {

package/src/server/core/argParser.js

@@ -120,8 +120,9 @@ function parseArgs(argv, { createCliError } = {}) {
       if (hasInlineValue) {
         optionValueRaw = withoutPrefix.slice(withoutPrefix.indexOf("=") + 1);
       } else {
-        const nextToken = typeof args[0] === "string" ? String(args[0]) : "";
-        if (nextToken && !nextToken.startsWith("-")) {
+        const hasNextStringToken = typeof args[0] === "string";
+        const nextToken = hasNextStringToken ? String(args[0]) : "";
+        if (hasNextStringToken && !nextToken.startsWith("-")) {
           optionValueRaw = args.shift();
         }
       }

package/src/server/shared/optionInterpolation.js

@@ -209,6 +209,80 @@ function normalizePathValue(value) {
     .join("/");
 }
 
+function normalizePromptChoices(rawChoices = []) {
+  return ensureArray(rawChoices)
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return null;
+      }
+      const value = String(entry.value || "").trim();
+      const label = String(entry.label || value).trim();
+      if (!value || !label) {
+        return null;
+      }
+      return Object.freeze({ value, label });
+    })
+    .filter(Boolean);
+}
+
+function findPromptChoice(promptChoices = [], answer = "") {
+  const normalizedAnswer = String(answer || "").trim();
+  if (!normalizedAnswer) {
+    return null;
+  }
+
+  if (/^\d+$/.test(normalizedAnswer)) {
+    const index = Number.parseInt(normalizedAnswer, 10) - 1;
+    if (index >= 0 && index < promptChoices.length) {
+      return promptChoices[index];
+    }
+  }
+
+  return promptChoices.find((entry) => {
+    return entry.value === normalizedAnswer || entry.label === normalizedAnswer;
+  }) || null;
+}
+
+async function promptForChoice({
+  promptText = "",
+  promptChoices = [],
+  stdin,
+  stdout,
+  required = false,
+  defaultValue = ""
+}) {
+  const rl = createInterface({
+    input: stdin,
+    output: stdout
+  });
+
+  try {
+    while (true) {
+      const answer = String(await rl.question(promptText)).trim();
+      if (!answer && defaultValue) {
+        return defaultValue;
+      }
+      if (!answer && !required) {
+        return "";
+      }
+      if (!answer && required) {
+        throw createCliError("A selection is required.");
+      }
+
+      const matchedChoice = findPromptChoice(promptChoices, answer);
+      if (matchedChoice) {
+        return matchedChoice.value;
+      }
+
+      const values = promptChoices.map((entry) => entry.value).join(", ");
+      stdout.write(`Invalid selection. Enter a number or one of: ${values}.
+`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
 function parseTransformSpec(transform) {
   const normalized = String(transform || "").trim();
   if (!normalized) {
@@ -359,6 +433,7 @@ async function promptForRequiredOption({
   ownerId,
   optionName,
   optionSchema,
+  promptChoices = [],
   stdin = process.stdin,
   stdout = process.stdout
 }) {
@@ -387,6 +462,24 @@ async function promptForRequiredOption({
   const defaultHint = defaultValue ? ` [default: ${defaultValue}]` : "";
   const hintSuffix = promptHint ? ` ${promptHint}` : "";
   const promptText = `${label}${defaultHint}${hintSuffix}: `;
+  const normalizedPromptChoices = normalizePromptChoices(promptChoices);
+
+  if (normalizedPromptChoices.length > 0) {
+    stdout.write(`${label}${defaultHint}${hintSuffix}
+`);
+    normalizedPromptChoices.forEach((entry, index) => {
+      stdout.write(`  ${index + 1}) ${entry.label}
+`);
+    });
+    return promptForChoice({
+      promptText: "Select a surface by number or id: ",
+      promptChoices: normalizedPromptChoices,
+      stdin,
+      stdout,
+      required,
+      defaultValue
+    });
+  }
 
   let answer = "";