@hifullmoon/aicommit 1.4.0

package/src/setup.js

@@ -0,0 +1,268 @@
+import { readFile, writeFile, chmod, copyFile, rename, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import chalk from 'chalk';
+import ora from 'ora';
+import input from '@inquirer/input';
+import password from '@inquirer/password';
+import confirm from '@inquirer/confirm';
+
+import { checkConnection } from './api.js';
+import { isSecureApiUrl } from './config.js';
+import { vimSelect } from './ui.js';
+import { fileExists, formatMs, indentError, maskApiKey } from './utils.js';
+import { loadProviderPresetManifest } from './provider-presets.js';
+
+// Top-level connection keys from a legacy flat config. When the wizard writes
+// a providers map these are dropped from the top level, so the old flat
+// values can't silently shadow or conflict with the provider entries.
+const FLAT_CONNECTION_KEYS = ['apiUrl', 'apiKey', 'apiKeyEnv', 'modelId'];
+
+// Merge the wizard's answers into an existing config object (or an empty
+// one). Existing providers and unrelated settings are preserved; the new
+// provider becomes the default. Pure — exported for tests.
+export function mergeSetupConfig(existing, { providerName, entry, language }) {
+  const result = { ...existing };
+
+  // Legacy flat config: remove the top-level connection keys now that the
+  // connection lives under providers[providerName].
+  if (!result.providers) {
+    for (const key of FLAT_CONNECTION_KEYS) delete result[key];
+  }
+
+  result.providers = { ...existing.providers, [providerName]: entry };
+  result.defaultProvider = providerName;
+  result.language = language;
+  return result;
+}
+
+async function readExistingConfig(path) {
+  if (!(await fileExists(path))) return {};
+  try {
+    const parsed = JSON.parse(await readFile(path, 'utf-8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('expected a JSON object');
+    }
+    return parsed;
+  } catch (err) {
+    const backup = `${path}.invalid-${Date.now()}.bak`;
+    await copyFile(path, backup);
+    console.log(chalk.yellow(`  ⚠ Could not parse ${path} (${err.message}) — starting fresh.`));
+    console.log(chalk.dim(`    The original file was preserved at ${backup}.`));
+    return {};
+  }
+}
+
+async function writeConfigAtomic(path, value) {
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await writeFile(tempPath, JSON.stringify(value, null, 2) + '\n', {
+      encoding: 'utf-8',
+      mode: 0o600,
+    });
+    await chmod(tempPath, 0o600).catch(() => {});
+    await rename(tempPath, path);
+    await chmod(path, 0o600).catch(() => {});
+  } catch (err) {
+    await unlink(tempPath).catch(() => {});
+    throw err;
+  }
+}
+
+export async function runSetup(dependencies = {}) {
+  const {
+    targetPath = join(homedir(), '.aicommit.config.json'),
+    selectPrompt = vimSelect,
+    inputPrompt = input,
+    passwordPrompt = password,
+    confirmPrompt = confirm,
+    connectionCheck = checkConnection,
+    spinnerFactory = ora,
+    presetLoader = loadProviderPresetManifest,
+  } = dependencies;
+
+  console.log('');
+  console.log(
+    '  ' + chalk.cyan.bold('⚡ aicommit setup ') + chalk.dim('interactive configuration'),
+  );
+  console.log('  ' + chalk.dim('─'.repeat(45)));
+
+  // Provider credentials are always user-owned. A repository may contain a
+  // project config for harmless generation preferences, but it must never be
+  // able to redirect a globally authenticated request.
+  console.log(chalk.dim(`  Credentials will be stored in the user config: ${targetPath}`));
+
+  const existing = await readExistingConfig(targetPath);
+  const { manifest: presetManifest } = await presetLoader();
+  const providerPresets = presetManifest.providers;
+
+  // ── 2. Provider ─────────────────────────────────────────────────────
+
+  const presetName = await selectPrompt({
+    message: 'Choose a provider',
+    choices: [
+      ...providerPresets.map((p) => ({
+        name: p.label,
+        value: p.id,
+        description: `${p.apiUrl} — default model: ${p.modelId}`,
+      })),
+      { name: 'custom', value: 'custom', description: 'Any OpenAI-compatible endpoint' },
+    ],
+  });
+
+  let providerName, apiUrl, defaultModel, presetAdapter, presetExtraBody;
+  if (presetName === 'custom') {
+    providerName = await inputPrompt({
+      message: 'Provider name (used with aicommit -p <name>)',
+      validate: (v) => /^[\w.-]+$/.test(v.trim()) || 'Use letters, digits, dot, dash or underscore',
+    });
+    providerName = providerName.trim();
+    apiUrl = await inputPrompt({
+      message: 'API endpoint URL',
+      validate: (v) => isSecureApiUrl(v.trim()) || 'Use HTTPS, or HTTP only for localhost/loopback',
+    });
+    apiUrl = apiUrl.trim();
+    defaultModel = '';
+  } else {
+    const preset = providerPresets.find((p) => p.id === presetName);
+    if (!preset) throw new Error(`Provider preset not found: ${presetName}`);
+    providerName = preset.id;
+    apiUrl = preset.apiUrl;
+    defaultModel = preset.modelId;
+    presetAdapter = preset.adapter;
+    presetExtraBody = preset.extraBody;
+  }
+
+  const existingProvider = existing.providers?.[providerName] || {};
+
+  // ── 3. API key ──────────────────────────────────────────────────────
+
+  const hasKey = Boolean(existingProvider.apiKey);
+  const hasKeyEnv = Boolean(existingProvider.apiKeyEnv);
+  // An empty key is allowed — local models (Ollama, LM Studio, LiteLLM) are
+  // keyless; the optional connection test below still catches a missing key
+  // for providers that require one.
+  const keyInput = await passwordPrompt({
+    message: `API key for ${providerName}${
+      hasKey
+        ? ` (current: ${maskApiKey(existingProvider.apiKey)} — leave empty to keep)`
+        : hasKeyEnv
+          ? ` (current env: ${existingProvider.apiKeyEnv} — leave empty to keep)`
+          : ' (use env:VARIABLE, or leave empty for local models)'
+    }`,
+    mask: '*',
+  });
+  const enteredKey = keyInput.trim();
+  let apiKey = existingProvider.apiKey || '';
+  let apiKeyEnv = existingProvider.apiKeyEnv || '';
+  if (/^env:/i.test(enteredKey)) {
+    apiKeyEnv = enteredKey.slice(4).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(apiKeyEnv)) {
+      throw new Error('Invalid environment variable name after env:.');
+    }
+    if (!process.env[apiKeyEnv]) {
+      throw new Error(`Environment variable "${apiKeyEnv}" is not set.`);
+    }
+    apiKey = '';
+  } else if (enteredKey) {
+    apiKey = enteredKey;
+    apiKeyEnv = '';
+  }
+
+  // ── 4. Model ────────────────────────────────────────────────────────
+
+  const modelInput = await inputPrompt({
+    message: 'Model ID',
+    default: existingProvider.modelId || defaultModel || undefined,
+    validate: (v) => (v.trim() ? true : 'Model ID is required'),
+  });
+  const modelId = modelInput.trim();
+
+  // ── 5. Commit message language ──────────────────────────────────────
+
+  const language = await selectPrompt({
+    message: 'Commit message language',
+    default: existing.language === 'en' ? 'en' : 'zh',
+    choices: [
+      { name: '中文 (zh)', value: 'zh' },
+      { name: 'English (en)', value: 'en' },
+    ],
+  });
+
+  const entry = {
+    ...existingProvider,
+    apiUrl,
+    apiKey,
+    apiKeyEnv,
+    modelId,
+    ...(presetAdapter ? { providerType: presetAdapter } : {}),
+    ...(presetExtraBody && !existingProvider.extraBody ? { extraBody: presetExtraBody } : {}),
+  };
+
+  // ── 6. Connection test ──────────────────────────────────────────────
+
+  const runTest = await confirmPrompt({
+    message: 'Test the connection now?',
+    default: true,
+  });
+  let connectionVerified = false;
+
+  if (runTest) {
+    const spinner = spinnerFactory({
+      text: chalk.dim(`Checking ${chalk.bold(modelId)} ...`),
+      color: 'cyan',
+    }).start();
+
+    try {
+      const report = await connectionCheck({
+        ...entry,
+        apiKey: apiKeyEnv ? process.env[apiKeyEnv] : apiKey,
+        maxTokens: 64,
+        timeoutMs: 120000,
+      });
+      spinner.succeed(`Connection OK — ${formatMs(report.elapsed)}`);
+      connectionVerified = true;
+    } catch (err) {
+      spinner.fail('Connection failed');
+      console.log(`\n  ${indentError(err)}\n`);
+      const saveAnyway = await confirmPrompt({
+        message: 'Save the config anyway?',
+        default: false,
+      });
+      if (!saveAnyway) {
+        console.log(chalk.dim('\n  Setup cancelled — nothing was saved.\n'));
+        return;
+      }
+    }
+  }
+
+  // ── 7. Write config ─────────────────────────────────────────────────
+
+  const merged = mergeSetupConfig(existing, { providerName, entry, language });
+  // Write through a same-directory temporary file so interruption cannot
+  // leave a partially written config. Permissions are tightened before the
+  // atomic replacement as well as after it (best effort on Windows).
+  await writeConfigAtomic(targetPath, merged);
+
+  console.log('');
+  console.log('  ' + chalk.green.bold('✓ Config saved'));
+  console.log('  ' + chalk.dim(`  Path:     ${targetPath}`));
+  console.log('  ' + chalk.dim(`  Provider: ${providerName} (${modelId})`));
+  console.log(
+    '  ' + chalk.dim(`  API key:  ${apiKeyEnv ? `env:${apiKeyEnv}` : maskApiKey(apiKey)}`),
+  );
+  console.log('');
+  if (connectionVerified) {
+    console.log(chalk.dim('  Connection verified. Run ') + chalk.bold('aicommit') + chalk.dim('.'));
+  } else {
+    console.log(
+      chalk.dim('  Run ') +
+        chalk.bold('aicommit doctor') +
+        chalk.dim(' to verify the setup, or ') +
+        chalk.bold('aicommit') +
+        chalk.dim(' to start committing.'),
+    );
+  }
+  console.log('');
+}

package/src/split-checkpoint.js

@@ -0,0 +1,252 @@
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { dirname, isAbsolute, resolve } from 'node:path';
+
+import { validateSplitPlanArtifact } from './split-plan.js';
+
+export const SPLIT_CHECKPOINT_KIND = 'aicommit-split-checkpoint';
+export const SPLIT_CHECKPOINT_VERSION = 1;
+const MAX_CHECKPOINT_BYTES = 2 * 1024 * 1024;
+const OID_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+
+function object(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function checkpointFile(projectRoot) {
+  const raw = execFileSync('git', ['rev-parse', '--git-path', 'aicommit/split-checkpoint.json'], {
+    cwd: projectRoot,
+    encoding: 'utf8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+  return isAbsolute(raw) ? raw : resolve(projectRoot, raw);
+}
+
+function validateEntry(entry, label) {
+  if (entry === null) return null;
+  if (
+    !object(entry) ||
+    Object.keys(entry).some((key) => !['mode', 'oid'].includes(key)) ||
+    typeof entry.mode !== 'string' ||
+    !/^\d{6}$/.test(entry.mode) ||
+    typeof entry.oid !== 'string' ||
+    !OID_RE.test(entry.oid)
+  ) {
+    throw new Error(`${label} must be null or a Git mode/object pair.`);
+  }
+  return { mode: entry.mode, oid: entry.oid };
+}
+
+function validateCommitRecord(record, index) {
+  if (
+    !object(record) ||
+    Object.keys(record).some((key) => !['index', 'commit', 'parent', 'tree'].includes(key)) ||
+    record.index !== index ||
+    typeof record.commit !== 'string' ||
+    !OID_RE.test(record.commit) ||
+    (record.parent !== null &&
+      (typeof record.parent !== 'string' || !OID_RE.test(record.parent))) ||
+    typeof record.tree !== 'string' ||
+    !OID_RE.test(record.tree)
+  ) {
+    throw new Error(`completed[${index}] is invalid or non-contiguous.`);
+  }
+  return { index, commit: record.commit, parent: record.parent, tree: record.tree };
+}
+
+function validateInFlight(record, completedCount, groupCount) {
+  if (record === null) return null;
+  if (
+    !object(record) ||
+    Object.keys(record).some((key) => !['index', 'parent', 'tree'].includes(key)) ||
+    record.index !== completedCount ||
+    record.index >= groupCount ||
+    (record.parent !== null &&
+      (typeof record.parent !== 'string' || !OID_RE.test(record.parent))) ||
+    typeof record.tree !== 'string' ||
+    !OID_RE.test(record.tree)
+  ) {
+    throw new Error('Checkpoint inFlight record is invalid.');
+  }
+  return { index: record.index, parent: record.parent, tree: record.tree };
+}
+
+export function validateSplitCheckpoint(input) {
+  if (!object(input)) throw new Error('Split checkpoint must be a JSON object.');
+  const allowed = new Set([
+    'kind',
+    'version',
+    'transactionId',
+    'createdAt',
+    'updatedAt',
+    'plan',
+    'snapshots',
+    'completed',
+    'inFlight',
+  ]);
+  if (Object.keys(input).some((key) => !allowed.has(key))) {
+    throw new Error('Split checkpoint contains an unknown property.');
+  }
+  if (input.kind !== SPLIT_CHECKPOINT_KIND || input.version !== SPLIT_CHECKPOINT_VERSION) {
+    throw new Error('Unsupported split checkpoint version.');
+  }
+  if (typeof input.transactionId !== 'string' || !/^[0-9a-f]{64}$/.test(input.transactionId)) {
+    throw new Error('Split checkpoint transactionId must be a SHA-256 digest.');
+  }
+  for (const key of ['createdAt', 'updatedAt']) {
+    if (typeof input[key] !== 'string' || !Number.isFinite(Date.parse(input[key]))) {
+      throw new Error(`Split checkpoint ${key} must be an ISO timestamp.`);
+    }
+  }
+  const plan = validateSplitPlanArtifact(input.plan);
+  const realPaths = new Set(plan.changes.flatMap((change) => change.addPaths));
+  if (!Array.isArray(input.snapshots) || input.snapshots.length !== realPaths.size) {
+    throw new Error('Split checkpoint snapshots must cover every real path exactly once.');
+  }
+  const seen = new Set();
+  const snapshots = input.snapshots.map((snapshot, index) => {
+    if (
+      !object(snapshot) ||
+      Object.keys(snapshot).some((key) => !['path', 'target', 'index'].includes(key)) ||
+      typeof snapshot.path !== 'string' ||
+      !realPaths.has(snapshot.path) ||
+      seen.has(snapshot.path)
+    ) {
+      throw new Error(`snapshots[${index}] has an unknown or duplicate path.`);
+    }
+    seen.add(snapshot.path);
+    return {
+      path: snapshot.path,
+      target: validateEntry(snapshot.target, `snapshots[${index}].target`),
+      index: validateEntry(snapshot.index, `snapshots[${index}].index`),
+    };
+  });
+  if (!Array.isArray(input.completed) || input.completed.length > plan.groups.length) {
+    throw new Error('Split checkpoint completed list is invalid.');
+  }
+  const completed = input.completed.map(validateCommitRecord);
+  const inFlight = validateInFlight(input.inFlight, completed.length, plan.groups.length);
+  return {
+    kind: SPLIT_CHECKPOINT_KIND,
+    version: SPLIT_CHECKPOINT_VERSION,
+    transactionId: input.transactionId,
+    createdAt: input.createdAt,
+    updatedAt: input.updatedAt,
+    plan,
+    snapshots: snapshots.sort((left, right) => left.path.localeCompare(right.path)),
+    completed,
+    inFlight,
+  };
+}
+
+export function splitCheckpointPath(projectRoot) {
+  return checkpointFile(projectRoot);
+}
+
+export function assertNoSplitCheckpoint(projectRoot) {
+  const path = checkpointFile(projectRoot);
+  if (existsSync(path)) {
+    throw new Error(
+      `An unfinished split checkpoint already exists: ${path}\n` +
+        'Resume it with "aicommit split resume", or discard only the checkpoint with ' +
+        '"aicommit split abort". Discarding keeps existing commits and current changes.',
+    );
+  }
+  return path;
+}
+
+export function createSplitCheckpoint(projectRoot, plan, snapshots) {
+  const path = assertNoSplitCheckpoint(projectRoot);
+  const now = new Date().toISOString();
+  const transactionId = createHash('sha256')
+    .update(JSON.stringify({ plan, snapshots, createdAt: now }))
+    .digest('hex');
+  const checkpoint = validateSplitCheckpoint({
+    kind: SPLIT_CHECKPOINT_KIND,
+    version: SPLIT_CHECKPOINT_VERSION,
+    transactionId,
+    createdAt: now,
+    updatedAt: now,
+    plan,
+    snapshots,
+    completed: [],
+    inFlight: null,
+  });
+  writeSplitCheckpoint(projectRoot, checkpoint);
+  return { path, checkpoint };
+}
+
+export function readSplitCheckpoint(projectRoot) {
+  const path = checkpointFile(projectRoot);
+  let stat;
+  try {
+    stat = lstatSync(path);
+  } catch (err) {
+    if (err.code === 'ENOENT') throw new Error(`No split checkpoint found: ${path}`);
+    throw err;
+  }
+  if (!stat.isFile() || stat.isSymbolicLink()) {
+    throw new Error('Split checkpoint must be a regular, non-symbolic-link file.');
+  }
+  if (stat.size > MAX_CHECKPOINT_BYTES) throw new Error('Split checkpoint exceeds 2 MiB.');
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (err) {
+    throw new Error(`Failed to parse split checkpoint ${path}: ${err.message}`);
+  }
+  return { path, checkpoint: validateSplitCheckpoint(parsed) };
+}
+
+export function writeSplitCheckpoint(projectRoot, input) {
+  const path = checkpointFile(projectRoot);
+  const checkpoint = validateSplitCheckpoint({
+    ...input,
+    updatedAt: new Date().toISOString(),
+  });
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify(checkpoint, null, 2) + '\n', {
+      encoding: 'utf8',
+      mode: 0o600,
+    });
+    renameSync(temporary, path);
+  } catch (err) {
+    rmSync(temporary, { force: true });
+    throw err;
+  }
+  return { path, checkpoint };
+}
+
+export function removeSplitCheckpoint(projectRoot) {
+  rmSync(checkpointFile(projectRoot), { force: true });
+}
+
+// Explicitly abandoning recovery removes only AICommit's metadata. It never
+// rewrites HEAD, the index, or the worktree. A symlink at the fixed checkpoint
+// path is safe to unlink, but directories and special files are left alone.
+export function discardSplitCheckpoint(projectRoot) {
+  const path = checkpointFile(projectRoot);
+  let stat;
+  try {
+    stat = lstatSync(path);
+  } catch (err) {
+    if (err.code === 'ENOENT') throw new Error(`No split checkpoint found: ${path}`);
+    throw err;
+  }
+  if (!stat.isFile() && !stat.isSymbolicLink()) {
+    throw new Error('Split checkpoint must be a regular file or symbolic link to discard it.');
+  }
+  rmSync(path);
+  return path;
+}