fchek 1.0.0

package/lib/git.js

@@ -0,0 +1,290 @@
+'use strict';
+
+/**
+ * git.js — safe git operations in JSON
+ *
+ * Read-only by default. Write operations (stage, commit) require explicit flags.
+ * Never pushes, never force-pushes, never deletes branches.
+ * Agent uses this to understand repo state and commit completed work.
+ */
+
+const { spawnSync, execSync } = require('child_process');
+const path = require('path');
+const fs   = require('fs');
+const { output, ok, fail } = require('./output');
+
+const HELP = `
+fchek git <action> [args...]
+
+Safe git operations — JSON output. No push, no force, no branch deletion.
+
+Actions:
+  status              Current branch, staged/unstaged/untracked files
+  diff [file]         Show unstaged changes (or specific file)
+  diff --staged       Show staged changes
+  log [--n=10]        Recent commits
+  stage <file...>     Stage files for commit (git add)
+  unstage <file...>   Unstage files (git reset HEAD)
+  commit <message>    Commit staged changes
+  branch              List branches
+  stash               Stash uncommitted changes
+  stash pop           Restore stashed changes
+
+Examples:
+  fchek git status
+  fchek git diff
+  fchek git diff --staged
+  fchek git log --n=5
+  fchek git stage src/auth.py src/utils.py
+  fchek git commit "fix: validate user input in auth"
+`.trim();
+
+function gitExists() {
+  return commandExists('git');
+}
+
+function commandExists(cmd) {
+  try {
+    execSync(
+      process.platform === 'win32' ? `where ${cmd}` : `which ${cmd}`,
+      { stdio: 'ignore', timeout: 3000 }
+    );
+    return true;
+  } catch { return false; }
+}
+
+function isGitRepo(dir) {
+  const res = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+    encoding: 'utf8', cwd: dir, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return res.status === 0;
+}
+
+function gitCmd(args, cwd, timeoutMs = 15000) {
+  return spawnSync('git', args, {
+    encoding: 'utf8',
+    cwd,
+    timeout: timeoutMs,
+    windowsHide: true,
+  });
+}
+
+// ─── Actions ──────────────────────────────────────────────────────────────────
+
+function gitStatus(cwd) {
+  const branchRes = gitCmd(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+  const branch    = (branchRes.stdout || '').trim();
+
+  const statusRes = gitCmd(['status', '--porcelain=v1'], cwd);
+  const lines     = (statusRes.stdout || '').split('\n').filter(Boolean);
+
+  const staged    = [];
+  const unstaged  = [];
+  const untracked = [];
+  const conflicts = [];
+
+  for (const line of lines) {
+    const x    = line[0]; // index status
+    const y    = line[1]; // working tree status
+    const file = line.slice(3);
+
+    if (x === '?' && y === '?') { untracked.push(file); continue; }
+    if (x === 'U' || y === 'U') { conflicts.push(file); continue; }
+    if (x !== ' ' && x !== '?') staged.push({ status: x, file });
+    if (y !== ' ' && y !== '?') unstaged.push({ status: y, file });
+  }
+
+  // Last commit info
+  const logRes = gitCmd(['log', '-1', '--format=%H %s %ai'], cwd);
+  const logLine = (logRes.stdout || '').trim();
+  const lastCommit = logLine ? {
+    hash:    logLine.slice(0, 8),
+    message: logLine.slice(41, logLine.lastIndexOf(' ')).trim(),
+    date:    logLine.slice(logLine.lastIndexOf(' ') + 1),
+  } : null;
+
+  output(ok({
+    branch,
+    staged,
+    unstaged,
+    untracked,
+    conflicts,
+    is_clean:    staged.length === 0 && unstaged.length === 0 && untracked.length === 0,
+    last_commit: lastCommit,
+  }));
+}
+
+function gitDiff(cwd, file, staged) {
+  const args = ['diff'];
+  if (staged) args.push('--staged');
+  if (file) args.push('--', file);
+  args.push('--stat', '--patch');
+
+  const res = gitCmd(args, cwd, 30000);
+  const raw = (res.stdout || '').slice(0, 20000);
+
+  // Parse stat summary
+  const changed  = parseInt((raw.match(/(\d+) file(?:s)? changed/) || [0, 0])[1]);
+  const inserted = parseInt((raw.match(/(\d+) insertion/) || [0, 0])[1]);
+  const deleted  = parseInt((raw.match(/(\d+) deletion/)  || [0, 0])[1]);
+
+  // Extract changed files list
+  const changedFiles = [];
+  for (const m of raw.matchAll(/^diff --git a\/(.+?) b\//gm)) {
+    changedFiles.push(m[1]);
+  }
+
+  output(ok({
+    staged,
+    file:          file || null,
+    files_changed: changed,
+    insertions:    inserted,
+    deletions:     deleted,
+    changed_files: changedFiles,
+    patch:         raw,
+  }));
+}
+
+function gitLog(cwd, n) {
+  const res = gitCmd(['log', `--max-count=${n}`, '--format=%H|%s|%ai|%an'], cwd);
+  const commits = (res.stdout || '').trim().split('\n').filter(Boolean).map(line => {
+    const parts = line.split('|');
+    return {
+      hash:    parts[0]?.slice(0, 8),
+      message: parts[1],
+      date:    parts[2],
+      author:  parts[3],
+    };
+  });
+  output(ok({ commits, count: commits.length }));
+}
+
+function gitStage(cwd, files) {
+  if (files.length === 0) {
+    return output(fail('No files specified. Usage: fchek git stage <file...>'));
+  }
+  const res = gitCmd(['add', '--', ...files], cwd);
+  if (res.status !== 0) {
+    return output(fail(`git add failed:\n${res.stderr}`));
+  }
+  output(ok({ action: 'stage', files, staged: true }));
+}
+
+function gitUnstage(cwd, files) {
+  if (files.length === 0) {
+    return output(fail('No files specified. Usage: fchek git unstage <file...>'));
+  }
+  const res = gitCmd(['reset', 'HEAD', '--', ...files], cwd);
+  if (res.status !== 0) {
+    return output(fail(`git reset failed:\n${res.stderr}`));
+  }
+  output(ok({ action: 'unstage', files }));
+}
+
+function gitCommit(cwd, message) {
+  if (!message) {
+    return output(fail('Commit message required. Usage: fchek git commit "<message>"'));
+  }
+  // Check there is something staged
+  const statusRes = gitCmd(['diff', '--staged', '--stat'], cwd);
+  if (!(statusRes.stdout || '').trim()) {
+    return output(fail('Nothing staged. Use: fchek git stage <files> first'));
+  }
+
+  const res = gitCmd(['commit', '-m', message], cwd);
+  if (res.status !== 0) {
+    return output(fail(`git commit failed:\n${res.stderr}`));
+  }
+
+  const logRes = gitCmd(['log', '-1', '--format=%H %s'], cwd);
+  const line   = (logRes.stdout || '').trim();
+  output(ok({
+    action:     'commit',
+    hash:       line.slice(0, 8),
+    message,
+    committed:  true,
+    output:     (res.stdout || '').trim(),
+  }));
+}
+
+function gitBranch(cwd) {
+  const res = gitCmd(['branch', '-a', '--format=%(refname:short)|%(HEAD)'], cwd);
+  const branches = (res.stdout || '').trim().split('\n').filter(Boolean).map(line => {
+    const [name, current] = line.split('|');
+    return { name: name.trim(), current: current === '*' };
+  });
+  output(ok({ branches }));
+}
+
+function gitStash(cwd, action) {
+  if (action === 'pop') {
+    const res = gitCmd(['stash', 'pop'], cwd);
+    if (res.status !== 0) return output(fail(`git stash pop failed:\n${res.stderr}`));
+    output(ok({ action: 'stash_pop', output: (res.stdout || '').trim() }));
+  } else {
+    const res = gitCmd(['stash'], cwd);
+    if (res.status !== 0) return output(fail(`git stash failed:\n${res.stderr}`));
+    output(ok({ action: 'stash', output: (res.stdout || '').trim() }));
+  }
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+async function run(args) {
+  if (args.length === 0 || args[0] === '--help') { console.log(HELP); return; }
+
+  if (!gitExists()) {
+    return output(fail('git not found. Install: https://git-scm.com'));
+  }
+
+  const cwd = process.cwd();
+  if (!isGitRepo(cwd)) {
+    return output(fail(
+      'Not a git repository.\n' +
+      'Initialize with: git init && git add . && git commit -m "initial"'
+    ));
+  }
+
+  const action = args[0];
+
+  switch (action) {
+    case 'status':
+      return gitStatus(cwd);
+
+    case 'diff': {
+      const staged = args.includes('--staged');
+      const file   = args.find(a => !a.startsWith('--') && a !== 'diff') || null;
+      return gitDiff(cwd, file, staged);
+    }
+
+    case 'log': {
+      const n = parseInt(
+        (args.find(a => a.startsWith('--n=')) || '--n=10').replace('--n=', ''), 10
+      );
+      return gitLog(cwd, n);
+    }
+
+    case 'stage':
+      return gitStage(cwd, args.slice(1));
+
+    case 'unstage':
+      return gitUnstage(cwd, args.slice(1));
+
+    case 'commit':
+      return gitCommit(cwd, args.slice(1).join(' '));
+
+    case 'branch':
+      return gitBranch(cwd);
+
+    case 'stash':
+      return gitStash(cwd, args[1]);
+
+    default:
+      return output(fail(
+        `Unknown git action: "${action}"\n` +
+        `Valid: status, diff, log, stage, unstage, commit, branch, stash`
+      ));
+  }
+}
+
+module.exports = { run };