@gitset-dev/cli 1.2.1 → 2.0.0

package/lib/ai/errors.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const CODES = Object.freeze({
+  AUTH: 'auth',
+  RATE_LIMIT: 'rate_limit',
+  CONTEXT_LENGTH: 'context_length',
+  TIMEOUT: 'timeout',
+  NETWORK: 'network',
+  BAD_REQUEST: 'bad_request',
+  PROVIDER_ERROR: 'provider_error',
+  UNSUPPORTED: 'unsupported',
+});
+
+const RETRYABLE = new Set([
+  CODES.RATE_LIMIT,
+  CODES.NETWORK,
+  CODES.TIMEOUT,
+  CODES.PROVIDER_ERROR,
+]);
+
+class AIError extends Error {
+
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = 'AIError';
+    this.code = code;
+    this.provider = opts.provider || null;
+    this.status = opts.status ?? null;
+    this.retryAfterMs = opts.retryAfterMs ?? null;
+
+    this.retryable = opts.retryable ?? RETRYABLE.has(code);
+    if (opts.cause !== undefined) this.cause = opts.cause;
+  }
+
+  toJSON() {
+    return {
+      error: true,
+      code: this.code,
+      message: this.message,
+      provider: this.provider,
+      retryable: this.retryable,
+    };
+  }
+}
+
+function normalizeError(err, provider) {
+  if (err instanceof AIError) return err;
+
+  const status = err?.status ?? err?.statusCode ?? err?.response?.status ?? null;
+  const sysCode = err?.code || err?.cause?.code || null;
+  const msg = String(err?.message || err || 'Unknown AI provider error');
+
+  if (err?.name === 'AbortError' || sysCode === 'ABORT_ERR') {
+    return new AIError(CODES.TIMEOUT, 'AI request timed out or was aborted.', { provider, cause: err });
+  }
+  if (['ENOTFOUND', 'ECONNRESET', 'ECONNREFUSED', 'EAI_AGAIN', 'UND_ERR_SOCKET'].includes(sysCode)) {
+    return new AIError(CODES.NETWORK, `Could not reach the ${provider} API.`, { provider, cause: err });
+  }
+  if (status === 401 || status === 403) {
+    const detail = upstreamDetail(err);
+    const base = `The ${provider} API key was rejected (HTTP ${status}). Check the key and model access.`;
+    return new AIError(CODES.AUTH, detail ? `${base} ${detail}` : base, { provider, status, cause: err });
+  }
+  if (status === 429) {
+    const retryAfterMs = parseRetryAfter(err);
+    const detail = upstreamDetail(err);
+
+    const hardLimit = /credit|billing|prepay|plan and billing|exceeded your current quota|quota.*(exhausted|depleted)|insufficient|payment/i.test(detail);
+    const message = detail
+      ? `${provider}: ${detail}`
+      : `Rate limited by ${provider}. This is your provider account's limit.`;
+    return new AIError(CODES.RATE_LIMIT, message, { provider, status, retryAfterMs, retryable: !hardLimit, cause: err });
+  }
+  if (status === 400 || status === 422) {
+    if (/context length|too long|maximum.*tokens|max_tokens|token limit/i.test(msg)) {
+      return new AIError(CODES.CONTEXT_LENGTH, 'The input is too large for this model\'s context window.', { provider, status, cause: err });
+    }
+    return new AIError(CODES.BAD_REQUEST, `${provider} rejected the request: ${msg}`, { provider, status, cause: err });
+  }
+  if (status === 408 || status === 504) {
+    return new AIError(CODES.TIMEOUT, `${provider} timed out.`, { provider, status, cause: err });
+  }
+  if (status != null && status >= 500) {
+
+    const detail = upstreamDetail(err);
+    const base = `${provider} is unavailable (HTTP ${status}).`;
+    return new AIError(CODES.PROVIDER_ERROR, detail ? `${base} ${detail}` : base, { provider, status, cause: err });
+  }
+
+  const detail = upstreamDetail(err);
+  return new AIError(CODES.PROVIDER_ERROR, `${provider} error: ${detail || msg}`, { provider, status, cause: err });
+}
+
+function upstreamDetail(err) {
+  const raw = String(err?.message || '').trim();
+  if (!raw) return '';
+  const brace = raw.indexOf('{');
+  if (brace !== -1) {
+    try {
+      const j = JSON.parse(raw.slice(brace));
+      const m = j?.error?.message || j?.message;
+      if (m) return String(m).trim().slice(0, 300);
+    } catch {  }
+  }
+  return raw.replace(/^got status:\s*\d*\s*/i, '').slice(0, 300);
+}
+
+function parseRetryAfter(err) {
+  const h = err?.headers?.get?.('retry-after') ?? err?.response?.headers?.['retry-after'];
+  if (!h) return null;
+  const secs = Number(h);
+  return Number.isFinite(secs) ? secs * 1000 : null;
+}
+
+module.exports = { AIError, CODES, normalizeError };

package/lib/ai/index.js

@@ -0,0 +1,98 @@
+// VENDORED from gitset-core-v2/lib/ai — do not edit here. Run `pnpm sync:ai`.
+'use strict';
+
+const { AIError, CODES, normalizeError } = require('./errors');
+const { withRetry } = require('./retry');
+const { PROVIDERS, SUPPORTED, FORBIDDEN_MODELS, isForbiddenModel, estimateTokens } = require('./capabilities');
+
+const ADAPTERS = {
+  anthropic: () => require('./providers/anthropic'),
+  openai: () => require('./providers/openai-compatible'),
+  openrouter: () => require('./providers/openai-compatible'),
+  deepseek: () => require('./providers/openai-compatible'),
+  gemini: () => require('./providers/gemini'),
+  mock: () => require('./providers/mock'),
+};
+
+function createProvider(cfg = {}) {
+  const provider = String(cfg.provider || '').toLowerCase();
+  const meta = PROVIDERS[provider];
+  if (!meta) {
+    throw new AIError(CODES.UNSUPPORTED, `Unknown provider "${cfg.provider}". Supported: ${SUPPORTED.join(', ')}.`, { provider });
+  }
+  if (provider !== 'mock' && !cfg.apiKey) {
+    throw new AIError(CODES.AUTH, `No API key supplied for ${meta.label}. Gitset is BYOAI — add your own key.`, { provider });
+  }
+
+  const model = cfg.model || meta.defaultModel;
+  if (isForbiddenModel(model)) {
+    throw new AIError(
+      CODES.UNSUPPORTED,
+      `Model "${model}" can't be used with Gitset. Pick another model for ${meta.label}.`,
+      { provider },
+    );
+  }
+  const baseURL = cfg.baseURL || meta.baseURL;
+  const timeoutMs = cfg.timeoutMs ?? 60_000;
+  const retry = cfg.retry || {};
+
+  const adapter = ADAPTERS[provider]().create({ apiKey: cfg.apiKey, model, baseURL, timeoutMs });
+
+  function preflight(request) {
+    if (!request || !Array.isArray(request.messages) || request.messages.length === 0) {
+      throw new AIError(CODES.BAD_REQUEST, 'request.messages must be a non-empty array.', { provider });
+    }
+    if (isForbiddenModel(request.model)) {
+      throw new AIError(
+        CODES.UNSUPPORTED,
+        `Model "${request.model}" can't be used with Gitset. Pick another model for ${meta.label}.`,
+        { provider },
+      );
+    }
+    const approx = estimateTokens(
+      (request.system || '') + request.messages.map((m) => m.content || '').join('\n'),
+    ) + (request.maxTokens || 0);
+    if (approx > meta.contextFloor * 1.5) {
+      throw new AIError(
+        CODES.CONTEXT_LENGTH,
+        `Input (~${approx} tokens) likely exceeds ${meta.label}'s context window.`,
+        { provider },
+      );
+    }
+  }
+
+  return {
+    provider,
+    model,
+    capabilities: {
+      streaming: meta.streaming,
+      jsonMode: meta.jsonMode,
+      maxContext: meta.contextFloor,
+      label: meta.label,
+    },
+
+    async generate(request) {
+      preflight(request);
+      return withRetry(() => adapter.generate(request), { provider, signal: request.signal, ...retry });
+    },
+
+    async *stream(request) {
+      preflight(request);
+      if (!meta.streaming) {
+        const r = await this.generate(request);
+        yield { done: true, text: r.text, usage: r.usage, finishReason: r.finishReason };
+        return;
+      }
+      try {
+        yield* adapter.stream(request);
+      } catch (err) {
+        throw normalizeError(err, provider);
+      }
+    },
+  };
+}
+
+module.exports = {
+  createProvider, AIError, CODES, PROVIDERS, SUPPORTED,
+  FORBIDDEN_MODELS, isForbiddenModel, estimateTokens,
+};

package/lib/ai/providers/anthropic.js

@@ -0,0 +1,62 @@
+'use strict';
+
+function create({ apiKey, model, timeoutMs = 60_000 }) {
+  let client;
+  function getClient() {
+    if (client) return client;
+    const Anthropic = require('@anthropic-ai/sdk');
+    client = new Anthropic({ apiKey, timeout: timeoutMs, maxRetries: 0 });
+    return client;
+  }
+
+  function buildParams(req) {
+    return {
+      model: req.model || model,
+      max_tokens: req.maxTokens ?? 4096,
+      temperature: req.temperature ?? 0.7,
+      ...(req.system ? { system: req.system } : {}),
+      messages: (req.messages || []).map((m) => ({
+        role: m.role === 'assistant' ? 'assistant' : 'user',
+        content: m.content,
+      })),
+    };
+  }
+
+  return {
+    name: 'anthropic',
+
+    async generate(req) {
+      const msg = await getClient().messages.create(buildParams(req), { signal: req.signal });
+      const text = (msg.content || [])
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text)
+        .join('');
+      return {
+        text,
+        usage: { inputTokens: msg.usage?.input_tokens ?? 0, outputTokens: msg.usage?.output_tokens ?? 0 },
+        model: msg.model,
+        finishReason: msg.stop_reason || 'stop',
+        raw: msg,
+      };
+    },
+
+    async *stream(req) {
+      const s = getClient().messages.stream(buildParams(req), { signal: req.signal });
+      for await (const event of s) {
+        if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+          yield { delta: event.delta.text };
+        }
+      }
+      const final = await s.finalMessage();
+      const text = (final.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('');
+      yield {
+        done: true,
+        text,
+        usage: { inputTokens: final.usage?.input_tokens ?? 0, outputTokens: final.usage?.output_tokens ?? 0 },
+        finishReason: final.stop_reason || 'stop',
+      };
+    },
+  };
+}
+
+module.exports = { create };

package/lib/ai/providers/gemini.js

@@ -0,0 +1,77 @@
+'use strict';
+
+function create({ apiKey, model, timeoutMs = 60_000 }) {
+  let ai;
+  function getClient() {
+    if (ai) return ai;
+    const { GoogleGenAI } = require('@google/genai');
+    ai = new GoogleGenAI({ apiKey });
+    return ai;
+  }
+
+  function toContents(req) {
+    return (req.messages || []).map((m) => ({
+      role: m.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: m.content }],
+    }));
+  }
+
+  function buildConfig(req) {
+    const cfg = {
+      temperature: req.temperature ?? 0.7,
+      ...(req.maxTokens ? { maxOutputTokens: req.maxTokens } : {}),
+      ...(req.system ? { systemInstruction: req.system } : {}),
+    };
+    const ac = req.signal ? { abortSignal: req.signal } : {};
+    return { config: cfg, http: { ...ac, timeout: timeoutMs } };
+  }
+
+  return {
+    name: 'gemini',
+
+    async generate(req) {
+      const { config, http } = buildConfig(req);
+      const resp = await getClient().models.generateContent({
+        model: req.model || model,
+        contents: toContents(req),
+        config,
+        httpOptions: http,
+      });
+      const u = resp.usageMetadata || {};
+      return {
+        text: resp.text || '',
+        usage: { inputTokens: u.promptTokenCount ?? 0, outputTokens: u.candidatesTokenCount ?? 0 },
+        model: req.model || model,
+        finishReason: resp.candidates?.[0]?.finishReason || 'stop',
+        raw: resp,
+      };
+    },
+
+    async *stream(req) {
+      const { config, http } = buildConfig(req);
+      const s = await getClient().models.generateContentStream({
+        model: req.model || model,
+        contents: toContents(req),
+        config,
+        httpOptions: http,
+      });
+      let text = '';
+      let usage = { inputTokens: 0, outputTokens: 0 };
+      let finishReason = 'stop';
+      for await (const chunk of s) {
+        if (chunk.text) { text += chunk.text; yield { delta: chunk.text }; }
+        if (chunk.usageMetadata) {
+          usage = {
+            inputTokens: chunk.usageMetadata.promptTokenCount ?? 0,
+            outputTokens: chunk.usageMetadata.candidatesTokenCount ?? 0,
+          };
+        }
+        const fr = chunk.candidates?.[0]?.finishReason;
+        if (fr) finishReason = fr;
+      }
+      yield { done: true, text, usage, finishReason };
+    },
+  };
+}
+
+module.exports = { create };

package/lib/ai/providers/mock.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { estimateTokens } = require('../capabilities');
+
+function create({ model = 'mock-1' } = {}) {
+  function answer(req) {
+    const last = [...(req.messages || [])].reverse().find((m) => m.role !== 'assistant');
+    const seed = (last?.content || '').trim();
+    return `[mock:${model}] ${seed ? seed.slice(0, 280) : 'no input'}`;
+  }
+
+  return {
+    name: 'mock',
+
+    async generate(req) {
+      if (req.signal?.aborted) throw new Error('aborted');
+      const text = answer(req);
+      const inputTokens = estimateTokens((req.system || '') + JSON.stringify(req.messages || []));
+      return {
+        text,
+        usage: { inputTokens, outputTokens: estimateTokens(text) },
+        model,
+        finishReason: 'stop',
+        raw: { mock: true },
+      };
+    },
+
+    async *stream(req) {
+      const text = answer(req);
+      for (const word of text.split(' ')) yield { delta: word + ' ' };
+      yield {
+        done: true,
+        text,
+        usage: { inputTokens: estimateTokens(JSON.stringify(req.messages || [])), outputTokens: estimateTokens(text) },
+        finishReason: 'stop',
+      };
+    },
+  };
+}
+
+module.exports = { create };

package/lib/ai/providers/openai-compatible.js

@@ -0,0 +1,72 @@
+'use strict';
+
+function create({ apiKey, model, baseURL, timeoutMs = 60_000 }) {
+  let client;
+  function getClient() {
+    if (client) return client;
+    const OpenAI = require('openai');
+    client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}), timeout: timeoutMs, maxRetries: 0 });
+    return client;
+  }
+
+  function buildMessages(req) {
+    const msgs = [];
+    if (req.system) msgs.push({ role: 'system', content: req.system });
+    for (const m of req.messages || []) {
+      msgs.push({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content });
+    }
+    return msgs;
+  }
+
+  function baseParams(req) {
+    return {
+      model: req.model || model,
+      messages: buildMessages(req),
+      temperature: req.temperature ?? 0.7,
+      ...(req.maxTokens ? { max_tokens: req.maxTokens } : {}),
+    };
+  }
+
+  return {
+    name: 'openai-compatible',
+
+    async generate(req) {
+      const r = await getClient().chat.completions.create(
+        baseParams(req),
+        { signal: req.signal },
+      );
+      const choice = r.choices?.[0];
+      return {
+        text: choice?.message?.content || '',
+        usage: {
+          inputTokens: r.usage?.prompt_tokens ?? 0,
+          outputTokens: r.usage?.completion_tokens ?? 0,
+        },
+        model: r.model,
+        finishReason: choice?.finish_reason || 'stop',
+        raw: r,
+      };
+    },
+
+    async *stream(req) {
+      const s = await getClient().chat.completions.create(
+        { ...baseParams(req), stream: true, stream_options: { include_usage: true } },
+        { signal: req.signal },
+      );
+      let text = '';
+      let usage = { inputTokens: 0, outputTokens: 0 };
+      let finishReason = 'stop';
+      for await (const part of s) {
+        const d = part.choices?.[0]?.delta?.content;
+        if (d) { text += d; yield { delta: d }; }
+        if (part.choices?.[0]?.finish_reason) finishReason = part.choices[0].finish_reason;
+        if (part.usage) {
+          usage = { inputTokens: part.usage.prompt_tokens ?? 0, outputTokens: part.usage.completion_tokens ?? 0 };
+        }
+      }
+      yield { done: true, text, usage, finishReason };
+    },
+  };
+}
+
+module.exports = { create };

package/lib/ai/retry.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { normalizeError } = require('./errors');
+
+async function withRetry(fn, opts = {}) {
+  const { provider, retries = 3, baseDelayMs = 500, maxDelayMs = 8000, signal } = opts;
+  let attempt = 0;
+  for (;;) {
+    try {
+      return await fn();
+    } catch (raw) {
+      const err = normalizeError(raw, provider);
+      if (!err.retryable || attempt >= retries) throw err;
+      const backoff = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+      const jitter = Math.random() * backoff * 0.25;
+      const delay = err.retryAfterMs != null ? err.retryAfterMs : backoff + jitter;
+      attempt += 1;
+      await sleep(delay, signal);
+    }
+  }
+}
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new Error('aborted'));
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => { clearTimeout(t); reject(new Error('aborted')); }, { once: true });
+  });
+}
+
+module.exports = { withRetry };

package/lib/cli-commit.js

@@ -0,0 +1,143 @@
+'use strict';
+
+/**
+ * `gitset commit` — local, BYOAI commit-message generation with iterative
+ * refinement. No backend, key never leaves the machine.
+ *
+ * Flags:
+ *   --provider <name>   override default provider for this run
+ *   --model <name>      override model
+ *   --style <name>      commit style (default: conventional)
+ *   --all, -a           `git add -A` before generating
+ *   --yes, -y           non-interactive: accept first message and commit
+ *   --json              machine output ({message,provider,model}); implies -y-less (no commit)
+ *   --print             print the message only; do not commit
+ *
+ * Exit codes: 0 ok · 1 usage/git error · 2 AI provider error.
+ */
+const { execFileSync, spawnSync } = require('child_process');
+const readline = require('readline');
+const config = require('./config');
+const { getStagedChanges, generateCommitMessage, AIError } = require('./commit-local');
+const theme = require('../src/utils/theme');
+
+const out = (s = '') => console.log(s);
+const errln = (s) => console.error(`${theme.error('✗')} ${s}`);
+
+function getFlag(argv, name) {
+  const i = argv.indexOf(name);
+  return i !== -1 && i + 1 < argv.length && !argv[i + 1].startsWith('-') ? argv[i + 1] : null;
+}
+const hasFlag = (argv, ...names) => names.some((n) => argv.includes(n));
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => rl.question(question, (a) => { rl.close(); resolve(a.trim()); }));
+}
+
+async function runCommitCommand(argv) {
+  const json = hasFlag(argv, '--json');
+  const printOnly = hasFlag(argv, '--print');
+  const nonInteractive = hasFlag(argv, '--yes', '-y') || json || printOnly || !process.stdin.isTTY;
+
+  let providerCfg;
+  try {
+    providerCfg = await config.ensureConfigured(getFlag(argv, '--provider'), { interactive: !nonInteractive });
+  } catch (e) {
+    errln(e.message);
+    return 1;
+  }
+
+  if (hasFlag(argv, '--all', '-a')) {
+    try {
+      execFileSync('git', ['add', '-A'], { stdio: 'ignore' });
+    } catch {
+      errln('`git add -A` failed — is this a git repository?');
+      return 1;
+    }
+  }
+
+  let changes;
+  try {
+    changes = getStagedChanges();
+  } catch (e) {
+    errln(e.message);
+    return 1;
+  }
+  if (!changes.diff.trim()) {
+    errln('Nothing staged. Stage changes with `git add` (or pass --all).');
+    return 1;
+  }
+
+  const style = getFlag(argv, '--style') || 'conventional';
+  const model = getFlag(argv, '--model');
+  const baseCfg = model ? { ...providerCfg, model } : providerCfg;
+
+  async function gen(previous, instruction) {
+    try {
+      if (!json && !printOnly) process.stderr.write(theme.dim(`… generating via ${providerCfg.provider} (${baseCfg.model || 'default model'})\n`));
+      return await generateCommitMessage({
+        providerCfg: baseCfg, diff: changes.diff, stats: changes.stat, style, previous, instruction,
+      });
+    } catch (e) {
+      if (e instanceof AIError) { errln(`AI provider error (${e.code}): ${e.message}`); throw { exit: 2 }; }
+      if (e.code === 'NO_STAGED_CHANGES') { errln(e.message); throw { exit: 1 }; }
+      errln(e.message || 'Generation failed'); throw { exit: 2 };
+    }
+  }
+
+  let result;
+  try {
+    result = await gen();
+  } catch (e) {
+    return e.exit || 2;
+  }
+
+  if (json) {
+    out(JSON.stringify({ message: result.message, provider: result.provider, model: result.model }));
+    return 0;
+  }
+  if (printOnly) { out(result.message); return 0; }
+
+  function doCommit(message) {
+    const r = spawnSync('git', ['commit', '-m', message], { stdio: 'inherit' });
+    return r.status === 0 ? 0 : 1;
+  }
+
+  if (nonInteractive) {
+    out(result.message);
+    return doCommit(result.message);
+  }
+
+  for (;;) {
+    out();
+    out(theme.bold('Proposed commit message:'));
+    out(theme.accent(result.message.split('\n').map((l) => `  ${l}`).join('\n')));
+    out();
+    out(theme.dim('tip: edit ~/.gitset/templates/commit.md (or run `gitset template edit commit`) to change the style'));
+    const choice = (await ask(
+      `${theme.key('a', 'ccept')}  ${theme.key('r', 'efine')}  ${theme.key('g', 'regenerate')}  ${theme.key('e', 'dit')}  ${theme.key('q', 'uit')} > `,
+    )).toLowerCase();
+
+    if (choice === 'a' || choice === '') return doCommit(result.message);
+    if (choice === 'q') { out('Aborted. Nothing committed.'); return 0; }
+    if (choice === 'e') {
+      const edited = await ask('New message: ');
+      if (edited) return doCommit(edited);
+      continue;
+    }
+    if (choice === 'g') {
+      try { result = await gen(); } catch (e) { return e.exit || 2; }
+      continue;
+    }
+    if (choice === 'r') {
+      const instruction = await ask('Refinement instruction: ');
+      if (!instruction) continue;
+      try { result = await gen(result.message, instruction); } catch (e) { return e.exit || 2; }
+      continue;
+    }
+    out(theme.warn('Unrecognized option.'));
+  }
+}
+
+module.exports = { runCommitCommand };