diffstalker 0.2.1 → 0.2.3

package/dist/git/status.js

@@ -1,4 +1,5 @@
 import { simpleGit } from 'simple-git';
+import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getIgnoredFiles } from './ignoreUtils.js';
@@ -60,62 +61,12 @@ export async function getStatus(repoPath) {
             };
         }
         const status = await git.status();
-        const files = [];
-        // Process staged files
-        for (const file of status.staged) {
-            files.push({
-                path: file,
-                status: 'added',
-                staged: true,
-            });
-        }
-        // Process modified staged files
-        for (const file of status.modified) {
-            // Check if it's in the index (staged)
-            const existingStaged = files.find((f) => f.path === file && f.staged);
-            if (!existingStaged) {
-                files.push({
-                    path: file,
-                    status: 'modified',
-                    staged: false,
-                });
-            }
-        }
-        // Process deleted files
-        for (const file of status.deleted) {
-            files.push({
-                path: file,
-                status: 'deleted',
-                staged: false,
-            });
-        }
-        // Process untracked files
-        for (const file of status.not_added) {
-            files.push({
-                path: file,
-                status: 'untracked',
-                staged: false,
-            });
-        }
-        // Process renamed files
-        for (const file of status.renamed) {
-            files.push({
-                path: file.to,
-                originalPath: file.from,
-                status: 'renamed',
-                staged: true,
-            });
-        }
-        // Use the files array from status for more accurate staging info
-        // The status.files array has detailed index/working_dir info
+        // Build processed file list, filtering ignored files
         const processedFiles = [];
         const seen = new Set();
-        // Collect untracked files to check if they're ignored
         const untrackedPaths = status.files.filter((f) => f.working_dir === '?').map((f) => f.path);
-        // Get the set of ignored files
         const ignoredFiles = await getIgnoredFiles(repoPath, untrackedPaths);
         for (const file of status.files) {
-            // Skip ignored files (marked with '!' in either column, or detected by check-ignore)
             if (file.index === '!' || file.working_dir === '!' || ignoredFiles.has(file.path)) {
                 continue;
             }
@@ -123,7 +74,6 @@ export async function getStatus(repoPath) {
             if (seen.has(key))
                 continue;
             seen.add(key);
-            // Staged changes (index column)
             if (file.index && file.index !== ' ' && file.index !== '?') {
                 processedFiles.push({
                     path: file.path,
@@ -131,7 +81,6 @@ export async function getStatus(repoPath) {
                     staged: true,
                 });
             }
-            // Unstaged changes (working_dir column)
             if (file.working_dir && file.working_dir !== ' ') {
                 processedFiles.push({
                     path: file.path,
@@ -147,7 +96,6 @@ export async function getStatus(repoPath) {
         ]);
         const stagedStats = parseNumstat(stagedNumstat);
         const unstagedStats = parseNumstat(unstagedNumstat);
-        // Apply stats to files
         for (const file of processedFiles) {
             const stats = file.staged ? stagedStats.get(file.path) : unstagedStats.get(file.path);
             if (stats) {
@@ -218,6 +166,44 @@ export async function getHeadMessage(repoPath) {
         return '';
     }
 }
+export function stageHunk(repoPath, patch) {
+    execFileSync('git', ['apply', '--cached', '--unidiff-zero'], {
+        cwd: repoPath,
+        input: patch,
+        encoding: 'utf-8',
+    });
+}
+export function unstageHunk(repoPath, patch) {
+    execFileSync('git', ['apply', '--cached', '--reverse', '--unidiff-zero'], {
+        cwd: repoPath,
+        input: patch,
+        encoding: 'utf-8',
+    });
+}
+export async function push(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.push();
+    // Build a summary string from the push result
+    const pushed = result.pushed;
+    if (pushed.length === 0)
+        return 'Everything up-to-date';
+    return pushed.map((p) => `${p.local} → ${p.remote}`).join(', ');
+}
+export async function fetchRemote(repoPath) {
+    const git = simpleGit(repoPath);
+    await git.fetch();
+    return 'Fetch complete';
+}
+export async function pullRebase(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.pull(['--rebase']);
+    if (result.summary.changes === 0 &&
+        result.summary.insertions === 0 &&
+        result.summary.deletions === 0) {
+        return 'Already up-to-date';
+    }
+    return `${result.summary.changes} file(s) changed`;
+}
 export async function getCommitHistory(repoPath, count = 50) {
     const git = simpleGit(repoPath);
     try {
@@ -235,3 +221,74 @@ export async function getCommitHistory(repoPath, count = 50) {
         return [];
     }
 }
+export async function getStashList(repoPath) {
+    const git = simpleGit(repoPath);
+    try {
+        const result = await git.stashList();
+        return result.all.map((entry, i) => ({
+            index: i,
+            message: entry.message,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function stashSave(repoPath, message) {
+    const git = simpleGit(repoPath);
+    const args = ['push'];
+    if (message)
+        args.push('-m', message);
+    await git.stash(args);
+    return 'Stashed';
+}
+export async function stashPop(repoPath, index = 0) {
+    const git = simpleGit(repoPath);
+    await git.stash(['pop', `stash@{${index}}`]);
+    return 'Stash popped';
+}
+export async function getLocalBranches(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.branchLocal();
+    return result.all.map((name) => ({
+        name,
+        current: name === result.current,
+        tracking: result.branches[name]?.label || undefined,
+    }));
+}
+export async function switchBranch(repoPath, name) {
+    const git = simpleGit(repoPath);
+    await git.checkout(name);
+    return `Switched to ${name}`;
+}
+export async function createBranch(repoPath, name) {
+    const git = simpleGit(repoPath);
+    await git.checkoutLocalBranch(name);
+    return `Created ${name}`;
+}
+// Undo operations
+export async function softResetHead(repoPath, count = 1) {
+    const git = simpleGit(repoPath);
+    await git.reset(['--soft', `HEAD~${count}`]);
+    return 'Reset done';
+}
+// History actions
+export async function cherryPick(repoPath, hash) {
+    const git = simpleGit(repoPath);
+    await git.raw(['cherry-pick', hash]);
+    return 'Cherry-picked';
+}
+export async function revertCommit(repoPath, hash) {
+    const git = simpleGit(repoPath);
+    await git.revert(hash);
+    return 'Reverted';
+}
+/**
+ * List all files in the repo: tracked files + untracked (not ignored) files.
+ * Uses git ls-files which is fast (git already has the index in memory).
+ */
+export async function listAllFiles(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.raw(['ls-files', '-z', '--cached', '--others', '--exclude-standard']);
+    return result.split('\0').filter((f) => f.length > 0);
+}

package/dist/git/test-helpers.js

@@ -0,0 +1,67 @@
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const FIXTURES_DIR = path.resolve(import.meta.dirname, '../../test-fixtures');
+/**
+ * Create a fixture git repo with initial config.
+ */
+export function createFixtureRepo(name) {
+    const repoPath = path.join(FIXTURES_DIR, name);
+    fs.mkdirSync(repoPath, { recursive: true });
+    gitExec(repoPath, 'init --initial-branch=main');
+    gitExec(repoPath, 'config user.email "test@test.com"');
+    gitExec(repoPath, 'config user.name "Test User"');
+    return repoPath;
+}
+/**
+ * Remove a fixture repo directory.
+ */
+export function removeFixtureRepo(name) {
+    const repoPath = path.join(FIXTURES_DIR, name);
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+/**
+ * Write a file inside a fixture repo, creating parent directories as needed.
+ */
+export function writeFixtureFile(repoPath, filePath, content) {
+    const fullPath = path.join(repoPath, filePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+}
+/**
+ * Run a git command in a fixture repo.
+ */
+export function gitExec(repoPath, command) {
+    return execSync(`git ${command}`, {
+        cwd: repoPath,
+        encoding: 'utf-8',
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+}
+/**
+ * Create a bare remote repo and a cloned working repo for branch comparison tests.
+ * Returns { remotePath, repoPath }.
+ */
+export function createRepoWithRemote(name) {
+    const remotePath = path.join(FIXTURES_DIR, `${name}-remote`);
+    const repoPath = path.join(FIXTURES_DIR, name);
+    // Create bare remote
+    fs.mkdirSync(remotePath, { recursive: true });
+    gitExec(remotePath, 'init --bare --initial-branch=main');
+    // Clone it
+    execSync(`git clone "${remotePath}" "${repoPath}"`, {
+        encoding: 'utf-8',
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+    // Configure cloned repo
+    gitExec(repoPath, 'config user.email "test@test.com"');
+    gitExec(repoPath, 'config user.name "Test User"');
+    return { remotePath, repoPath };
+}
+/**
+ * Clean up both a repo and its remote.
+ */
+export function removeRepoWithRemote(name) {
+    removeFixtureRepo(name);
+    removeFixtureRepo(`${name}-remote`);
+}