@hifullmoon/aicommit 1.5.1 → 2.0.0

package/src/setup.js

@@ -9,28 +9,17 @@ import password from '@inquirer/password';
 import confirm from '@inquirer/confirm';
 
 import { checkConnection } from './api.js';
-import { isSecureApiUrl } from './config.js';
+import { CONFIG_SCHEMA_VERSION, isSecureApiUrl, validateUserConfig } from './config.js';
 import { vimSelect } from './ui.js';
 import { fileExists, formatMs, indentError, maskApiKey } from './utils.js';
 import { loadProviderPresetManifest } from './provider-presets.js';
 
-// Top-level connection keys from a legacy flat config. When the wizard writes
-// a providers map these are dropped from the top level, so the old flat
-// values can't silently shadow or conflict with the provider entries.
-const FLAT_CONNECTION_KEYS = ['apiUrl', 'apiKey', 'apiKeyEnv', 'modelId'];
-
-// Merge the wizard's answers into an existing config object (or an empty
-// one). Existing providers and unrelated settings are preserved; the new
-// provider becomes the default. Pure — exported for tests.
+// Merge the wizard's answers into the one supported Provider/Model schema.
+// Existing providers and unrelated global settings are preserved; the
+// configured provider becomes the default. Pure — exported for tests.
 export function mergeSetupConfig(existing, { providerName, entry, language }) {
   const result = { ...existing };
-
-  // Legacy flat config: remove the top-level connection keys now that the
-  // connection lives under providers[providerName].
-  if (!result.providers) {
-    for (const key of FLAT_CONNECTION_KEYS) delete result[key];
-  }
-
+  result.schemaVersion = CONFIG_SCHEMA_VERSION;
   result.providers = { ...existing.providers, [providerName]: entry };
   result.defaultProvider = providerName;
   result.language = language;
@@ -41,10 +30,7 @@ async function readExistingConfig(path) {
   if (!(await fileExists(path))) return {};
   try {
     const parsed = JSON.parse(await readFile(path, 'utf-8'));
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-      throw new Error('expected a JSON object');
-    }
-    return parsed;
+    return validateUserConfig(parsed);
   } catch (err) {
     const backup = `${path}.invalid-${Date.now()}.bak`;
     await copyFile(path, backup);
@@ -105,13 +91,15 @@ export async function runSetup(dependencies = {}) {
       ...providerPresets.map((p) => ({
         name: p.label,
         value: p.id,
-        description: `${p.apiUrl} — default model: ${p.modelId}`,
+        description:
+          `${p.apiUrl} — default model: ` +
+          `${p.models[p.defaultModel].label || p.models[p.defaultModel].modelId}`,
       })),
       { name: 'custom', value: 'custom', description: 'Any OpenAI-compatible endpoint' },
     ],
   });
 
-  let providerName, apiUrl, defaultModel, presetAdapter, presetExtraBody;
+  let providerName, apiUrl, presetAdapter, presetModels, presetDefaultModel;
   if (presetName === 'custom') {
     providerName = await inputPrompt({
       message: 'Provider name (used with aicommit -p <name>)',
@@ -123,15 +111,16 @@ export async function runSetup(dependencies = {}) {
       validate: (v) => isSecureApiUrl(v.trim()) || 'Use HTTPS, or HTTP only for localhost/loopback',
     });
     apiUrl = apiUrl.trim();
-    defaultModel = '';
+    presetModels = {};
+    presetDefaultModel = 'default';
   } else {
     const preset = providerPresets.find((p) => p.id === presetName);
     if (!preset) throw new Error(`Provider preset not found: ${presetName}`);
     providerName = preset.id;
     apiUrl = preset.apiUrl;
-    defaultModel = preset.modelId;
     presetAdapter = preset.adapter;
-    presetExtraBody = preset.extraBody;
+    presetModels = preset.models;
+    presetDefaultModel = preset.defaultModel;
   }
 
   const existingProvider = existing.providers?.[providerName] || {};
@@ -172,12 +161,45 @@ export async function runSetup(dependencies = {}) {
 
   // ── 4. Model ────────────────────────────────────────────────────────
 
-  const modelInput = await inputPrompt({
-    message: 'Model ID',
-    default: existingProvider.modelId || defaultModel || undefined,
-    validate: (v) => (v.trim() ? true : 'Model ID is required'),
-  });
-  const modelId = modelInput.trim();
+  const models = { ...presetModels, ...existingProvider.models };
+  let suggestedModel = existingProvider.defaultModel || presetDefaultModel;
+  while (true) {
+    const modelNameInput = await inputPrompt({
+      message: 'Model name (used with aicommit -m <name>)',
+      default: suggestedModel,
+      validate: (v) =>
+        /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(v.trim()) ||
+        'Use 1-64 letters, digits, dots, dashes, or underscores',
+    });
+    const modelName = modelNameInput.trim();
+    const currentModel = models[modelName] || {};
+    const modelIdInput = await inputPrompt({
+      message: `Model ID for ${modelName}`,
+      default: currentModel.modelId || undefined,
+      validate: (v) => (v.trim() ? true : 'Model ID is required'),
+    });
+    models[modelName] = { ...currentModel, modelId: modelIdInput.trim() };
+    const addAnother = await confirmPrompt({
+      message: 'Add another model?',
+      default: false,
+    });
+    if (!addAnother) break;
+    suggestedModel = undefined;
+  }
+
+  const modelNames = Object.keys(models);
+  const defaultModel =
+    modelNames.length === 1
+      ? modelNames[0]
+      : await selectPrompt({
+          message: 'Choose the default model',
+          default: existingProvider.defaultModel || presetDefaultModel,
+          choices: modelNames.map((name) => ({
+            name: `${name} (${models[name].modelId})`,
+            value: name,
+          })),
+        });
+  const selectedModel = models[defaultModel];
 
   // ── 5. Commit message language ──────────────────────────────────────
 
@@ -191,13 +213,16 @@ export async function runSetup(dependencies = {}) {
   });
 
   const entry = {
-    ...existingProvider,
     apiUrl,
     apiKey,
     apiKeyEnv,
-    modelId,
-    ...(presetAdapter ? { providerType: presetAdapter } : {}),
-    ...(presetExtraBody && !existingProvider.extraBody ? { extraBody: presetExtraBody } : {}),
+    providerType: presetAdapter || existingProvider.providerType || 'custom',
+    defaultModel,
+    models,
+    ...(existingProvider.retry ? { retry: existingProvider.retry } : {}),
+    ...(existingProvider.credentialHelper
+      ? { credentialHelper: existingProvider.credentialHelper }
+      : {}),
   };
 
   // ── 6. Connection test ──────────────────────────────────────────────
@@ -210,13 +235,14 @@ export async function runSetup(dependencies = {}) {
 
   if (runTest) {
     const spinner = spinnerFactory({
-      text: chalk.dim(`Checking ${chalk.bold(modelId)} ...`),
+      text: chalk.dim(`Checking ${chalk.bold(selectedModel.modelId)} ...`),
       color: 'cyan',
     }).start();
 
     try {
       const report = await connectionCheck({
         ...entry,
+        ...selectedModel,
         apiKey: apiKeyEnv ? process.env[apiKeyEnv] : apiKey,
         maxTokens: 64,
         timeoutMs: 120000,
@@ -240,6 +266,7 @@ export async function runSetup(dependencies = {}) {
   // ── 7. Write config ─────────────────────────────────────────────────
 
   const merged = mergeSetupConfig(existing, { providerName, entry, language });
+  validateUserConfig(merged);
   // Write through a same-directory temporary file so interruption cannot
   // leave a partially written config. Permissions are tightened before the
   // atomic replacement as well as after it (best effort on Windows).
@@ -248,7 +275,9 @@ export async function runSetup(dependencies = {}) {
   console.log('');
   console.log('  ' + chalk.green.bold('✓ Config saved'));
   console.log('  ' + chalk.dim(`  Path:     ${targetPath}`));
-  console.log('  ' + chalk.dim(`  Provider: ${providerName} (${modelId})`));
+  console.log(
+    '  ' + chalk.dim(`  Provider: ${providerName}/${defaultModel} (${selectedModel.modelId})`),
+  );
   console.log(
     '  ' + chalk.dim(`  API key:  ${apiKeyEnv ? `env:${apiKeyEnv}` : maskApiKey(apiKey)}`),
   );

package/src/ui.js

@@ -128,6 +128,21 @@ export function formatReasoningPanel(reasoning, options = {}) {
 
 const CTRL_O_RELEASE_MS = 180;
 
+export class PromptQuitError extends Error {
+  constructor() {
+    super('User quit the interactive prompt.');
+    this.name = 'PromptQuitError';
+  }
+}
+
+export function isPromptQuitError(error) {
+  return error instanceof PromptQuitError;
+}
+
+function isQuitKey(key) {
+  return key?.name === 'q' && !key.ctrl && !key.meta && !key.shift;
+}
+
 function useCtrlOToggleGate() {
   const gate = useRef({ locked: false, timer: null });
   useEffect(() => () => clearTimeout(gate.current.timer), []);
@@ -291,6 +306,7 @@ const reasoningSelect = createPrompt((config, done) => {
   const choices = normalizeSelectChoices(config.choices);
   const first = choices.findIndex((choice) => !choice.disabled);
   if (first === -1) throw new Error('No selectable choices.');
+  const quitChoice = choices.find((choice) => !choice.disabled && choice.value === 'cancel');
 
   const [active, setActive] = useState(first);
   const [expanded, setExpanded] = useState(false);
@@ -308,6 +324,12 @@ const reasoningSelect = createPrompt((config, done) => {
   const maxOffset = Math.max(0, completeView.totalLines - pageSize);
 
   useKeypress((key, rl) => {
+    if (isQuitKey(key)) {
+      if (!quitChoice) throw new PromptQuitError();
+      setStatus('quit');
+      done(quitChoice.value);
+      return;
+    }
     if (key.ctrl && key.name === 'o') {
       rl.clearLine(0);
       if (acceptCtrlOToggle(ctrlOGate)) {
@@ -352,8 +374,9 @@ const reasoningSelect = createPrompt((config, done) => {
     }
   });
 
-  if (status === 'done') {
-    return `${chalk.green('?')} ${config.message} ${chalk.cyan(selected.short)}`;
+  if (status !== 'idle') {
+    const answer = status === 'quit' ? quitChoice : selected;
+    return `${chalk.green('?')} ${config.message} ${chalk.cyan(answer.short)}`;
   }
 
   const panel = formatReasoningPanel(config.reasoning.text, {
@@ -371,25 +394,29 @@ const reasoningSelect = createPrompt((config, done) => {
     .join('\n');
   const description = selected.description ? `\n  ${chalk.cyan(selected.description)}` : '';
   const pageHelp = expanded && maxOffset > 0 ? ' · PgUp/PgDn reasoning' : '';
-  const help = chalk.dim(`  ↑↓/j k navigate · Enter select · Ctrl+O reasoning${pageHelp}`);
+  const help = chalk.dim(`  ↑↓/j k navigate · Enter select · q quit · Ctrl+O reasoning${pageHelp}`);
 
   return `${panel}\n\n${chalk.green('?')} ${config.message}\n${rows}${description}\n${help}\x1B[?25l`;
 });
 
-// Vim-friendly prompts: wraps @inquirer prompts with j/k → arrow key
-// remapping. We intercept keypress events BEFORE @inquirer sees them and
-// translate j→down, k→up by emitting synthetic arrow-key events.
-// @inquirer ignores the original j/k characters, so only the arrow keys
-// take effect.
-async function withVimKeys(promptFn, options) {
+// Vim-friendly prompts: wraps @inquirer prompts with j/k navigation and q to
+// quit. The q shortcut resolves to an existing cancel choice when possible so
+// callers can run their normal cleanup; prompts without one unwind through a
+// dedicated error that main turns into a successful cancellation.
+async function withVimKeys(promptFn, options, { quitValue, hasQuitValue = false } = {}) {
   // Ensure keypress events are enabled on stdin (idempotent)
   readline.emitKeypressEvents(process.stdin);
 
   let inTranslate = false; // guard against re-entering our own synthetic emits
+  let quitRequested = false;
+  let activePrompt;
 
   const interceptor = (_str, key) => {
     if (inTranslate || !key) return;
-    if (key.name === 'j') {
+    if (isQuitKey(key)) {
+      quitRequested = true;
+      activePrompt?.cancel();
+    } else if (key.name === 'j') {
       inTranslate = true;
       process.stdin.emit('keypress', undefined, {
         name: 'down',
@@ -416,7 +443,12 @@ async function withVimKeys(promptFn, options) {
   process.stdin.prependListener('keypress', interceptor);
 
   try {
-    return await promptFn(options);
+    activePrompt = promptFn(options);
+    return await activePrompt;
+  } catch (error) {
+    if (!quitRequested) throw error;
+    if (hasQuitValue) return quitValue;
+    throw new PromptQuitError();
   } finally {
     process.stdin.removeListener('keypress', interceptor);
   }
@@ -426,11 +458,32 @@ export async function vimSelect(options, reasoning) {
   if (reasoning) {
     return reasoningSelect({ ...options, reasoning });
   }
-  return withVimKeys(select, options);
+  const quitChoice = options.choices.find(
+    (choice) => typeof choice === 'object' && choice?.value === 'cancel' && !choice.disabled,
+  );
+  const promptOptions = options.instructions
+    ? options
+    : {
+        ...options,
+        instructions: {
+          navigation: '↑↓/j k navigate · Enter select · q quit',
+          pager: '↑↓/j k navigate · Enter select · q quit',
+        },
+      };
+  return withVimKeys(select, promptOptions, {
+    quitValue: quitChoice?.value,
+    hasQuitValue: Boolean(quitChoice),
+  });
 }
 
 export async function vimCheckbox(options) {
-  return withVimKeys(checkbox, options);
+  const promptOptions = options.instructions
+    ? options
+    : {
+        ...options,
+        instructions: '↑↓/j k navigate · Space select · Enter confirm · q quit',
+      };
+  return withVimKeys(checkbox, promptOptions);
 }
 
 export async function confirmAction(message, reasoning) {