@hifullmoon/aicommit 1.4.0

package/src/split-hunks.js

@@ -0,0 +1,263 @@
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+
+function git(projectRoot, args, { indexPath = null, input = undefined } = {}) {
+  try {
+    return execFileSync('git', args, {
+      cwd: projectRoot,
+      env: indexPath ? { ...process.env, GIT_INDEX_FILE: indexPath } : process.env,
+      encoding: 'utf8',
+      input,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (err) {
+    const detail = err.stderr?.toString('utf8').trim();
+    throw new Error(`git ${args.join(' ')} failed${detail ? `: ${detail}` : ''}`, { cause: err });
+  }
+}
+
+function updateIndexEntry(projectRoot, indexPath, path, entry) {
+  if (entry) {
+    git(
+      projectRoot,
+      ['update-index', '--add', '--cacheinfo', `${entry.mode},${entry.oid},${path}`],
+      { indexPath },
+    );
+  } else {
+    git(projectRoot, ['update-index', '--force-remove', '--', path], { indexPath });
+  }
+}
+
+function parseIndexEntries(text) {
+  const entries = new Map();
+  for (const field of text.split('\0')) {
+    if (!field) continue;
+    const match = field.match(/^(\d+) ([0-9a-f]+) 0\t([\s\S]+)$/);
+    if (match) entries.set(match[3], { mode: match[1], oid: match[2] });
+  }
+  return entries;
+}
+
+function parsePatch(path, patch) {
+  if (
+    !patch.startsWith('diff --git ') ||
+    /^(?:GIT binary patch|Binary files |new file mode |deleted file mode |old mode |new mode |rename (?:from|to) )/m.test(
+      patch,
+    )
+  ) {
+    return null;
+  }
+  const matches = [...patch.matchAll(/^@@ /gm)];
+  if (matches.length < 2) return null;
+  const header = patch.slice(0, matches[0].index);
+  const hunks = matches.map((match, index) => {
+    const end = matches[index + 1]?.index ?? patch.length;
+    const text = patch.slice(match.index, end);
+    const coordinates = text.match(HUNK_HEADER_RE);
+    if (!coordinates) throw new Error(`Cannot parse unified hunk header for ${path}.`);
+    return {
+      id: `H${index + 1}`,
+      hash: createHash('sha256').update(`${path}\0${text}`).digest('hex'),
+      oldStart: Number(coordinates[1]),
+      oldLines: Number(coordinates[2] ?? 1),
+      newStart: Number(coordinates[3]),
+      newLines: Number(coordinates[4] ?? 1),
+      text,
+    };
+  });
+  return { path, header, hunks };
+}
+
+function targetTreeAndPatches(projectRoot, baseHead, changes, snapshots) {
+  if (!baseHead) return { targetTree: null, patches: new Map() };
+  const snapshot = new Map(snapshots.map((entry) => [entry.path, entry.target]));
+  const candidates = changes.filter(
+    (change) =>
+      change.addPaths.length === 1 &&
+      change.status.includes('M') &&
+      snapshot.get(change.addPaths[0]),
+  );
+  const tempDir = mkdtempSync(join(tmpdir(), 'aicommit-split-hunks-'));
+  const indexPath = join(tempDir, 'index');
+  try {
+    git(projectRoot, ['read-tree', baseHead], { indexPath });
+    for (const change of candidates) {
+      const path = change.addPaths[0];
+      updateIndexEntry(projectRoot, indexPath, path, snapshot.get(path));
+    }
+    const targetTree = git(projectRoot, ['write-tree'], { indexPath }).trim();
+    const patches = new Map();
+    for (const change of candidates) {
+      const path = change.addPaths[0];
+      const patch = git(projectRoot, [
+        'diff',
+        '--no-ext-diff',
+        '--binary',
+        '--no-textconv',
+        '--full-index',
+        '--unified=3',
+        baseHead,
+        targetTree,
+        '--',
+        path,
+      ]);
+      const parsed = parsePatch(path, patch);
+      if (parsed) patches.set(change.path, parsed);
+    }
+    return { targetTree, patches };
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+function publicHunk(hunk) {
+  return {
+    id: hunk.id,
+    hash: hunk.hash,
+    oldStart: hunk.oldStart,
+    oldLines: hunk.oldLines,
+    newStart: hunk.newStart,
+    newLines: hunk.newLines,
+  };
+}
+
+export function discoverSplitHunks(projectRoot, baseHead, changes, snapshots) {
+  const { patches } = targetTreeAndPatches(projectRoot, baseHead, changes, snapshots);
+  return changes.map((change) => {
+    const parsed = patches.get(change.path);
+    return parsed
+      ? { ...change, hunks: parsed.hunks.map(publicHunk) }
+      : { status: change.status, path: change.path, addPaths: [...change.addPaths] };
+  });
+}
+
+function sameHunkMetadata(expected, actual) {
+  return (
+    expected.id === actual.id &&
+    expected.hash === actual.hash &&
+    expected.oldStart === actual.oldStart &&
+    expected.oldLines === actual.oldLines &&
+    expected.newStart === actual.newStart &&
+    expected.newLines === actual.newLines
+  );
+}
+
+function validateCatalog(plan, patches) {
+  for (const change of plan.changes) {
+    if (!change.hunks?.length) continue;
+    const parsed = patches.get(change.path);
+    if (
+      !parsed ||
+      parsed.hunks.length !== change.hunks.length ||
+      change.hunks.some((hunk, index) => !sameHunkMetadata(hunk, parsed.hunks[index]))
+    ) {
+      throw new Error(`Hunk catalog no longer matches the target snapshot: ${change.path}`);
+    }
+  }
+}
+
+function groupRealPaths(group, changes) {
+  const byPath = new Map(changes.map((change) => [change.path, change]));
+  const displays = [...group.files, ...(group.hunks || []).map((entry) => entry.path)];
+  return [...new Set(displays.flatMap((path) => byPath.get(path)?.addPaths || [path]))];
+}
+
+function entriesEqual(left, right) {
+  if (!left) return !right;
+  return Boolean(right) && left.mode === right.mode && left.oid === right.oid;
+}
+
+export function validateHunkTransaction(projectRoot, plan, snapshots) {
+  if (!plan.hunkMode) return null;
+  const { patches } = targetTreeAndPatches(projectRoot, plan.baseHead, plan.changes, snapshots);
+  validateCatalog(plan, patches);
+
+  const snapshot = new Map(snapshots.map((entry) => [entry.path, entry.target]));
+  const byDisplay = new Map(plan.changes.map((change) => [change.path, change]));
+  const tempDir = mkdtempSync(join(tmpdir(), 'aicommit-split-hunk-validate-'));
+  const indexPath = join(tempDir, 'index');
+  const groupTrees = [];
+  try {
+    git(projectRoot, ['read-tree', plan.baseHead], { indexPath });
+    let previousTree = git(projectRoot, ['write-tree'], { indexPath }).trim();
+    for (const [groupIndex, group] of plan.groups.entries()) {
+      for (const path of group.files) {
+        const change = byDisplay.get(path);
+        for (const realPath of change.addPaths) {
+          updateIndexEntry(projectRoot, indexPath, realPath, snapshot.get(realPath) || null);
+        }
+      }
+      for (const assignment of group.hunks || []) {
+        const parsed = patches.get(assignment.path);
+        const selected = new Set(assignment.ids);
+        const patch =
+          parsed.header +
+          parsed.hunks
+            .filter((hunk) => selected.has(hunk.id))
+            .map((hunk) => hunk.text)
+            .join('');
+        git(projectRoot, ['apply', '--cached', '--3way', '--whitespace=nowarn', '--recount', '-'], {
+          indexPath,
+          input: patch,
+        });
+      }
+      const tree = git(projectRoot, ['write-tree'], { indexPath }).trim();
+      if (tree === previousTree) {
+        throw new Error(`Hunk group ${groupIndex + 1} would create an empty commit.`);
+      }
+      groupTrees.push(tree);
+      previousTree = tree;
+    }
+
+    const finalEntries = parseIndexEntries(
+      git(projectRoot, ['ls-files', '--stage', '-z', '--', ...snapshots.map((item) => item.path)], {
+        indexPath,
+      }),
+    );
+    for (const entry of snapshots) {
+      if (!entriesEqual(finalEntries.get(entry.path) || null, entry.target)) {
+        throw new Error(`Hunk plan is not lossless for ${entry.path}.`);
+      }
+    }
+    return {
+      groupTrees,
+      realPaths: plan.groups.map((group) => groupRealPaths(group, plan.changes)),
+    };
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+export function stripHunkCatalog(changes) {
+  return changes.map((change) => ({
+    status: change.status,
+    path: change.path,
+    addPaths: [...change.addPaths],
+  }));
+}
+
+export function fallbackHunkGroups(groups, changes) {
+  const hunkPaths = new Set(
+    changes.filter((change) => change.hunks?.length).map((change) => change.path),
+  );
+  const owner = new Map();
+  groups.forEach((group, index) => {
+    for (const assignment of group.hunks || []) {
+      if (!owner.has(assignment.path)) owner.set(assignment.path, index);
+    }
+  });
+  return groups
+    .map((group, index) => {
+      const files = [...group.files];
+      for (const path of hunkPaths) {
+        if (owner.get(path) === index && !files.includes(path)) files.push(path);
+      }
+      return { message: group.message, files };
+    })
+    .filter((group) => group.files.length);
+}

package/src/split-plan.js

@@ -0,0 +1,339 @@
+import { lstat, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+
+import { normalizeCommitPolicy, validateCommitCandidate } from './policy.js';
+
+export const SPLIT_PLAN_KIND = 'aicommit-split-plan';
+export const SPLIT_PLAN_VERSION = 1;
+const MAX_PLAN_BYTES = 1024 * 1024;
+const HASH_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+const FINGERPRINT_RE = /^[0-9a-f]{64}$/;
+const HUNK_HASH_RE = /^[0-9a-f]{64}$/;
+
+function object(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function safePath(value, label) {
+  if (
+    typeof value !== 'string' ||
+    !value ||
+    value.length > 1000 ||
+    value.includes('\0') ||
+    isAbsolute(value) ||
+    value === '..' ||
+    value.startsWith('../') ||
+    value.split(/[\\/]/).includes('..')
+  ) {
+    throw new Error(`${label} must be a safe repository-relative path.`);
+  }
+  return value;
+}
+
+function clonePolicy(policy, language) {
+  const normalized = normalizeCommitPolicy(policy, language);
+  return {
+    version: normalized.version,
+    types: [...normalized.types],
+    scope: { ...normalized.scope, values: [...normalized.scope.values] },
+    subject: { ...normalized.subject },
+    body: { ...normalized.body },
+    breakingChange: normalized.breakingChange,
+    language: normalized.language,
+  };
+}
+
+function normalizeChange(change, index) {
+  if (!object(change)) throw new Error(`changes[${index}] must be an object.`);
+  const keys = Object.keys(change);
+  if (keys.some((key) => !['status', 'path', 'addPaths', 'hunks'].includes(key))) {
+    throw new Error(`changes[${index}] contains an unknown property.`);
+  }
+  if (typeof change.status !== 'string' || !change.status || change.status.length > 8) {
+    throw new Error(`changes[${index}].status must be a short non-empty string.`);
+  }
+  const path = safePath(change.path, `changes[${index}].path`);
+  if (!Array.isArray(change.addPaths) || !change.addPaths.length || change.addPaths.length > 2) {
+    throw new Error(`changes[${index}].addPaths must contain one or two paths.`);
+  }
+  const addPaths = change.addPaths.map((item, pathIndex) =>
+    safePath(item, `changes[${index}].addPaths[${pathIndex}]`),
+  );
+  if (new Set(addPaths).size !== addPaths.length) {
+    throw new Error(`changes[${index}].addPaths contains a duplicate path.`);
+  }
+  let hunks;
+  if (change.hunks !== undefined) {
+    if (!Array.isArray(change.hunks) || change.hunks.length < 2 || change.hunks.length > 1000) {
+      throw new Error(`changes[${index}].hunks must contain 2-1000 entries.`);
+    }
+    hunks = change.hunks.map((hunk, hunkIndex) => {
+      if (
+        !object(hunk) ||
+        Object.keys(hunk).some(
+          (key) => !['id', 'hash', 'oldStart', 'oldLines', 'newStart', 'newLines'].includes(key),
+        ) ||
+        typeof hunk.id !== 'string' ||
+        !/^H[1-9]\d*$/.test(hunk.id) ||
+        typeof hunk.hash !== 'string' ||
+        !HUNK_HASH_RE.test(hunk.hash)
+      ) {
+        throw new Error(`changes[${index}].hunks[${hunkIndex}] is invalid.`);
+      }
+      for (const key of ['oldStart', 'oldLines', 'newStart', 'newLines']) {
+        if (!Number.isInteger(hunk[key]) || hunk[key] < 0) {
+          throw new Error(`changes[${index}].hunks[${hunkIndex}].${key} is invalid.`);
+        }
+      }
+      return {
+        id: hunk.id,
+        hash: hunk.hash,
+        oldStart: hunk.oldStart,
+        oldLines: hunk.oldLines,
+        newStart: hunk.newStart,
+        newLines: hunk.newLines,
+      };
+    });
+    if (new Set(hunks.map((hunk) => hunk.id)).size !== hunks.length) {
+      throw new Error(`changes[${index}].hunks contains a duplicate id.`);
+    }
+  }
+  return { status: change.status, path, addPaths, ...(hunks ? { hunks } : {}) };
+}
+
+function normalizeGroup(group, index, allowedPaths, hunkCatalog, policy, language) {
+  if (!object(group)) throw new Error(`groups[${index}] must be an object.`);
+  const keys = Object.keys(group);
+  if (keys.some((key) => !['message', 'files', 'hunks'].includes(key))) {
+    throw new Error(`groups[${index}] contains an unknown property.`);
+  }
+  if (typeof group.message !== 'string' || !group.message.trim() || group.message.length > 10_000) {
+    throw new Error(`groups[${index}].message must be a non-empty bounded string.`);
+  }
+  const validation = validateCommitCandidate(group.message, {
+    policy: normalizeCommitPolicy(policy, language),
+  });
+  if (!validation.valid) {
+    throw new Error(
+      `groups[${index}].message violates commitPolicy: ${validation.errors
+        .map((issue) => issue.message)
+        .join(' ')}`,
+    );
+  }
+  if (!Array.isArray(group.files)) {
+    throw new Error(`groups[${index}].files must be an array.`);
+  }
+  const files = group.files.map((item, fileIndex) =>
+    safePath(item, `groups[${index}].files[${fileIndex}]`),
+  );
+  if (new Set(files).size !== files.length) {
+    throw new Error(`groups[${index}].files contains a duplicate path.`);
+  }
+  for (const path of files) {
+    if (!allowedPaths.has(path))
+      throw new Error(`groups[${index}] references unknown path: ${path}`);
+  }
+  let hunks = [];
+  if (group.hunks !== undefined) {
+    if (!Array.isArray(group.hunks)) throw new Error(`groups[${index}].hunks must be an array.`);
+    hunks = group.hunks.map((assignment, assignmentIndex) => {
+      if (
+        !object(assignment) ||
+        Object.keys(assignment).some((key) => !['path', 'ids'].includes(key)) ||
+        typeof assignment.path !== 'string' ||
+        !hunkCatalog.has(assignment.path) ||
+        !Array.isArray(assignment.ids) ||
+        !assignment.ids.length
+      ) {
+        throw new Error(`groups[${index}].hunks[${assignmentIndex}] is invalid.`);
+      }
+      const path = safePath(assignment.path, `groups[${index}].hunks[${assignmentIndex}].path`);
+      const ids = assignment.ids.map((id) => {
+        if (typeof id !== 'string' || !hunkCatalog.get(path).has(id)) {
+          throw new Error(`groups[${index}] references unknown hunk: ${path}#${id}`);
+        }
+        return id;
+      });
+      if (new Set(ids).size !== ids.length) {
+        throw new Error(`groups[${index}].hunks[${assignmentIndex}] contains a duplicate id.`);
+      }
+      return { path, ids };
+    });
+    if (new Set(hunks.map((assignment) => assignment.path)).size !== hunks.length) {
+      throw new Error(`groups[${index}].hunks contains a duplicate path.`);
+    }
+  }
+  if (!files.length && !hunks.length) throw new Error(`groups[${index}] must not be empty.`);
+  return { message: validation.parsed.cleaned, files, ...(hunks.length ? { hunks } : {}) };
+}
+
+export function validateSplitPlanArtifact(input) {
+  if (!object(input)) throw new Error('Split plan must be a JSON object.');
+  const allowedKeys = new Set([
+    'kind',
+    'version',
+    'createdAt',
+    'hunkMode',
+    'scope',
+    'baseHead',
+    'fingerprint',
+    'language',
+    'commitPolicy',
+    'changes',
+    'groups',
+  ]);
+  if (Object.keys(input).some((key) => !allowedKeys.has(key))) {
+    throw new Error('Split plan contains an unknown top-level property.');
+  }
+  if (input.kind !== SPLIT_PLAN_KIND || input.version !== SPLIT_PLAN_VERSION) {
+    throw new Error(`Unsupported split plan; expected ${SPLIT_PLAN_KIND} version 1.`);
+  }
+  if (typeof input.createdAt !== 'string' || !Number.isFinite(Date.parse(input.createdAt))) {
+    throw new Error('Split plan createdAt must be an ISO timestamp.');
+  }
+  if (!['staged', 'all'].includes(input.scope)) {
+    throw new Error('Split plan scope must be staged or all.');
+  }
+  const hunkMode = input.hunkMode === true;
+  if (input.hunkMode !== undefined && typeof input.hunkMode !== 'boolean') {
+    throw new Error('Split plan hunkMode must be a boolean.');
+  }
+  if (
+    input.baseHead !== null &&
+    (typeof input.baseHead !== 'string' || !HASH_RE.test(input.baseHead))
+  ) {
+    throw new Error('Split plan baseHead must be a Git object id or null.');
+  }
+  if (typeof input.fingerprint !== 'string' || !FINGERPRINT_RE.test(input.fingerprint)) {
+    throw new Error('Split plan fingerprint must be a SHA-256 digest.');
+  }
+  if (!['zh', 'en'].includes(input.language)) {
+    throw new Error('Split plan language must be zh or en.');
+  }
+  const commitPolicy = clonePolicy(input.commitPolicy, input.language);
+  if (!Array.isArray(input.changes) || !input.changes.length || input.changes.length > 10_000) {
+    throw new Error('Split plan changes must contain 1-10000 entries.');
+  }
+  const changes = input.changes.map(normalizeChange);
+  const displayPaths = changes.map((change) => change.path);
+  if (new Set(displayPaths).size !== displayPaths.length) {
+    throw new Error('Split plan changes contains duplicate display paths.');
+  }
+  if (!Array.isArray(input.groups) || !input.groups.length || input.groups.length > 1000) {
+    throw new Error('Split plan groups must contain 1-1000 entries.');
+  }
+  const allowedPaths = new Set(displayPaths);
+  const hunkCatalog = new Map(
+    changes
+      .filter((change) => change.hunks?.length)
+      .map((change) => [change.path, new Set(change.hunks.map((hunk) => hunk.id))]),
+  );
+  if (!hunkMode && hunkCatalog.size) {
+    throw new Error('Split plan cannot contain a hunk catalog when hunkMode is disabled.');
+  }
+  const groups = input.groups.map((group, index) =>
+    normalizeGroup(group, index, allowedPaths, hunkCatalog, commitPolicy, input.language),
+  );
+  const assignedFiles = groups.flatMap((group) => group.files);
+  if (new Set(assignedFiles).size !== assignedFiles.length) {
+    throw new Error('Split plan assigns a path to more than one group.');
+  }
+  const assignedHunks = new Set();
+  for (const group of groups) {
+    for (const assignment of group.hunks || []) {
+      if (assignedFiles.includes(assignment.path)) {
+        throw new Error(`Split plan assigns both a whole file and hunks: ${assignment.path}`);
+      }
+      for (const id of assignment.ids) {
+        const key = `${assignment.path}\0${id}`;
+        if (assignedHunks.has(key)) {
+          throw new Error(`Split plan assigns a hunk more than once: ${assignment.path}#${id}`);
+        }
+        assignedHunks.add(key);
+      }
+    }
+  }
+  const missing = displayPaths.filter((path) => {
+    if (assignedFiles.includes(path)) return false;
+    const ids = hunkCatalog.get(path);
+    return !ids || [...ids].some((id) => !assignedHunks.has(`${path}\0${id}`));
+  });
+  if (missing.length) throw new Error(`Split plan leaves paths unassigned: ${missing.join(', ')}`);
+
+  return {
+    kind: SPLIT_PLAN_KIND,
+    version: SPLIT_PLAN_VERSION,
+    createdAt: input.createdAt,
+    hunkMode,
+    scope: input.scope,
+    baseHead: input.baseHead,
+    fingerprint: input.fingerprint,
+    language: input.language,
+    commitPolicy,
+    changes,
+    groups,
+  };
+}
+
+export function createSplitPlanArtifact({
+  scope,
+  baseHead,
+  fingerprint,
+  language,
+  commitPolicy,
+  changes,
+  groups,
+  hunkMode = false,
+  createdAt = new Date().toISOString(),
+}) {
+  return validateSplitPlanArtifact({
+    kind: SPLIT_PLAN_KIND,
+    version: SPLIT_PLAN_VERSION,
+    createdAt,
+    hunkMode,
+    scope,
+    baseHead,
+    fingerprint,
+    language,
+    commitPolicy,
+    changes,
+    groups,
+  });
+}
+
+export async function writeSplitPlanArtifact(path, artifact) {
+  const absolute = resolve(path);
+  const validated = validateSplitPlanArtifact(artifact);
+  await mkdir(dirname(absolute), { recursive: true, mode: 0o700 });
+  const temporary = `${absolute}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(temporary, JSON.stringify(validated, null, 2) + '\n', {
+      encoding: 'utf8',
+      mode: 0o600,
+    });
+    await rename(temporary, absolute);
+  } catch (err) {
+    await unlink(temporary).catch(() => {});
+    throw err;
+  }
+  return absolute;
+}
+
+export async function readSplitPlanArtifact(path) {
+  const absolute = resolve(path);
+  const stat = await lstat(absolute).catch((err) => {
+    if (err.code === 'ENOENT') throw new Error(`Split plan not found: ${absolute}`);
+    throw err;
+  });
+  if (!stat.isFile() || stat.isSymbolicLink()) {
+    throw new Error('Split plan must be a regular, non-symbolic-link file.');
+  }
+  if (stat.size > MAX_PLAN_BYTES) throw new Error('Split plan exceeds the 1 MiB limit.');
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(absolute, 'utf8'));
+  } catch (err) {
+    throw new Error(`Failed to parse split plan ${absolute}: ${err.message}`);
+  }
+  return { path: absolute, artifact: validateSplitPlanArtifact(parsed) };
+}