@hifullmoon/aicommit 2.2.3 → 2.4.0

package/src/config.js

@@ -1,4 +1,5 @@
 import { readFile, chmod } from 'node:fs/promises';
+import { DEFAULT_LARGE_CHANGE } from './analysis-budget.js';
 import { execSync } from 'node:child_process';
 
 import chalk from 'chalk';
@@ -148,6 +149,7 @@ export const DEFAULT_CONFIG = {
   // condensed to a `git diff --stat` summary plus truncated hunks, so a huge
   // change set doesn't burn tokens on lines the model doesn't need.
   maxDiffChars: 30000,
+  largeChange: DEFAULT_LARGE_CHANGE,
   // Cap on a single file's diff section. One huge file (e.g. a new generated
   // asset) is truncated to its header and leading hunks instead of eating
   // the whole maxDiffChars budget and pushing every other file out.
@@ -434,6 +436,20 @@ function assertNumber(config, key, { integer = false, min = -Infinity, max = Inf
 }
 
 export function validateConfig(config) {
+  if (config.largeChange !== undefined) {
+    const value = config.largeChange;
+    if (!object(value)) throw new Error('Invalid config "largeChange": expected an object.');
+    assertKnownKeys(value, new Set(Object.keys(DEFAULT_LARGE_CHANGE)), 'largeChange');
+    const settings = { ...DEFAULT_LARGE_CHANGE, ...value };
+    if (!['auto', 'deep'].includes(settings.strategy))
+      throw new Error('Invalid config "largeChange.strategy": expected auto or deep.');
+    for (const key of ['chunkInputTokens', 'maxTotalTokens', 'timeoutMs']) {
+      assertNumber(settings, key, { integer: true, min: 1024 });
+    }
+    assertNumber(settings, 'concurrency', { integer: true, min: 1, max: 4 });
+    if (settings.maxTotalTokens < settings.chunkInputTokens)
+      throw new Error('largeChange.maxTotalTokens must cover one input request.');
+  }
   assertUrl(config, 'apiUrl');
   assertString(config, 'modelId');
   if (typeof config.prompt !== 'string' || config.prompt.length > 100_000) {

package/src/doctor.js

@@ -8,9 +8,7 @@ import { classifyError, ERROR_CATEGORIES, fail } from './errors.js';
 import { getProviderAdapter } from './providers.js';
 import { formatMs, formatUsage, redactSensitiveUrl, sanitizeTerminalText } from './utils.js';
 
-function nodeSupported(version = process.versions.node) {
-  return Number(version.split('.')[0]) >= 18;
-}
+import { nodeSupported, MIN_NODE_VERSION } from './runtime.js';
 
 function renderCheck(check) {
   const icon = check.status === 'pass' ? chalk.green('✓') : check.status === 'warn' ? '⚠' : '✗';
@@ -43,7 +41,7 @@ export async function runDoctor(cliProvider = null, cliModel = null) {
     checks,
     'Node.js',
     nodeSupported(nodeVersion) ? 'pass' : 'fail',
-    `v${nodeVersion}${nodeSupported(nodeVersion) ? ' (supported)' : ' (requires >=18)'}`,
+    `v${nodeVersion}${nodeSupported(nodeVersion) ? ' (supported)' : ` (requires >=${MIN_NODE_VERSION})`}`,
   );
 
   try {

package/src/git-spool.js

@@ -0,0 +1,108 @@
+import { execFileSync } from 'node:child_process';
+import { closeSync, fstatSync, mkdtempSync, openSync, readSync, rmSync, writeSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const active = new Set();
+export function cleanupGitSpools() {
+  for (const source of active) source.dispose();
+}
+process.once('exit', cleanupGitSpools);
+
+// Git writes directly to a private temporary file, never to a Node stdout
+// buffer. Consumers scan the captured bytes without reopening the worktree.
+export function spoolGit(commands, cwd) {
+  const dir = mkdtempSync(join(tmpdir(), 'aicommit-diff-'));
+  const path = join(dir, 'patch');
+  let fd;
+  try {
+    fd = openSync(path, 'wx+', 0o600);
+    for (const args of commands) {
+      execFileSync('git', ['--no-pager', ...args], {
+        cwd,
+        stdio: ['ignore', fd, 'pipe'],
+        timeout: 120000,
+        maxBuffer: 1024 * 1024,
+      });
+    }
+    let size = fstatSync(fd).size;
+    closeSync(fd);
+    fd = undefined;
+    const source = {
+      get size() {
+        return size;
+      },
+      append(buffer) {
+        const output = openSync(path, 'r+');
+        try {
+          let written = 0;
+          while (written < buffer.length)
+            written += writeSync(output, buffer, written, buffer.length - written, size + written);
+          size += written;
+        } finally {
+          closeSync(output);
+        }
+      },
+      *buffers() {
+        const input = openSync(path, 'r');
+        const buffer = Buffer.alloc(64 * 1024);
+        let offset = 0;
+        try {
+          while (offset < size) {
+            const count = readSync(input, buffer, 0, buffer.length, offset);
+            if (!count) throw new Error('Captured Git patch was truncated.');
+            offset += count;
+            yield buffer.subarray(0, count);
+          }
+        } finally {
+          closeSync(input);
+        }
+      },
+      *lines(maxLineBytes = 1024 * 1024) {
+        let pending = Buffer.alloc(0);
+        for (const buffer of this.buffers()) {
+          const data = Buffer.concat([pending, buffer]);
+          let start = 0;
+          for (let end = data.indexOf(10); end !== -1; end = data.indexOf(10, start)) {
+            if (end - start > maxLineBytes)
+              throw new Error(
+                'Diff line exceeds the safe analysis limit (1 MiB); split the change before retrying.',
+              );
+            yield data.subarray(start, end + 1).toString('utf8');
+            start = end + 1;
+          }
+          pending = Buffer.from(data.subarray(start));
+          if (pending.length > maxLineBytes)
+            throw new Error(
+              'Diff line exceeds the safe analysis limit (1 MiB); split the change before retrying.',
+            );
+        }
+        if (pending.length) yield pending.toString('utf8');
+      },
+      text(limit) {
+        if (size > limit) return null;
+        return [...this.lines()].join('').trim();
+      },
+      dispose() {
+        if (!active.delete(source)) return;
+        rmSync(dir, { recursive: true, force: true });
+      },
+    };
+    active.add(source);
+    return source;
+  } catch (err) {
+    if (fd !== undefined) closeSync(fd);
+    rmSync(dir, { recursive: true, force: true });
+    throw new Error(`Failed to capture Git patch: ${err.message}`, { cause: err });
+  }
+}
+
+export function updateGitHash(hash, args, cwd) {
+  const source = spoolGit([args], cwd);
+  try {
+    for (const buffer of source.buffers()) hash.update(buffer);
+  } finally {
+    source.dispose();
+  }
+  return hash;
+}

package/src/git.js

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync
 import { createHash } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { updateGitHash } from './git-spool.js';
 
 // Big repos can produce multi-MB diffs; raise the default 1MB child-process
 // buffer and surface a contextual error if the explicit limit is exceeded.
@@ -73,8 +74,11 @@ export function getStagedDiff(cwd, contextLines) {
 // ids) so a long-running AI/review step cannot silently commit a different
 // index from the one used to generate the message.
 export function getIndexFingerprint(cwd) {
-  const patch = readGit(['diff', '--staged', '--binary', '--full-index', '--no-ext-diff'], cwd);
-  return createHash('sha256').update(patch).digest('hex');
+  return updateGitHash(
+    createHash('sha256'),
+    ['diff', '--staged', '--binary', '--full-index', '--no-ext-diff'],
+    cwd,
+  ).digest('hex');
 }
 
 function hashFileOrMissing(path) {
@@ -428,7 +432,7 @@ export function protectSensitiveDiff(diff) {
   return { diff: out.join(''), findings: [...new Set(findings)] };
 }
 
-export function runGit(args, projectRoot, inherit = false) {
+export function runGit(args, projectRoot, inherit = false, input = undefined) {
   try {
     const stdio =
       inherit === 'stderr'
@@ -436,7 +440,7 @@ export function runGit(args, projectRoot, inherit = false) {
         : inherit
           ? 'inherit'
           : 'pipe';
-    execFileSync('git', args, { cwd: projectRoot, stdio });
+    execFileSync('git', args, { cwd: projectRoot, stdio, input });
   } catch (err) {
     const detail =
       typeof err.stderr === 'string' ? err.stderr.trim() : err.stderr?.toString('utf-8').trim();
@@ -445,6 +449,23 @@ export function runGit(args, projectRoot, inherit = false) {
   }
 }
 
+export function pathBatches(paths, limit = 6000) {
+  const batches = [];
+  let batch = [];
+  let size = 0;
+  for (const path of paths) {
+    if (batch.length && size + path.length * 2 + 4 > limit) {
+      batches.push(batch);
+      batch = [];
+      size = 0;
+    }
+    batch.push(path);
+    size += path.length * 2 + 4;
+  }
+  if (batch.length) batches.push(batch);
+  return batches;
+}
+
 export function hasHead(projectRoot) {
   try {
     execFileSync('git', ['rev-parse', '--verify', 'HEAD'], {

package/src/local-analysis.js

@@ -0,0 +1,271 @@
+import { createHash } from 'node:crypto';
+import { isLockFile, matchStripPattern } from './git.js';
+import { ERROR_CATEGORIES, fail } from './errors.js';
+
+// These are evidence-selection rules, not exclusions from Git or secret scans.
+export function isGeneratedFile(path) {
+  return (
+    /(?:^|\/)(?:dist|build|coverage|vendor|node_modules)\//.test(path) ||
+    /(?:\.min\.(?:js|css)|\.map|\.snap|\.generated\.[^/]+)$/.test(path)
+  );
+}
+
+export function isDeepAnalysis(config) {
+  return config.largeChange?.strategy === 'deep';
+}
+
+function clip(text, bytes) {
+  if (Buffer.byteLength(text) <= bytes) return text;
+  let result = '';
+  let size = 0;
+  for (const char of text) {
+    size += Buffer.byteLength(char);
+    if (size > Math.max(0, bytes - 3)) break;
+    result += char;
+  }
+  return result + '…';
+}
+
+function category(file, config) {
+  if (isLockFile(file.path)) return 'lockfile';
+  if (matchStripPattern(file.path, config.stripFiles)) return 'excluded';
+  if (isGeneratedFile(file.path)) return 'generated';
+  if (/(?:^|\/)(?:test|tests|__tests__)\/|\.(?:test|spec)\./.test(file.path)) return 'test';
+  if (/\.(?:md|rst|txt)$/.test(file.path)) return 'documentation';
+  if (/(?:^|\/)(?:[^/]*config[^/]*|package\.json)$|\.(?:ya?ml|toml)$/.test(file.path))
+    return 'configuration';
+  return 'source';
+}
+
+function moduleOf(path) {
+  const parts = path.split('/');
+  return parts.length === 1 ? '.' : parts.slice(0, Math.min(parts.length - 1, 2)).join('/');
+}
+
+export function localInputBytes(config) {
+  // UTF-8 bytes also bound non-ASCII input. Leave space for JSON escaping,
+  // repository context, policy, and the provider's message envelope.
+  return Math.max(
+    256,
+    Math.min(
+      config.maxDiffChars || 30000,
+      Math.floor((config.analysisBudget?.limits.chunkInputTokens || 12000) * 0.6),
+    ),
+  );
+}
+
+function summaryOf(fact, evidence = true) {
+  return {
+    id: fact.id,
+    kind: fact.kind,
+    status: fact.status,
+    module: clip(fact.module, 160),
+    fileCount: fact.files.length,
+    additions: fact.additions,
+    deletions: fact.deletions,
+    ...(fact.modeChange ? { modeChange: fact.modeChange } : {}),
+    ...(fact.binary ? { binary: true } : {}),
+    examples: fact.files.slice(0, 2).map((path) => clip(path, 180)),
+    ...(evidence && fact.evidence ? { representativeExcerpt: fact.evidence } : {}),
+  };
+}
+
+const SAMPLE_NOTICE =
+  'Local change inventory with selected excerpts, not complete semantic analysis. ' +
+  'Counts cover every file. Excerpts are partial; omitted content and paths are not evidence of unchanged behavior. ' +
+  'Identical textual edits are grouped within a module. Describe supported changes conservatively; do not infer intent.';
+
+function ranked(facts) {
+  const priority = { source: 0, configuration: 1, test: 2, documentation: 3 };
+  return [...facts].sort(
+    (a, b) =>
+      (priority[a.kind] ?? 4) - (priority[b.kind] ?? 4) ||
+      b.files.length - a.files.length ||
+      a.id.localeCompare(b.id),
+  );
+}
+
+export function localOverview(config, facts) {
+  const kinds = {};
+  const statuses = {};
+  let totalFiles = 0;
+  let additions = 0;
+  let deletions = 0;
+  let modeChangedFiles = 0;
+  let binaryFiles = 0;
+  for (const fact of facts) {
+    totalFiles += fact.files.length;
+    additions += fact.additions;
+    deletions += fact.deletions;
+    if (fact.modeChange) modeChangedFiles += fact.files.length;
+    if (fact.binary) binaryFiles += fact.files.length;
+    kinds[fact.kind] = (kinds[fact.kind] || 0) + fact.files.length;
+    statuses[fact.status] = (statuses[fact.status] || 0) + fact.files.length;
+  }
+  const data = {
+    notice: SAMPLE_NOTICE,
+    totalFiles,
+    additions,
+    deletions,
+    modeChangedFiles,
+    binaryFiles,
+    lineCounts: 'tracked diff only',
+    kinds,
+    statuses,
+    totalGroups: facts.length,
+    omittedGroups: facts.length,
+    samples: [],
+  };
+  const cap = localInputBytes(config);
+  let sampledFiles = 0;
+  const seen = new Set();
+  const ordered = ranked(facts);
+  // First cover distinct modules/categories, then use remaining space for detail.
+  const diverse = [];
+  const rest = [];
+  for (const fact of ordered) {
+    const key = JSON.stringify([fact.module, fact.kind]);
+    if (seen.has(key)) rest.push(fact);
+    else {
+      seen.add(key);
+      diverse.push(fact);
+    }
+  }
+  const firstKinds = new Set();
+  const first = [];
+  const remaining = [];
+  for (const fact of diverse) {
+    if (firstKinds.has(fact.kind)) remaining.push(fact);
+    else {
+      firstKinds.add(fact.kind);
+      first.push(fact);
+    }
+  }
+  for (const fact of [...first, ...remaining, ...rest]) {
+    if (data.samples.length >= 16) break;
+    const sample = summaryOf(fact);
+    data.samples.push(sample);
+    if (Buffer.byteLength(JSON.stringify(data)) > cap) {
+      data.samples.pop();
+      continue;
+    }
+    if (fact.evidence) sampledFiles++;
+    data.omittedGroups--;
+  }
+  // A tiny configured budget may not even fit aggregate metadata. Fail before
+  // sending rather than silently slicing JSON or dropping the uncertainty notice.
+  const text = JSON.stringify(data);
+  if (Buffer.byteLength(text) > cap)
+    throw fail(
+      ERROR_CATEGORIES.CONFIG,
+      'Local change inventory does not fit the input budget. Increase largeChange.chunkInputTokens or maxDiffChars.',
+    );
+  return { text, sampledFiles };
+}
+
+export function analyzeLocally(config, capture, protect, previews) {
+  const records = new Map(
+    capture.manifest.map((file) => [
+      file.id,
+      {
+        file,
+        hash: createHash('sha256'),
+        evidence: '',
+        textual: false,
+      },
+    ]),
+  );
+  for (const unit of capture.units(protect, previews)) {
+    if (unit.metadataOnly) continue;
+    const record = records.get(unit.fileId);
+    // Tracked fragments carry Git headers; untracked fragments are plain text.
+    const section = unit.id.match(/S\d+(?=P\d+$)/)?.[0];
+    if (section && section !== record.section) {
+      record.section = section;
+      record.inHunk = false;
+    }
+    for (const line of unit.text.split(/(?<=\n)/)) {
+      if (section) {
+        if (line.startsWith('@@')) record.inHunk = true;
+        if (!record.inHunk || !/^[+-]/.test(line)) continue;
+      }
+      record.hash.update(line);
+      record.textual = true;
+      const remaining = 900 - Buffer.byteLength(record.evidence);
+      if (remaining > 3) record.evidence += clip(line, remaining);
+    }
+  }
+  const grouped = new Map();
+  for (const { file, hash, evidence, textual } of records.values()) {
+    const kind = category(file, config);
+    const module = moduleOf(file.addPaths?.at(-1) || file.path);
+    const status = file.status.replace(/\d+$/, '');
+    const metadata = ['lockfile', 'excluded', 'generated'].includes(kind);
+    const modeChange =
+      file.oldMode && file.newMode && file.oldMode !== file.newMode
+        ? `${file.oldMode} -> ${file.newMode}`
+        : null;
+    // Unknown/binary changes and renames stay independent for split safety.
+    const identity = metadata
+      ? 'metadata'
+      : textual && !status.startsWith('R')
+        ? hash.digest('hex')
+        : file.id;
+    const key = JSON.stringify([kind, module, status, identity, modeChange, !!file.binary]);
+    let fact = grouped.get(key);
+    if (!fact) {
+      fact = {
+        id: file.id,
+        kind,
+        module,
+        status,
+        files: [],
+        additions: 0,
+        deletions: 0,
+        modeChange,
+        binary: !!file.binary,
+        evidence: metadata ? '' : evidence,
+      };
+      grouped.set(key, fact);
+    }
+    fact.files.push(file.path);
+    fact.additions += file.additions;
+    fact.deletions += file.deletions;
+  }
+  const facts = [...grouped.values()];
+  const overview = localOverview(config, facts);
+  return {
+    facts,
+    summary: overview.text,
+    coverage: {
+      strategy: 'auto',
+      totalFiles: capture.manifest.length,
+      analyzedFiles: 0,
+      sampledFiles: overview.sampledFiles,
+      metadataOnlyFiles: capture.manifest.length - overview.sampledFiles,
+      failedFiles: 0,
+      completedChunks: 0,
+    },
+  };
+}
+
+export function localPlanItems(config, facts, cap) {
+  const error = () =>
+    fail(
+      ERROR_CATEGORIES.CONFIG,
+      'The complete split candidate inventory does not fit one request. Stage a smaller logical change or explicitly set personal largeChange.strategy to deep. No planning request was sent.',
+    );
+  if (facts.length > (config.splitMaxPlanFiles || 100)) throw error();
+  const items = facts.map((fact) => ({
+    ...summaryOf(fact, false),
+    summary: 'Local candidate only; verify grouping. Content not fully analyzed.',
+  }));
+  if (Buffer.byteLength(JSON.stringify(items)) > cap) throw error();
+  for (const fact of ranked(facts)) {
+    if (!fact.evidence) continue;
+    const item = items.find((item) => item.id === fact.id);
+    item.representativeExcerpt = fact.evidence;
+    if (Buffer.byteLength(JSON.stringify(items)) > cap) delete item.representativeExcerpt;
+  }
+  return items;
+}