@gitset-dev/cli 1.2.1 → 2.0.1

package/lib/commit-local.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Local, BYOAI commit-message generation.
+ *
+ * Runs entirely on the user's machine: reads the staged diff via git, builds
+ * the prompt through the vendored prompt boundary, and calls the user's own
+ * AI provider through the vendored lib/ai. No Gitset backend, no telemetry,
+ * the API key never leaves the process.
+ */
+const { execFileSync } = require('child_process');
+const { createProvider, AIError } = require('./ai');
+const promptPack = require('./prompts');
+const { loadTemplate } = require('./generate-local');
+
+function getStagedChanges(cwd = process.cwd()) {
+  const git = (args) =>
+    execFileSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).trim();
+  let diff = '';
+  let stat = '';
+  try {
+    diff = git(['diff', '--cached', '--no-color']);
+    stat = git(['diff', '--cached', '--shortstat']);
+  } catch (e) {
+    const err = new Error('Not a git repository, or git is unavailable.');
+    err.cause = e;
+    throw err;
+  }
+  return { diff, stat };
+}
+
+function parseMessage(raw) {
+  let m = String(raw || '').trim();
+
+  m = m.replace(/^```[a-z]*\n?/i, '').replace(/\n?```$/i, '').trim();
+  return m;
+}
+
+async function generateCommitMessage(opts) {
+  const { providerCfg, diff, stats = '', style = 'conventional', instruction = '', previous = '', signal } = opts;
+  if (!diff || !diff.trim()) {
+    const e = new Error('Nothing staged. `git add` your changes first.');
+    e.code = 'NO_STAGED_CHANGES';
+    throw e;
+  }
+
+  const provider = createProvider({
+    provider: providerCfg.provider === 'custom' ? 'openai' : providerCfg.provider,
+    apiKey: providerCfg.apiKey,
+    baseURL: providerCfg.baseUrl || undefined,
+    model: providerCfg.model || undefined,
+  });
+
+  const req = promptPack.toAIRequest('commit', {
+    diff, stats, style, instruction, previous, template: loadTemplate('commit'),
+  }, { temperature: 0.4, maxTokens: 1024, signal });
+
+  const result = await provider.generate(req);
+  return {
+    message: parseMessage(result.text),
+    provider: providerCfg.provider,
+    model: result.model,
+    usage: result.usage,
+  };
+}
+
+module.exports = { getStagedChanges, generateCommitMessage, parseMessage, AIError };

package/lib/config.js

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * Local BYOAI config for the CLI.
+ *
+ * Keys live ONLY on the user's machine in ~/.gitset/config.json (chmod 600).
+ * They are never sent to any Gitset server — the CLI calls the AI provider
+ * directly with the vendored lib/ai. Env vars override stored keys so users
+ * can avoid persisting secrets at all (CI-friendly).
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DIR = process.env.GITSET_CONFIG_DIR || path.join(os.homedir(), '.gitset');
+const FILE = path.join(DIR, 'config.json');
+
+const ENV_KEYS = {
+  anthropic: 'ANTHROPIC_API_KEY',
+  openai: 'OPENAI_API_KEY',
+  gemini: 'GEMINI_API_KEY',
+  openrouter: 'OPENROUTER_API_KEY',
+  deepseek: 'DEEPSEEK_API_KEY',
+};
+
+function readRaw() {
+  try {
+    return JSON.parse(fs.readFileSync(FILE, 'utf8'));
+  } catch {
+    return { defaultProvider: null, providers: {} };
+  }
+}
+
+function writeRaw(cfg) {
+  fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(FILE, JSON.stringify(cfg, null, 2), { mode: 0o600 });
+  try { fs.chmodSync(FILE, 0o600); } catch {  }
+}
+
+function setProvider(name, { apiKey, model, baseUrl, makeDefault } = {}) {
+  const provider = String(name || '').toLowerCase();
+  if (!provider) throw new Error('Provider name is required.');
+  const cfg = readRaw();
+  cfg.providers = cfg.providers || {};
+  const prev = cfg.providers[provider] || {};
+  cfg.providers[provider] = {
+    apiKey: apiKey !== undefined ? apiKey : prev.apiKey || null,
+    model: model !== undefined ? model : prev.model || null,
+    baseUrl: baseUrl !== undefined ? baseUrl : prev.baseUrl || null,
+  };
+  if (makeDefault || !cfg.defaultProvider) cfg.defaultProvider = provider;
+  writeRaw(cfg);
+  return cfg.providers[provider];
+}
+
+function removeProvider(name) {
+  const provider = String(name || '').toLowerCase();
+  const cfg = readRaw();
+  if (cfg.providers && cfg.providers[provider]) {
+    delete cfg.providers[provider];
+    if (cfg.defaultProvider === provider) {
+      cfg.defaultProvider = Object.keys(cfg.providers)[0] || null;
+    }
+    writeRaw(cfg);
+    return true;
+  }
+  return false;
+}
+
+function list() {
+  const cfg = readRaw();
+  return Object.entries(cfg.providers || {}).map(([name, p]) => ({
+    provider: name,
+    isDefault: cfg.defaultProvider === name,
+    keyLast4: p.apiKey ? String(p.apiKey).slice(-4) : (process.env[ENV_KEYS[name]] ? 'env' : null),
+    model: p.model || null,
+    baseUrl: p.baseUrl || null,
+  }));
+}
+
+function resolve(requested) {
+  const cfg = readRaw();
+  const provider = String(requested || cfg.defaultProvider || '').toLowerCase();
+  if (!provider) {
+    throw new Error('No AI provider configured. Run:  gitset config set <provider> --key <api-key>');
+  }
+  const stored = (cfg.providers && cfg.providers[provider]) || {};
+  const envKey = ENV_KEYS[provider] && process.env[ENV_KEYS[provider]];
+  const apiKey = envKey || stored.apiKey;
+  if (provider !== 'mock' && !apiKey) {
+    throw new Error(
+      `No API key for "${provider}". Set one:  gitset config set ${provider} --key <api-key>` +
+      (ENV_KEYS[provider] ? `  (or export ${ENV_KEYS[provider]})` : ''),
+    );
+  }
+  return {
+    provider,
+    apiKey: apiKey || null,
+    model: stored.model || null,
+    baseUrl: stored.baseUrl || null,
+  };
+}
+
+function getTheme() {
+  const cfg = readRaw();
+  return cfg.theme === 'light' || cfg.theme === 'dark' ? cfg.theme : null;
+}
+
+function setTheme(mode) {
+  if (mode !== 'dark' && mode !== 'light') throw new Error('Theme must be "dark" or "light".');
+  const cfg = readRaw();
+  cfg.theme = mode;
+  writeRaw(cfg);
+}
+
+// Resolves a provider, and — only when running interactively — offers the
+// quick-setup wizard instead of a bare error when nothing is configured yet.
+// Non-interactive callers (scripts, --yes, --json) always get the plain
+// error, never a prompt.
+async function ensureConfigured(requested, { interactive = false } = {}) {
+  try {
+    return resolve(requested);
+  } catch (e) {
+    if (!interactive) throw e;
+    const { runQuickSetup } = require('./setup-wizard');
+    const didSetUp = await runQuickSetup();
+    if (!didSetUp) throw e;
+    return resolve(requested);
+  }
+}
+
+module.exports = {
+  setProvider, removeProvider, list, resolve, ensureConfigured, getTheme, setTheme, FILE, DIR, ENV_KEYS,
+};

package/lib/generate-local.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Generic local BYOAI text generation for any Gitset tool (commit/issue/pr/
+ * readme/release/about). Runs on the user's machine with their own key via
+ * the vendored lib/ai + lib/prompts boundary — no backend, no telemetry.
+ *
+ * This is the shared engine the CLI commands route through (commit has its
+ * own thin wrapper in commit-local.js; everything else uses this).
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const config = require('./config');
+const { createProvider, AIError } = require('./ai');
+const promptPack = require('./prompts');
+
+function stripFences(raw) {
+  let m = String(raw || '').trim();
+  return m.replace(/^```[a-z]*\n?/i, '').replace(/\n?```$/i, '').trim();
+}
+
+function loadTemplate(tool) {
+  const dir = process.env.GITSET_CONFIG_DIR || path.join(os.homedir(), '.gitset');
+  try {
+    return fs.readFileSync(path.join(dir, 'templates', `${tool}.md`), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+async function generate(opts) {
+  const { tool, ctx = {}, provider: providerName, model, maxTokens = 4096, temperature = 0.4, signal, interactive = false } = opts;
+
+  if (!promptPack.listPrompts().includes(tool)) {
+    throw new Error(`Unknown tool "${tool}". One of: ${promptPack.listPrompts().join(', ')}`);
+  }
+
+  const cfg = await config.ensureConfigured(providerName, { interactive });
+  const provider = createProvider({
+    provider: cfg.provider === 'custom' ? 'openai' : cfg.provider,
+    apiKey: cfg.apiKey,
+    baseURL: cfg.baseUrl || undefined,
+    model: model || cfg.model || undefined,
+  });
+
+  const fullCtx = { ...ctx, template: ctx.template || loadTemplate(tool) };
+  const req = promptPack.toAIRequest(tool, fullCtx, { maxTokens, temperature, signal });
+  const result = await provider.generate(req);
+  return {
+    text: stripFences(result.text),
+    raw: result.text,
+    provider: cfg.provider,
+    model: result.model,
+    usage: result.usage,
+  };
+}
+
+module.exports = { generate, stripFences, loadTemplate, AIError };

package/lib/labels-ai.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * AI label suggestions for issues / PRs (BYOAI, local). Mirrors the web
+ * tools' label generator. Returns an array of {name,color,description}.
+ */
+const genLocal = require('./generate-local');
+
+function parseLabels(text) {
+  let t = String(text || '').trim().replace(/^```[a-z]*\n?/i, '').replace(/\n?```$/i, '');
+  const a = t.indexOf('['); const b = t.lastIndexOf(']');
+  if (a !== -1 && b !== -1) {
+    try {
+      const arr = JSON.parse(t.slice(a, b + 1));
+      if (Array.isArray(arr)) {
+        return arr
+          .filter((l) => l && l.name)
+          .map((l) => ({
+            name: String(l.name).trim(),
+            color: String(l.color || '').replace('#', '') || 'ededed',
+            description: String(l.description || '').slice(0, 100),
+          }));
+      }
+    } catch {  }
+  }
+  return [];
+}
+
+async function suggestLabels(opts = {}) {
+  const r = await genLocal.generate({
+    tool: 'labels',
+    ctx: { title: opts.title || '', body: opts.body || '', existing: opts.existing || '' },
+    provider: opts.provider,
+    model: opts.model,
+    maxTokens: 1024,
+    temperature: 0.3,
+  });
+  return parseLabels(r.raw || r.text);
+}
+
+module.exports = { suggestLabels, parseLabels, AIError: genLocal.AIError };

package/lib/prompts/defaults.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const clip = (s, n) => {
+  const str = String(s ?? '');
+  return str.length > n ? `${str.slice(0, n)}\n…(truncated)` : str;
+};
+
+const commit = {
+  id: 'commit',
+  build(ctx = {}) {
+    const { diff = '', stats = '', style = 'conventional', template = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You are a precise Git commit message author. Produce ONE commit message only, no prose, no code fences. ' +
+        `Follow the ${style} commits convention. Imperative mood, concise subject (<= 72 chars), ` +
+        'optional body explaining the why when the change is non-trivial.',
+      user: [
+        stats && `Change stats:\n${clip(stats, 2000)}`,
+        template && `Follow this commit template/style:\n${clip(template, 2000)}`,
+        `Staged diff:\n${clip(diff, 12000)}`,
+        previous && `Previous attempt to improve on:\n${clip(previous, 2000)}`,
+        instruction && `Extra instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+const issue = {
+  id: 'issue',
+  build(ctx = {}) {
+    const { title = '', context = '', template = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You write clear, actionable GitHub issues. Output GitHub-flavored Markdown only. ' +
+        'Include a short summary, concrete steps/acceptance criteria, and scope. No filler.',
+      user: [
+        title && `Topic: ${clip(title, 500)}`,
+        template && `Follow this template:\n${clip(template, 4000)}`,
+        context && `Repository context:\n${clip(context, 8000)}`,
+        previous && `Refine this previous version:\n${clip(previous, 6000)}`,
+        instruction && `Refinement instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+const pr = {
+  id: 'pr',
+  build(ctx = {}) {
+    const { diff = '', commits = '', template = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You write high-signal pull request descriptions in GitHub-flavored Markdown. ' +
+        'Sections: Summary, Changes, Testing. Be specific and concise; no boilerplate.',
+      user: [
+        template && `Follow this template:\n${clip(template, 4000)}`,
+        commits && `Commits:\n${clip(commits, 4000)}`,
+        diff && `Diff:\n${clip(diff, 12000)}`,
+        previous && `Refine this previous version:\n${clip(previous, 6000)}`,
+        instruction && `Refinement instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+const readme = {
+  id: 'readme',
+  build(ctx = {}) {
+    const { projectName = '', context = '', template = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You write professional README.md files in GitHub-flavored Markdown. ' +
+        'Accurate to the provided code context. Include title, description, install, usage. ' +
+        'Do not invent features that are not evidenced by the context.',
+      user: [
+        projectName && `Project: ${clip(projectName, 200)}`,
+        template && `Follow this structure:\n${clip(template, 4000)}`,
+        context && `Repository context:\n${clip(context, 16000)}`,
+        previous && `Refine this previous version:\n${clip(previous, 12000)}`,
+        instruction && `Refinement instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+const release = {
+  id: 'release',
+  build(ctx = {}) {
+    const { tag = '', commits = '', mode = 'summary', template = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You write release notes in GitHub-flavored Markdown. Group changes ' +
+        '(Features, Fixes, Other). User-facing language. No commit hashes in headings. ' +
+        'Output ONLY the release notes themselves — start directly with the content, ' +
+        'with NO preamble, NO sign-off, and NO conversational text such as ' +
+        '"Here\'s a summary" or "Here are the release notes". ' +
+        'When a template/style example is provided, follow its structure, section ' +
+        'headings, ordering, and tone closely — treat it as the format to reproduce.',
+      user: [
+        tag && `Release: ${clip(tag, 100)}`,
+        `Mode: ${mode}`,
+        template && `Reproduce the structure, sections, and tone of this template/example closely:\n${clip(template, 12000)}`,
+        commits && `Commits/diff:\n${clip(commits, 14000)}`,
+        previous && `Refine this previous version:\n${clip(previous, 8000)}`,
+        instruction && `Refinement instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+const about = {
+  id: 'about',
+  build(ctx = {}) {
+    const { context = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You generate a concise GitHub repository "About" description (<= 350 chars) ' +
+        'and up to 12 lowercase topic tags. Respond as JSON: {"description": string, "topics": string[]}.',
+      user: [
+        context && `Repository context:\n${clip(context, 12000)}`,
+        previous && `Improve on:\n${clip(previous, 2000)}`,
+        instruction && `Instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+const gitignore = {
+  id: 'gitignore',
+  build(ctx = {}) {
+    const { stack = '', context = '', instruction = '', previous = '' } = ctx;
+    return {
+      system:
+        'You generate the contents of a .gitignore file. Output ONLY the raw ' +
+        '.gitignore contents — no prose, no Markdown, no code fences. Group ' +
+        'entries under short "# Section" comments. Cover OS, editor, language/' +
+        'framework build artifacts, deps, env/secret files, and logs as relevant.',
+      user: [
+        stack && `Target stack / tools: ${clip(stack, 2000)}`,
+        context && `Repository signals:\n${clip(context, 6000)}`,
+        previous && `Improve on this existing .gitignore:\n${clip(previous, 6000)}`,
+        instruction && `Extra instruction: ${clip(instruction, 1000)}`,
+      ].filter(Boolean).join('\n\n') || 'Generate a sensible general-purpose .gitignore.',
+    };
+  },
+};
+
+const labels = {
+  id: 'labels',
+  build(ctx = {}) {
+    const { title = '', body = '', existing = '', instruction = '' } = ctx;
+    return {
+      system:
+        'You suggest GitHub labels for an issue or pull request. Respond with ' +
+        'ONLY a JSON array of objects: [{"name","color","description"}]. ' +
+        'name lowercase, 1-2 words (hyphenate if two, e.g. "bug", "good-first-issue"); ' +
+        'color a 6-char hex WITHOUT "#"; description under 80 chars. Suggest 1-4 ' +
+        'labels. Prefer names from the existing list when they fit. No prose, no fences.',
+      user: [
+        title && `Title: ${clip(title, 500)}`,
+        body && `Body:\n${clip(body, 4000)}`,
+        existing && `Existing repo labels (prefer these when fitting): ${clip(existing, 1500)}`,
+        instruction && `Instruction: ${clip(instruction, 500)}`,
+      ].filter(Boolean).join('\n\n') || 'Suggest sensible default labels.',
+    };
+  },
+};
+
+const labelDescriptions = {
+  id: 'labelDescriptions',
+  build(ctx = {}) {
+    const { labels = '', instruction = '' } = ctx;
+    return {
+      system:
+        'You are an expert technical writer for software projects. Rewrite or ' +
+        'generate concise descriptions for the given GitHub labels. Tone: ' +
+        'professional, technical, concise. Each description MUST be under 100 ' +
+        'characters. If a description already exists, rewrite it to read ' +
+        'differently while preserving its meaning; if none exists, infer a ' +
+        'logical one from the label name. Respond with ONLY valid JSON mapping ' +
+        'each label name to its description: {"label-name":"description"}. ' +
+        'No prose, no Markdown, no code fences.',
+      user: [
+        `Labels:\n${clip(labels, 6000)}`,
+        instruction && `Instruction: ${clip(instruction, 500)}`,
+      ].filter(Boolean).join('\n\n'),
+    };
+  },
+};
+
+module.exports = { commit, issue, pr, readme, release, about, gitignore, labels, labelDescriptions };

package/lib/prompts/index.js

@@ -0,0 +1,79 @@
+// VENDORED from gitset-core-v2/lib/prompts — do not edit here. Run `pnpm sync:ai`.
+'use strict';
+
+const defaults = require('./defaults');
+
+let _cache = null;
+
+function tryRequire(spec) {
+  try {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
+    return require(spec);
+  } catch (err) {
+    if (err && err.code === 'MODULE_NOT_FOUND') return null;
+
+    console.warn(`[prompts] overlay "${spec}" failed to load; using defaults. ${err.message}`);
+    return null;
+  }
+}
+
+function resolvePack() {
+  if (_cache) return _cache;
+
+  let overlay = null;
+  let source = 'defaults';
+
+  if (process.env.GITSET_PROMPT_PACK) {
+    overlay = tryRequire(process.env.GITSET_PROMPT_PACK);
+    if (overlay) source = `env:${process.env.GITSET_PROMPT_PACK}`;
+  }
+  if (!overlay) {
+    overlay = tryRequire('./private');
+    if (overlay) source = 'private';
+  }
+
+  const pack = { ...defaults };
+  if (overlay && typeof overlay === 'object') {
+    for (const [key, val] of Object.entries(overlay)) {
+      if (val && typeof val.build === 'function') pack[key] = val;
+    }
+  }
+
+  _cache = { pack, source, private: source !== 'defaults' };
+  return _cache;
+}
+
+function _reset() { _cache = null; }
+
+function isPrivatePackLoaded() { return resolvePack().private; }
+
+function packSource() { return resolvePack().source; }
+
+function listPrompts() { return Object.keys(resolvePack().pack); }
+
+function getPrompt(key, ctx = {}) {
+  const { pack } = resolvePack();
+  const entry = pack[key];
+  if (!entry || typeof entry.build !== 'function') {
+    throw new Error(`Unknown prompt "${key}". Available: ${Object.keys(pack).join(', ')}`);
+  }
+  const out = entry.build(ctx);
+  if (!out || typeof out.system !== 'string' || typeof out.user !== 'string') {
+    throw new Error(`Prompt "${key}" must return { system: string, user: string }`);
+  }
+  return out;
+}
+
+function toAIRequest(key, ctx = {}, extra = {}) {
+  const { system, user } = getPrompt(key, ctx);
+  return { system, messages: [{ role: 'user', content: user }], ...extra };
+}
+
+module.exports = {
+  getPrompt,
+  toAIRequest,
+  listPrompts,
+  isPrivatePackLoaded,
+  packSource,
+  _reset,
+};

package/lib/setup-wizard.js

@@ -0,0 +1,115 @@
+'use strict';
+
+/**
+ * Interactive BYOAI provider setup. Triggered by:
+ *   - `gitset config` with no providers configured yet
+ *   - `gitset config set` with no provider argument
+ *   - any AI command hitting "no provider configured" while running
+ *     interactively (never in scripts/--yes/--json — those keep the plain
+ *     error so they never block on a prompt)
+ *
+ * Returns true if a provider was saved, false if the user backed out.
+ */
+const { askQuestion, askSecret, selectOption } = require('../src/utils/ui');
+const theme = require('../src/utils/theme');
+const config = require('./config');
+const { PROVIDERS, SUPPORTED, isForbiddenModel } = require('./ai/capabilities');
+
+const CUSTOM_MODEL = '__custom_model__';
+
+async function pickModel(meta) {
+  const models = Array.isArray(meta.models) && meta.models.length ? meta.models : [meta.defaultModel];
+  const choices = models.map((m, i) => ({
+    label: i === 0 ? `${m}  ${theme.dim('(recommended)')}` : m,
+    value: m,
+  }));
+  choices.push({ label: 'Type a different model id', value: CUSTOM_MODEL });
+
+  const picked = await selectOption(`Model (default: ${meta.defaultModel}):`, choices);
+  if (picked !== CUSTOM_MODEL) return picked;
+
+  const typed = (await askQuestion('Model id: ')).trim();
+  return typed || meta.defaultModel;
+}
+
+async function runQuickSetup() {
+  if (!process.stdin.isTTY) return false;
+
+  console.log();
+  console.log(theme.bold("Let's connect your AI provider."));
+  console.log(theme.dim('Your key is stored only on this machine — it never touches a Gitset server.'));
+
+  const providerChoices = SUPPORTED.filter((p) => p !== 'mock').map((id) => ({
+    label: PROVIDERS[id].label,
+    value: id,
+  }));
+  providerChoices.push({ label: 'Custom (any OpenAI-compatible endpoint)', value: 'custom' });
+
+  let provider;
+  try {
+    provider = await selectOption('Pick your AI provider:', providerChoices);
+  } catch {
+    return false;
+  }
+
+  const meta = PROVIDERS[provider] || {};
+
+  let baseUrl;
+  if (provider === 'custom') {
+    baseUrl = (await askQuestion('Base URL (e.g. https://api.example.com/v1): ')).trim();
+    if (!baseUrl) {
+      console.log(theme.warn('A base URL is required for a custom provider. Setup cancelled.'));
+      return false;
+    }
+  }
+
+  const hint = meta.keyHint ? theme.dim(` (starts like ${meta.keyHint})`) : '';
+  let apiKey;
+  try {
+    apiKey = await askSecret(`Paste your ${meta.label || provider} API key${hint}: `);
+  } catch {
+    console.log(theme.warn('\nSetup cancelled.'));
+    return false;
+  }
+  if (!apiKey) {
+    console.log(theme.warn('No key entered — setup cancelled.'));
+    return false;
+  }
+
+  let model;
+  if (provider === 'custom') {
+    model = (await askQuestion('Model id for this endpoint: ')).trim();
+  } else {
+    model = await pickModel(meta);
+  }
+  if (isForbiddenModel(model)) {
+    console.log(theme.error(`"${model}" isn't available through Gitset — using ${meta.defaultModel} instead.`));
+    model = meta.defaultModel;
+  }
+
+  const existing = config.list();
+  let makeDefault = true;
+  if (existing.length > 0) {
+    const ans = (await askQuestion(`Make ${provider} your default provider? [Y/n] `)).trim().toLowerCase();
+    makeDefault = ans !== 'n';
+  }
+
+  config.setProvider(provider, { apiKey, model: model || undefined, baseUrl, makeDefault });
+
+  console.log();
+  console.log(
+    `${theme.success('✓')} ${provider} configured` +
+      (makeDefault ? ' (default)' : '') +
+      (model ? ` — model: ${theme.accent(model)}` : ''),
+  );
+  console.log(theme.dim(`Stored locally at ${config.FILE} (chmod 600).`));
+  console.log();
+  console.log(theme.dim('Try it now:'));
+  console.log(`  ${theme.accent('gitset commit')}    draft a commit message from staged changes`);
+  console.log(`  ${theme.accent('gitset init')}      scaffold editable templates for every tool`);
+  console.log();
+
+  return true;
+}
+
+module.exports = { runQuickSetup };