create-quiver 0.14.1 → 0.15.1

package/src/create-quiver/lib/cli/selectors.js

@@ -0,0 +1,160 @@
+const { resolveUxMode } = require('./ux');
+
+function formatError(message) {
+  return `create-quiver: ${message}`;
+}
+
+function normalizeSelectorOptions(options = []) {
+  return options.map((option) => {
+    if (typeof option === 'string') {
+      return {
+        label: option,
+        value: option,
+        hint: '',
+        default: false,
+      };
+    }
+    return {
+      label: String(option.label || option.name || option.id || option.value || ''),
+      value: String(option.value || option.id || option.path || option.label || ''),
+      hint: option.hint || option.description || '',
+      default: option.default === true || option.recommended === true,
+      raw: option.raw || option,
+    };
+  }).filter((option) => option.label && option.value);
+}
+
+function findOption(options, value) {
+  const normalized = String(value || '').trim();
+  if (!normalized) return null;
+  return options.find((option) => option.value === normalized || option.label === normalized) || null;
+}
+
+function resolveDefaultOption(options, defaultValue) {
+  return findOption(options, defaultValue) || options.find((option) => option.default) || (options.length === 1 ? options[0] : null);
+}
+
+async function loadClack(injected) {
+  if (injected) return injected;
+  return import('@clack/prompts');
+}
+
+async function selectOption(message, rawOptions, options = {}) {
+  const normalizedOptions = normalizeSelectorOptions(rawOptions);
+  if (normalizedOptions.length === 0) {
+    throw new Error(formatError(`${options.name || 'selection'} has no available options.`));
+  }
+
+  const explicit = findOption(normalizedOptions, options.value);
+  if (explicit) return explicit;
+  if (options.value) {
+    throw new Error(formatError(`${options.name || 'selection'} option '${options.value}' was not found.`));
+  }
+
+  const mode = resolveUxMode({
+    interactive: options.interactive === true,
+    json: options.json,
+    noColor: options.noColor,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+  }, options.env || process.env, {
+    input: options.input || process.stdin,
+    output: options.output || process.stdout,
+    error: options.error || process.stderr,
+  });
+
+  if (mode.usePrompts) {
+    if (typeof options.promptSelect === 'function') {
+      const selected = await options.promptSelect(message, normalizedOptions);
+      const match = findOption(normalizedOptions, selected);
+      if (!match) {
+        throw new Error(formatError(`${options.name || 'selection'} prompt returned unknown option '${selected}'.`));
+      }
+      return match;
+    }
+    const clack = await loadClack(options.prompts);
+    const selected = await clack.select({
+      message,
+      options: normalizedOptions.map((option) => ({
+        label: option.label,
+        value: option.value,
+        hint: option.hint || undefined,
+      })),
+      initialValue: resolveDefaultOption(normalizedOptions, options.defaultValue)?.value,
+    });
+    if (clack.isCancel && clack.isCancel(selected)) {
+      throw new Error(formatError(`${options.name || 'selection'} was canceled.`));
+    }
+    return findOption(normalizedOptions, selected);
+  }
+
+  const fallback = resolveDefaultOption(normalizedOptions, options.defaultValue);
+  if (fallback) return fallback;
+
+  const flag = options.flag || '--value';
+  const available = normalizedOptions.map((option) => option.value).join(', ');
+  throw new Error(formatError([
+    `${options.name || 'selection'} requires an explicit choice.`,
+    `Available options: ${available}.`,
+    `Use ${flag} <value> or rerun with --interactive.`,
+  ].join('\n')));
+}
+
+async function promptText(message, options = {}) {
+  const explicit = String(options.value || '').trim();
+  if (explicit) return explicit;
+
+  const mode = resolveUxMode({
+    interactive: options.interactive === true,
+    json: options.json,
+    noColor: options.noColor,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+  }, options.env || process.env, {
+    input: options.input || process.stdin,
+    output: options.output || process.stdout,
+    error: options.error || process.stderr,
+  });
+
+  if (mode.usePrompts) {
+    if (typeof options.promptText === 'function') {
+      const value = await options.promptText(message, options);
+      const normalized = String(value || '').trim();
+      if (!normalized && options.required !== false) {
+        throw new Error(formatError(`${options.name || 'input'} is required.`));
+      }
+      return normalized;
+    }
+    const clack = await loadClack(options.prompts);
+    const value = await clack.text({
+      message,
+      placeholder: options.placeholder,
+      initialValue: options.initialValue,
+      validate: options.required === false
+        ? undefined
+        : (input) => (String(input || '').trim() ? undefined : 'Required'),
+    });
+    if (clack.isCancel && clack.isCancel(value)) {
+      throw new Error(formatError(`${options.name || 'input'} was canceled.`));
+    }
+    return String(value || '').trim();
+  }
+
+  if (options.defaultValue !== undefined && options.defaultValue !== null) {
+    return String(options.defaultValue).trim();
+  }
+
+  const flag = options.flag || '--value';
+  throw new Error(formatError([
+    `${options.name || 'input'} requires an explicit value.`,
+    `Use ${flag} <value> or rerun with --interactive.`,
+  ].join('\n')));
+}
+
+module.exports = {
+  normalizeSelectorOptions,
+  promptText,
+  selectOption,
+};

package/src/create-quiver/lib/cli/theme.js

@@ -9,8 +9,11 @@ const QUIVER_COLORS = Object.freeze({
 const STATUS_COLORS = Object.freeze({
   info: 'sky',
   command: 'blue',
+  success: 'blue',
   planner: 'violet',
   review: 'magenta',
+  warning: 'magenta',
+  error: 'magenta',
   risk: 'magenta',
   muted: 'periwinkle',
 });
@@ -70,8 +73,8 @@ function resolveTheme(options = {}, env = process.env, tty = {}) {
   const useColor = shouldUseColor(options, env, tty);
   const useUnicode = shouldUseUnicode(options, env, tty);
   const symbols = useUnicode
-    ? { start: '◇', success: '✓', warning: '!', error: '✖', bullet: '•' }
-    : { start: '*', success: 'OK', warning: 'WARN', error: 'ERR', bullet: '-' };
+    ? { start: '◇', section: '◆', success: '✓', warning: '!', error: '✖', bullet: '•' }
+    : { start: '*', section: '*', success: 'OK', warning: 'WARN', error: 'ERR', bullet: '-' };
   const theme = {
     colors: QUIVER_COLORS,
     statusColors: STATUS_COLORS,

package/src/create-quiver/lib/cli/ux-flags.js

@@ -5,6 +5,12 @@ const UX_FLAG_OPTIONS = Object.freeze({
 });
 
 const UX_FLAG_MATRIX = Object.freeze({
+  init: Object.freeze({
+    withPlanner: false,
+    interactive: true,
+    review: false,
+    note: 'guided project onboarding choices',
+  }),
   'ai prepare-context': Object.freeze({
     withPlanner: true,
     interactive: true,
@@ -29,6 +35,18 @@ const UX_FLAG_MATRIX = Object.freeze({
     review: true,
     note: 'PR body review and interactive PR inputs',
   }),
+  'ai execute-slice': Object.freeze({
+    withPlanner: false,
+    interactive: true,
+    review: false,
+    note: 'executor profile and ready-slice selection',
+  }),
+  'ai execute-plan': Object.freeze({
+    withPlanner: false,
+    interactive: true,
+    review: false,
+    note: 'execution strategy confirmation and future selectors',
+  }),
 });
 
 function formatError(message) {

package/src/create-quiver/lib/cli/ux.js

@@ -49,6 +49,11 @@ function createUx(options = {}) {
     write(`${text}\n`);
   }
 
+  function formatStatus(status, text) {
+    const symbol = mode.theme.symbols[status] || mode.theme.symbols.bullet;
+    return mode.theme.status(status, `${symbol} ${text}`);
+  }
+
   function heading(text) {
     if (mode.json) return;
     if (!mode.decoration) {
@@ -59,15 +64,65 @@ function createUx(options = {}) {
     line(mode.theme.status('planner', `${prefix} ${text}`));
   }
 
+  function section(text) {
+    if (mode.json) return;
+    if (!mode.decoration) {
+      line(text);
+      return;
+    }
+    const prefix = mode.theme.symbols.section || mode.theme.symbols.start;
+    line(mode.theme.status('command', `${prefix} ${text}`));
+  }
+
   function writeStatus(status, text) {
     if (mode.json) return;
     if (!mode.decoration) {
       line(text);
       return;
     }
-    const symbol = mode.theme.symbols[status] || mode.theme.symbols.bullet;
-    const body = mode.theme.status(status, `${symbol} ${text}`);
-    line(body);
+    line(formatStatus(status, text));
+  }
+
+  function check(text) {
+    writeStatus('success', text);
+  }
+
+  function warning(text) {
+    writeStatus('warning', text);
+  }
+
+  function error(text) {
+    writeStatus('error', text);
+  }
+
+  function info(text) {
+    writeStatus('info', text);
+  }
+
+  function summary(items = [], summaryOptions = {}) {
+    if (mode.json) return;
+    const title = summaryOptions.title || 'Summary';
+    section(title);
+    for (const item of items) {
+      if (typeof item === 'string') {
+        line(mode.decoration ? mode.theme.status('muted', `  ${mode.theme.symbols.bullet} ${item}`) : `- ${item}`);
+        continue;
+      }
+      if (item && typeof item === 'object') {
+        const label = item.label || item.key || '';
+        const value = item.value == null ? '' : String(item.value);
+        const text = label ? `${label}: ${value}` : value;
+        line(mode.decoration ? mode.theme.status(item.status || 'muted', `  ${mode.theme.symbols.bullet} ${text}`) : `- ${text}`);
+      }
+    }
+  }
+
+  function nextSteps(steps = [], stepOptions = {}) {
+    if (mode.json || !Array.isArray(steps) || steps.length === 0) return;
+    section(stepOptions.title || 'Next steps');
+    for (const step of steps) {
+      line(mode.decoration ? mode.theme.status('command', `  ${mode.theme.symbols.bullet} ${step}`) : `- ${step}`);
+    }
   }
 
   async function withSpinner(message, task, spinnerOptions = {}) {
@@ -84,17 +139,49 @@ function createUx(options = {}) {
 
     const clack = await loadClack(options.prompts);
     const spinner = clack.spinner();
+    let stopped = false;
+    function stop(message, code) {
+      if (stopped) return;
+      stopped = true;
+      spinner.stop(message, code);
+    }
     spinner.start(message);
     try {
       const result = await task();
-      spinner.stop(spinnerOptions.successMessage || message);
+      stop(spinnerOptions.successMessage || message);
       return result;
     } catch (error) {
-      spinner.stop(spinnerOptions.failureMessage || `Failed: ${message}`, 1);
+      stop(spinnerOptions.failureMessage || `Failed: ${message}`, 1);
       throw error;
     }
   }
 
+  async function taskGroup(title, stages = []) {
+    heading(title);
+    const results = [];
+    for (const stage of stages) {
+      const run = typeof stage === 'function' ? stage : stage.run;
+      const message = typeof stage === 'function' ? stage.name || 'Running task' : stage.message;
+      const successMessage = stage.successMessage || message;
+      const useSpinner = stage.spinner === true;
+      if (typeof run !== 'function') {
+        throw new Error('create-quiver: taskGroup stage requires a run function.');
+      }
+      const result = useSpinner
+        ? await withSpinner(message, run, {
+          successMessage,
+          failureMessage: stage.failureMessage,
+          echo: stage.echo,
+        })
+        : await run();
+      if (!useSpinner) {
+        check(successMessage);
+      }
+      results.push(result);
+    }
+    return results;
+  }
+
   async function promptConfirm(message, promptOptions = {}) {
     if (!mode.usePrompts) {
       throw new Error('create-quiver: interactive confirmation requires an interactive TTY. Pass the equivalent flags or rerun with --interactive.');
@@ -114,11 +201,19 @@ function createUx(options = {}) {
   }
 
   return {
+    check,
+    error,
     heading,
+    info,
     line,
     mode,
+    nextSteps,
     promptConfirm,
+    section,
+    summary,
+    taskGroup,
     theme: mode.theme,
+    warning,
     withSpinner,
     writeStatus,
   };