create-quiver 0.14.1 → 0.15.0

package/src/create-quiver/lib/agent-profiles.js

@@ -5,7 +5,7 @@ const { assertSupportedProvider, formatProviderList } = require('./ai/providers'
 const { quiverInternalPaths } = require('./init-layout');
 
 const AGENT_PROFILE_ROLES = Object.freeze(['planner', 'executor', 'reviewer', 'doctor']);
-const PROFILE_STATE_VERSION = 1;
+const PROFILE_STATE_VERSION = 2;
 
 function formatError(message) {
   return `create-quiver: ${message}`;
@@ -56,9 +56,46 @@ function emptyProfilesState() {
   return {
     version: PROFILE_STATE_VERSION,
     profiles: {},
+    profile_sets: {},
   };
 }
 
+function profileSetKey(role) {
+  return `${normalizeAgentProfileRole(role)}s`;
+}
+
+function normalizeProfileId(value, fallback = 'default') {
+  const source = String(value || fallback || 'default').trim().toLowerCase();
+  const normalized = source
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || 'default';
+}
+
+function resolveAgentProfileDisplayName(profile = {}) {
+  return profile.displayName || profile.model || profile.provider || profile.role || '';
+}
+
+function normalizeStoredProfile(profile, role, fallbackId = 'default') {
+  const normalizedRole = normalizeAgentProfileRole(role || profile?.role);
+  const provider = profile?.provider ? assertSupportedProvider(profile.provider) : '';
+  const normalized = {
+    id: normalizeProfileId(profile?.id || profile?.label, fallbackId),
+    role: normalizedRole,
+    provider,
+    model: normalizeOptionalText(profile?.model, 'model'),
+    label: normalizeOptionalText(profile?.label, 'label'),
+    displayName: normalizeOptionalText(profile?.displayName || profile?.display_name, 'displayName'),
+    context: normalizeOptionalText(profile?.context, 'context'),
+    default: profile?.default === true,
+    updated_at: profile?.updated_at || '',
+  };
+  if (!normalized.displayName) {
+    normalized.displayName = resolveAgentProfileDisplayName(normalized);
+  }
+  return normalized;
+}
+
 function readAgentProfiles(projectRoot) {
   const filePath = agentProfilesPath(projectRoot);
   if (!fs.existsSync(filePath)) {
@@ -69,6 +106,8 @@ function readAgentProfiles(projectRoot) {
   return {
     version: state.version || PROFILE_STATE_VERSION,
     profiles: state.profiles && typeof state.profiles === 'object' ? state.profiles : {},
+    profile_sets: state.profile_sets && typeof state.profile_sets === 'object' ? state.profile_sets : {},
+    updated_at: state.updated_at || undefined,
   };
 }
 
@@ -80,18 +119,53 @@ function writeAgentProfiles(projectRoot, state) {
 }
 
 function getAgentProfile(projectRoot, role) {
+  const normalizedRole = normalizeAgentProfileRole(role);
+  const profiles = getAgentProfilesForRole(projectRoot, normalizedRole);
+  if (profiles.length === 0) return null;
+  return profiles.find((profile) => profile.default) || profiles[0];
+}
+
+function getAgentProfileById(projectRoot, role, profileId) {
+  const normalizedRole = normalizeAgentProfileRole(role);
+  const normalizedId = normalizeProfileId(profileId);
+  return getAgentProfilesForRole(projectRoot, normalizedRole)
+    .find((profile) => profile.id === normalizedId) || null;
+}
+
+function getAgentProfilesForRole(projectRoot, role) {
   const normalizedRole = normalizeAgentProfileRole(role);
   const state = readAgentProfiles(projectRoot);
-  return state.profiles[normalizedRole] || null;
+  const setKey = profileSetKey(normalizedRole);
+  const fromSet = Array.isArray(state.profile_sets[setKey])
+    ? state.profile_sets[setKey].map((profile, index) => normalizeStoredProfile(profile, normalizedRole, index === 0 ? 'default' : `${normalizedRole}-${index + 1}`))
+    : [];
+  const legacy = state.profiles[normalizedRole]
+    ? normalizeStoredProfile({ ...state.profiles[normalizedRole], default: true }, normalizedRole, 'default')
+    : null;
+  const merged = new Map();
+
+  if (legacy) merged.set(legacy.id, legacy);
+  for (const profile of fromSet) {
+    merged.set(profile.id, profile);
+  }
+
+  const profiles = Array.from(merged.values()).filter((profile) => profile.provider);
+  if (profiles.length > 0 && !profiles.some((profile) => profile.default)) {
+    profiles[0].default = true;
+  }
+  return profiles;
 }
 
 function listAgentProfiles(projectRoot) {
-  const state = readAgentProfiles(projectRoot);
-  return AGENT_PROFILE_ROLES.map((role) => ({
-    role,
-    configured: Boolean(state.profiles[role]),
-    profile: state.profiles[role] || null,
-  }));
+  return AGENT_PROFILE_ROLES.map((role) => {
+    const profiles = getAgentProfilesForRole(projectRoot, role);
+    return {
+      role,
+      configured: profiles.length > 0,
+      profile: profiles.find((profile) => profile.default) || profiles[0] || null,
+      profiles,
+    };
+  });
 }
 
 function setAgentProfile(projectRoot, role, options = {}) {
@@ -109,23 +183,47 @@ function buildAgentProfileState(projectRoot, role, options = {}) {
   const provider = assertSupportedProvider(options.provider);
   const model = normalizeOptionalText(options.model, 'model');
   const label = normalizeOptionalText(options.label, 'label');
+  const displayName = normalizeOptionalText(options.displayName || options.display_name, 'displayName');
   const context = normalizeOptionalText(options.context, 'context');
   const state = readAgentProfiles(projectRoot);
-  const current = state.profiles[normalizedRole] || {};
+  const currentProfiles = getAgentProfilesForRole(projectRoot, normalizedRole);
+  const currentDefault = currentProfiles.find((profile) => profile.default) || currentProfiles[0] || {};
+  const id = normalizeProfileId(options.id || currentDefault.id || label || model || provider);
+  const current = currentProfiles.find((profile) => profile.id === id) || {};
   const now = options.now instanceof Date ? options.now.toISOString() : new Date().toISOString();
+  const shouldBeDefault = options.default === true || currentProfiles.length === 0 || (options.default !== false && current.default === true);
   const profile = {
+    id,
     role: normalizedRole,
     provider,
     model: model || current.model || '',
     label: label || current.label || '',
+    displayName: displayName || current.displayName || model || label || provider,
     context: context || current.context || '',
+    default: shouldBeDefault,
     updated_at: now,
   };
 
   state.version = PROFILE_STATE_VERSION;
+  const setKey = profileSetKey(normalizedRole);
+  const nextProfiles = currentProfiles
+    .filter((item) => item.id !== id)
+    .map((item) => ({
+      ...item,
+      default: shouldBeDefault ? false : item.default === true,
+    }))
+    .concat(profile);
+  if (!nextProfiles.some((item) => item.default)) {
+    nextProfiles[0].default = true;
+  }
+  state.profile_sets = {
+    ...state.profile_sets,
+    [setKey]: nextProfiles,
+  };
+  const defaultProfile = nextProfiles.find((item) => item.default) || profile;
   state.profiles = {
     ...state.profiles,
-    [normalizedRole]: profile,
+    [normalizedRole]: defaultProfile,
   };
   state.updated_at = now;
 
@@ -149,6 +247,9 @@ module.exports = {
   AGENT_PROFILE_ROLES,
   PROFILE_STATE_VERSION,
   agentProfilesPath,
+  getAgentProfileById,
+  getAgentProfilesForRole,
+  resolveAgentProfileDisplayName,
   formatProviderList,
   buildAgentProfileState,
   getAgentProfile,

package/src/create-quiver/lib/ai/execution-plan.js

@@ -1,7 +1,13 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { resolveProfileProvider } = require('../agent-profiles');
+const {
+  getAgentProfile,
+  getAgentProfileById,
+  resolveAgentProfileDisplayName,
+  resolveProfileProvider,
+} = require('../agent-profiles');
+const { createUx } = require('../cli/ux');
 const { branchDelete, runGit, statusPorcelain, worktreeAdd, worktreePrune, worktreeRemove } = require('../git');
 const { withLock } = require('../locks');
 const { safeBranchName, worktreesRootForRepo } = require('../slice');
@@ -19,6 +25,71 @@ function toRelativePath(repoRoot, filePath) {
   return path.relative(repoRoot, filePath).split(path.sep).join('/');
 }
 
+function resolveExecutorRuntimeProfile(repoRoot, options = {}) {
+  const explicitProvider = options.providerExplicit === true || (options.provider && options.providerExplicit !== false);
+  const explicitModel = String(options.model || '').trim();
+
+  if (explicitProvider) {
+    const provider = String(options.provider || 'codex').trim().toLowerCase();
+    return {
+      provider,
+      model: explicitModel,
+      displayName: explicitModel || provider,
+      profile: null,
+    };
+  }
+
+  const profile = options.executorProfile
+    ? getAgentProfileById(repoRoot, 'executor', options.executorProfile)
+    : getAgentProfile(repoRoot, 'executor');
+  const provider = profile?.provider || resolveProfileProvider(repoRoot, options.role || 'executor', 'codex');
+  const model = explicitModel || profile?.model || '';
+
+  return {
+    provider,
+    model,
+    displayName: profile ? resolveAgentProfileDisplayName(profile) : (model || provider),
+    profile,
+  };
+}
+
+function createCommandUx(options = {}) {
+  if (options.ux) {
+    return options.ux;
+  }
+
+  return createUx({
+    env: options.env || process.env,
+    interactive: options.interactive,
+    json: options.json,
+    noColor: options.noColor,
+    prompts: options.prompts,
+    spinner: options.spinner,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+    write: options.write,
+  });
+}
+
+function shouldShowHumanProgress(ux, options = {}) {
+  return options.progress !== false
+    && options.dryRun !== true
+    && options.json !== true
+    && ux?.mode?.decoration === true;
+}
+
+async function runWithProgress({ ux, enabled, message, successMessage, failureMessage, run }) {
+  if (!enabled) {
+    return run();
+  }
+
+  return ux.withSpinner(message, run, {
+    successMessage,
+    failureMessage,
+  });
+}
+
 function normalizeExecutionMode(mode) {
   const value = String(mode || 'auto').trim().toLowerCase() || 'auto';
   if (!EXECUTION_MODES.has(value)) {
@@ -316,12 +387,14 @@ function formatHumanExecutionPlan(report) {
 
 function formatExecutePlanDryRun(report, options = {}) {
   const provider = options.resolvedProvider || options.provider || 'codex';
+  const model = options.resolvedModel || options.model || '';
   const commitEnabled = options.commit === true;
   const executionMode = normalizeExecutionMode(options.mode || options.executionMode);
   const lines = [
     'AI execute-plan dry-run',
     `Execution mode: ${executionMode}`,
     `Provider: ${provider}`,
+    model ? `Model: ${model}` : '',
     `Commit after each slice: ${commitEnabled ? 'enabled' : 'disabled'}`,
     `Total slices: ${report.summary.total_slices}`,
     '',
@@ -334,6 +407,9 @@ function formatExecutePlanDryRun(report, options = {}) {
       `--slice ${JSON.stringify(slice.slice_path)}`,
       `--provider ${provider}`,
     ];
+    if (model) {
+      parts.push(`--model ${JSON.stringify(model)}`);
+    }
     if (commitEnabled) {
       parts.push('--commit');
     }
@@ -363,7 +439,7 @@ function formatExecutePlanDryRun(report, options = {}) {
     }
   }
 
-  return `${lines.join('\n')}\n`;
+  return `${lines.filter(Boolean).join('\n')}\n`;
 }
 
 function buildRecoveryGuidance(ref, workspaces = []) {
@@ -455,8 +531,11 @@ async function runSequentialGroup(repoRoot, level, group, options = {}) {
         commit: true,
         context: options.context,
         dryRun: false,
+        executorProfile: options.executorProfile,
         provider: options.provider,
         providerExplicit: options.providerExplicit,
+        progress: false,
+        model: options.model,
         role: options.role,
         slice: slice.slice_path,
         skipWorktreeBranchCheck: true,
@@ -507,8 +586,11 @@ async function runParallelGroupInWorktrees(repoRoot, level, group, options = {})
         commit: true,
         context: options.context,
         dryRun: false,
+        executorProfile: options.executorProfile,
         provider: options.provider,
         providerExplicit: options.providerExplicit,
+        progress: false,
+        model: options.model,
         role: options.role,
         slice: workspace.slice.slice_path,
         skipWorktreeBranchCheck: true,
@@ -557,13 +639,15 @@ async function runExecutePlan(repoRoot, options = {}) {
   const report = collectExecutionPlan(repoRoot, options);
   const execute = options.execute === true;
   const executionMode = normalizeExecutionMode(options.mode || options.executionMode);
-  const provider = options.providerExplicit === true || (options.provider && options.providerExplicit !== false)
-    ? options.provider
-    : resolveProfileProvider(repoRoot, options.role || 'executor', 'codex');
+  const runtimeProfile = resolveExecutorRuntimeProfile(repoRoot, options);
+  const provider = runtimeProfile.provider;
   const resolvedOptions = {
     ...options,
     mode: executionMode,
+    model: runtimeProfile.model,
     provider,
+    profile: runtimeProfile,
+    resolvedModel: runtimeProfile.model,
     resolvedProvider: provider,
   };
 
@@ -586,13 +670,27 @@ async function runExecutePlan(repoRoot, options = {}) {
   }
 
   const results = [];
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  if (showProgress) {
+    ux.heading(`Ejecutando plan de slices con ${runtimeProfile.displayName}`);
+    ux.check(`Plan cargado: ${report.summary.total_slices} slice${report.summary.total_slices === 1 ? '' : 's'}`);
+    ux.check(`Modo: ${executionMode}`);
+  }
 
   for (const level of report.ready_levels) {
     for (const group of level.execution_groups) {
       try {
-        const groupResults = executionMode === 'delegated' && group.mode === 'parallel' && group.slice_refs.length > 1
-          ? await runParallelGroupInWorktrees(repoRoot, level, group, resolvedOptions)
-          : await runSequentialGroup(repoRoot, level, group, resolvedOptions);
+        const groupResults = await runWithProgress({
+          ux,
+          enabled: showProgress,
+          message: `Ejecutando wave ${level.index}: ${group.slice_refs.join(', ')}`,
+          successMessage: `Wave ${level.index} completada`,
+          failureMessage: `Falló wave ${level.index}`,
+          run: () => (executionMode === 'delegated' && group.mode === 'parallel' && group.slice_refs.length > 1
+            ? runParallelGroupInWorktrees(repoRoot, level, group, resolvedOptions)
+            : runSequentialGroup(repoRoot, level, group, resolvedOptions)),
+        });
         results.push(...groupResults);
       } catch (error) {
         const wrapped = new Error(formatError(`ai execute-plan stopped at wave ${level.index} group ${group.slice_refs.join(', ')}: ${error.message || error}`));