@hifullmoon/aicommit 2.3.0 → 2.4.0

package/schemas/aicommit-output.schema.json

@@ -19,9 +19,15 @@
     "error"
   ],
   "properties": {
-    "schemaVersion": { "const": "1.0" },
-    "ok": { "type": "boolean" },
-    "message": { "type": ["string", "null"] },
+    "schemaVersion": {
+      "const": "1.0"
+    },
+    "ok": {
+      "type": "boolean"
+    },
+    "message": {
+      "type": ["string", "null"]
+    },
     "plan": {
       "type": ["array", "null"],
       "items": {
@@ -29,8 +35,15 @@
         "additionalProperties": false,
         "required": ["message", "files"],
         "properties": {
-          "message": { "type": "string" },
-          "files": { "type": "array", "items": { "type": "string" } },
+          "message": {
+            "type": "string"
+          },
+          "files": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
           "hunks": {
             "type": "array",
             "items": {
@@ -38,29 +51,62 @@
               "additionalProperties": false,
               "required": ["path", "ids"],
               "properties": {
-                "path": { "type": "string" },
-                "ids": { "type": "array", "items": { "type": "string" } }
+                "path": {
+                  "type": "string"
+                },
+                "ids": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
               }
             }
           }
         }
       }
     },
-    "provider": { "type": ["string", "null"] },
-    "model": { "type": ["string", "null"] },
-    "latencyMs": { "type": ["number", "null"], "minimum": 0 },
+    "provider": {
+      "type": ["string", "null"]
+    },
+    "model": {
+      "type": ["string", "null"]
+    },
+    "latencyMs": {
+      "type": ["number", "null"],
+      "minimum": 0
+    },
     "usage": {
       "type": ["object", "null"],
       "additionalProperties": false,
       "properties": {
-        "inputTokens": { "type": "number", "minimum": 0 },
-        "outputTokens": { "type": "number", "minimum": 0 },
-        "totalTokens": { "type": "number", "minimum": 0 }
+        "inputTokens": {
+          "type": "number",
+          "minimum": 0
+        },
+        "outputTokens": {
+          "type": "number",
+          "minimum": 0
+        },
+        "totalTokens": {
+          "type": "number",
+          "minimum": 0
+        }
       }
     },
-    "warnings": { "type": "array", "items": { "type": "string" } },
-    "exitReason": { "type": "string", "minLength": 1 },
-    "committed": { "type": "boolean" },
+    "warnings": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "exitReason": {
+      "type": "string",
+      "minLength": 1
+    },
+    "committed": {
+      "type": "boolean"
+    },
     "error": {
       "type": ["object", "null"],
       "additionalProperties": false,
@@ -78,9 +124,65 @@
             "internal"
           ]
         },
-        "message": { "type": "string" }
+        "message": {
+          "type": "string"
+        }
       }
     },
-    "data": { "type": "object" }
+    "data": {
+      "type": "object",
+      "properties": {
+        "analysis": {
+          "type": "object",
+          "description": "Large-change coverage and shared request budget; never contains diff or intermediate summaries.",
+          "properties": {
+            "totalFiles": {
+              "type": "number",
+              "minimum": 0
+            },
+            "analyzedFiles": {
+              "type": "number",
+              "minimum": 0
+            },
+            "sampledFiles": {
+              "type": "number",
+              "minimum": 0,
+              "description": "Files represented by partial excerpts; not fully analyzed files."
+            },
+            "strategy": {
+              "enum": ["auto", "deep"]
+            },
+            "metadataOnlyFiles": {
+              "type": "number",
+              "minimum": 0
+            },
+            "failedFiles": {
+              "type": "number",
+              "minimum": 0
+            },
+            "completedChunks": {
+              "type": "number",
+              "minimum": 0
+            },
+            "requests": {
+              "type": "number",
+              "minimum": 0
+            },
+            "budgetedTokens": {
+              "type": "number",
+              "minimum": 0
+            },
+            "maxTotalTokens": {
+              "type": "number",
+              "minimum": 0
+            },
+            "elapsedMs": {
+              "type": "number",
+              "minimum": 0
+            }
+          }
+        }
+      }
+    }
   }
 }

package/src/analysis-budget.js

@@ -0,0 +1,76 @@
+import { ERROR_CATEGORIES, fail } from './errors.js';
+
+export const DEFAULT_LARGE_CHANGE = Object.freeze({
+  strategy: 'auto',
+  chunkInputTokens: 12000,
+  maxTotalTokens: 200000,
+  concurrency: 2,
+  timeoutMs: 180000,
+});
+
+export function estimateTokens(text) {
+  // Deliberately conservative fallback for providers without a tokenizer.
+  return Math.ceil(Buffer.byteLength(String(text), 'utf8') / 2);
+}
+
+export function createAnalysisBudget(settings = {}) {
+  const limits = { ...DEFAULT_LARGE_CHANGE, ...settings };
+  const started = Date.now();
+  let charged = 0;
+  let requests = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let reserveFinal = 0;
+  return {
+    limits,
+    signal: AbortSignal.timeout(limits.timeoutMs),
+    reserveFinal(tokens) {
+      reserveFinal = tokens;
+    },
+    remainingMs() {
+      return Math.max(0, limits.timeoutMs - (Date.now() - started));
+    },
+    snapshot() {
+      return {
+        requests,
+        budgetedTokens: charged,
+        maxTotalTokens: limits.maxTotalTokens,
+        elapsedMs: Date.now() - started,
+        usage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens },
+      };
+    },
+    reserve(input, output) {
+      if (
+        !this.remainingMs() ||
+        charged + input + output + reserveFinal > limits.maxTotalTokens ||
+        requests >= 256
+      ) {
+        throw fail(
+          ERROR_CATEGORIES.PROVIDER,
+          'Large-change analysis reached its token, request, or time budget. No incomplete plan will be committed. Increase the personal largeChange budget or stage a smaller change.',
+          { data: { analysis: this.snapshot() } },
+        );
+      }
+      if (input > limits.chunkInputTokens) {
+        throw fail(
+          ERROR_CATEGORIES.PROVIDER,
+          'Analysis request exceeds largeChange.chunkInputTokens; shorten repository context or increase the personal input budget.',
+        );
+      }
+      charged += input + output;
+      requests += 1;
+      inputTokens += input;
+      outputTokens += output;
+      return { input, output };
+    },
+    settle(ticket, usage) {
+      if (!ticket || !usage) return;
+      const actualInput = usage.inputTokens ?? ticket.input;
+      const actualOutput = usage.outputTokens ?? ticket.output;
+      charged +=
+        Math.max(usage.totalTokens || 0, actualInput + actualOutput) - ticket.input - ticket.output;
+      inputTokens += actualInput - ticket.input;
+      outputTokens += actualOutput - ticket.output;
+    },
+  };
+}

package/src/api.js

@@ -1,5 +1,7 @@
 import { cleanCommitMessage } from './utils.js';
 import { getProviderAdapter, normalizeUsage } from './providers.js';
+import { requestGeneration } from './model-client.js';
+export { requestGeneration } from './model-client.js';
 import { ERROR_CATEGORIES, fail } from './errors.js';
 import {
   buildCommitPolicyPrompt,
@@ -9,9 +11,6 @@ import {
 } from './policy.js';
 import { encodeUntrustedData } from './trust.js';
 
-// Default per-request timeout; overridable via the "timeoutMs" config key.
-const DEFAULT_TIMEOUT_MS = 120_000;
-
 export async function callAPI(
   apiUrl,
   apiKey,
@@ -41,294 +40,6 @@ export async function callAPI(
   return result.raw;
 }
 
-const DEFAULT_RETRY_POLICY = Object.freeze({
-  maxAttempts: 3,
-  baseDelayMs: 500,
-  maxDelayMs: 5000,
-});
-const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
-const RETRYABLE_NETWORK_CODES = new Set([
-  'ECONNRESET',
-  'ECONNREFUSED',
-  'EHOSTUNREACH',
-  'ENETUNREACH',
-  'EPIPE',
-  'UND_ERR_CONNECT_TIMEOUT',
-  'UND_ERR_SOCKET',
-]);
-
-function secureEndpoint(apiUrl) {
-  const endpoint = new URL(apiUrl);
-  const loopback =
-    endpoint.hostname === 'localhost' ||
-    endpoint.hostname === '127.0.0.1' ||
-    endpoint.hostname.startsWith('127.') ||
-    endpoint.hostname === '[::1]';
-  if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:' && loopback)) {
-    throw new Error(
-      'Refusing insecure API endpoint: use HTTPS, or HTTP only for localhost/loopback.',
-    );
-  }
-  return endpoint;
-}
-
-function retryPolicy(value = {}) {
-  return {
-    maxAttempts: value?.maxAttempts ?? DEFAULT_RETRY_POLICY.maxAttempts,
-    baseDelayMs: value?.baseDelayMs ?? DEFAULT_RETRY_POLICY.baseDelayMs,
-    maxDelayMs: value?.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs,
-    sleep:
-      value?.sleep ??
-      ((delayMs) =>
-        new Promise((resolve) => {
-          globalThis.setTimeout(resolve, delayMs);
-        })),
-    now: value?.now ?? (() => Date.now()),
-  };
-}
-
-function retryAfterMs(value, now) {
-  if (!value) return null;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
-  const date = Date.parse(value);
-  if (Number.isNaN(date)) return null;
-  return Math.max(0, date - now());
-}
-
-function networkFailure(err) {
-  if (err instanceof TypeError) return true;
-  return RETRYABLE_NETWORK_CODES.has(err?.code) || RETRYABLE_NETWORK_CODES.has(err?.cause?.code);
-}
-
-function timeoutError(err, timeout) {
-  if (err?.name !== 'TimeoutError' && err?.name !== 'AbortError') return null;
-  return new Error(
-    `Request timed out after ${Math.round(timeout / 1000)}s — the model took too long to respond. ` +
-      `Raise "timeoutMs" in your config if this keeps happening.`,
-  );
-}
-
-async function fetchWithRetry(apiUrl, init, timeout, configuredPolicy, consume) {
-  const policy = retryPolicy(configuredPolicy);
-  let attempt = 0;
-
-  while (attempt < policy.maxAttempts) {
-    attempt += 1;
-    let response;
-    try {
-      response = await fetch(apiUrl, {
-        ...init,
-        signal: AbortSignal.timeout(timeout),
-      });
-    } catch (err) {
-      const wrappedTimeout = timeoutError(err, timeout);
-      if (wrappedTimeout) throw wrappedTimeout;
-      if (!networkFailure(err) || attempt >= policy.maxAttempts) throw err;
-      const delay = Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
-      await policy.sleep(delay);
-      continue;
-    }
-
-    if (response.ok) {
-      try {
-        return { value: await consume(response), attempts: attempt };
-      } catch (err) {
-        const wrappedTimeout = timeoutError(err, timeout);
-        if (wrappedTimeout) throw wrappedTimeout;
-        // Once the provider has accepted a generation request, replaying it is
-        // unsafe: the first request may already have completed and been billed
-        // even though its response body was interrupted locally.
-        throw err;
-      }
-    }
-    if (RETRYABLE_STATUS.has(response.status) && attempt < policy.maxAttempts) {
-      const requestedDelay = retryAfterMs(response.headers.get('retry-after'), policy.now);
-      if (requestedDelay !== null && requestedDelay > policy.maxDelayMs) {
-        await response.body?.cancel().catch(() => {});
-        throw new Error(
-          `HTTP ${response.status}: provider requested a retry after ${Math.ceil(
-            requestedDelay / 1000,
-          )}s, exceeding the configured retry.maxDelayMs limit.`,
-        );
-      }
-      const delay =
-        requestedDelay ?? Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
-      await response.body?.cancel().catch(() => {});
-      await policy.sleep(delay);
-      continue;
-    }
-
-    const errText = await response.text();
-    throw new Error(`HTTP ${response.status}: ${errText.slice(0, 400)}`);
-  }
-
-  throw new Error('Provider request exhausted its retry budget.');
-}
-
-// Unified provider request contract. Provider adapters own request dialects
-// and response normalization; callers receive the same shape regardless of
-// whether the endpoint is OpenAI-compatible or native Ollama.
-export async function requestGeneration(config, request) {
-  secureEndpoint(config.apiUrl);
-  const timeout = config.timeoutMs || DEFAULT_TIMEOUT_MS;
-  const adapter = getProviderAdapter(config);
-  const payload = await adapter.buildRequest({
-    messages: request.messages,
-    temperature: request.temperature,
-    maxTokens: request.maxTokens,
-    extraBody: config.extraBody,
-    reasoning: request.reasoning ?? config.reasoning,
-    streaming: Boolean(request.stream?.onReasoningDelta),
-  });
-  const startedAt = performance.now();
-  const { value: consumed, attempts } = await fetchWithRetry(
-    config.apiUrl,
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
-        ...adapter.headers,
-      },
-      body: JSON.stringify(payload),
-    },
-    timeout,
-    config.retry,
-    async (response) => {
-      const contentType = response.headers.get('content-type') || '';
-      if (payload.stream && contentType.includes('text/event-stream')) {
-        return {
-          data: await consumeEventStream(response, request.stream.onReasoningDelta),
-          eventStream: true,
-        };
-      }
-      try {
-        return { data: await response.json(), eventStream: false };
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          throw fail(ERROR_CATEGORIES.RESPONSE_FORMAT, 'Provider returned invalid JSON.', {
-            cause: err,
-          });
-        }
-        throw err;
-      }
-    },
-  );
-
-  const { data, eventStream } = consumed;
-  const normalized = await adapter.normalizeResponse(data);
-  if (request.stream?.onReasoningDelta && !eventStream && normalized.reasoning) {
-    request.stream.onReasoningDelta(normalized.reasoning);
-  }
-  return {
-    ...normalized,
-    capabilities: adapter.capabilities,
-    attempts,
-    latencyMs: performance.now() - startedAt,
-  };
-}
-
-function streamContent(value) {
-  if (typeof value === 'string') return value;
-  if (Array.isArray(value)) {
-    return value
-      .map((part) => part?.text ?? part?.content ?? '')
-      .filter(Boolean)
-      .join('');
-  }
-  return value?.text ?? '';
-}
-
-// Consume OpenAI-compatible SSE (`data: {...}` / `data: [DONE]`) while
-// assembling a normal Chat Completions-shaped response for the existing
-// parsing and retry pipeline. Reasoning fields differ by provider, so every
-// delta goes through the same normalization used for non-stream responses.
-async function consumeEventStream(response, onReasoningDelta) {
-  if (!response.body) throw new Error('Streaming response did not include a body.');
-
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-  let dataLines = [];
-  let content = '';
-  let reasoning = '';
-  let usage = null;
-  let model = null;
-  let finishReason = null;
-  let completed = false;
-
-  const consumeData = (raw) => {
-    const payloadText = raw.trim();
-    if (!payloadText) return;
-    if (payloadText === '[DONE]') {
-      completed = true;
-      return;
-    }
-
-    let event;
-    try {
-      event = JSON.parse(payloadText);
-    } catch {
-      throw new Error(`Invalid JSON in streaming response: ${payloadText.slice(0, 200)}`);
-    }
-    if (event.error) {
-      const message = event.error.message || JSON.stringify(event.error);
-      throw new Error(`Streaming API error: ${message}`);
-    }
-
-    model ||= event.model || null;
-    if (event.usage) usage = event.usage;
-    const finishedChoice = event?.choices?.find((choice) => choice?.finish_reason != null);
-    if (finishedChoice) {
-      completed = true;
-      finishReason ||= finishedChoice.finish_reason;
-    }
-    const delta = event?.choices?.[0]?.delta ?? event?.choices?.[0]?.message;
-    if (!delta) return;
-
-    content += streamContent(delta.content);
-    const reasoningDelta = extractReasoning(delta);
-    if (reasoningDelta) {
-      reasoning += reasoningDelta;
-      onReasoningDelta(reasoningDelta);
-    }
-  };
-
-  const consumeLine = (line) => {
-    if (line === '') {
-      if (dataLines.length) consumeData(dataLines.join('\n'));
-      dataLines = [];
-      return;
-    }
-    if (line.startsWith('data:')) dataLines.push(line.slice(5).trimStart());
-  };
-
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split(/\r?\n/);
-    buffer = lines.pop() || '';
-    for (const line of lines) consumeLine(line);
-  }
-
-  buffer += decoder.decode();
-  if (buffer) consumeLine(buffer);
-  if (dataLines.length) consumeData(dataLines.join('\n'));
-
-  if (!completed) {
-    throw new Error(
-      'Streaming response ended before the provider sent [DONE] or a finish_reason. ' +
-        'The partial response was discarded; retry the request.',
-    );
-  }
-
-  const message = { content: content || null };
-  if (reasoning) message.reasoning_content = reasoning;
-  return { model, choices: [{ message, finish_reason: finishReason }], usage };
-}
-
 // Minimal "ping" request to verify the endpoint, API key, and model are all
 // reachable. Throws on HTTP errors (same as callAPI); returns latency, the
 // echoed model id, and a preview of the model's reply. Uses the same request
@@ -368,7 +79,10 @@ const MAX_REASONING_CHARS = 8000;
 // normal `stop` (or a provider omitting finish_reason) remains untouched.
 function hitTokenLimit(data) {
   const reason = data?.finishReason;
-  return typeof reason === 'string' && /^(?:length|max_tokens|max_output_tokens)$/i.test(reason);
+  return (
+    typeof reason === 'string' &&
+    /^(?:length|max_tokens|max_output_tokens|token_limit)$/i.test(reason)
+  );
 }
 
 // A formatting follow-up does not need to repeat reasoning that has already
@@ -397,30 +111,6 @@ function regeneratePrompt(previousMessage, policy) {
   ].join('\n');
 }
 
-// Normalize reasoning from the vendor-specific fields that can carry it:
-// OpenAI-style `reasoning_content` (DeepSeek), OpenRouter-style `reasoning`,
-// MiniMax/OpenRouter-style `reasoning_details` ([{ type: 'thinking', text }],
-// possibly multiple segments with interleaved thinking).
-function reasoningText(value) {
-  if (typeof value === 'string') return value;
-  if (Array.isArray(value)) {
-    return value.map(reasoningText).filter(Boolean).join('\n');
-  }
-  if (value && typeof value === 'object') {
-    return reasoningText(value.text ?? value.summary ?? value.content);
-  }
-  return '';
-}
-
-function extractReasoning(msg0) {
-  return (
-    reasoningText(msg0?.reasoning_content) ||
-    reasoningText(msg0?.reasoning) ||
-    reasoningText(msg0?.reasoning_details) ||
-    null
-  );
-}
-
 // Last-ditch extraction from raw reasoning text: prefer the first line that
 // carries a conventional-commit prefix, else fall back to the last non-empty
 // line.