@mandipadk7/kavi 0.1.0 → 0.1.2

package/dist/git.js

@@ -51,6 +51,53 @@ export async function getBranchCommit(repoRoot, ref) {
     }
     return result.stdout.trim();
 }
+function parsePathList(output) {
+    return output.split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
+}
+function uniqueSorted(values) {
+    return [
+        ...new Set(values)
+    ].sort();
+}
+async function isUntrackedPath(worktreePath, filePath) {
+    const result = await runCommand("git", [
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "--",
+        filePath
+    ], {
+        cwd: worktreePath
+    });
+    if (result.code !== 0) {
+        throw new Error(result.stderr.trim() || `Unable to inspect untracked status for ${filePath}.`);
+    }
+    return parsePathList(result.stdout).includes(filePath);
+}
+async function buildSyntheticAddedFilePatch(worktreePath, filePath) {
+    const absolutePath = path.join(worktreePath, filePath);
+    const content = await fs.readFile(absolutePath, "utf8");
+    const normalized = content.replaceAll("\r", "");
+    const endsWithNewline = normalized.endsWith("\n");
+    const lines = normalized.length === 0 ? [] : normalized.replace(/\n$/, "").split("\n");
+    const patchLines = [
+        `diff --git a/${filePath} b/${filePath}`,
+        "new file mode 100644",
+        "--- /dev/null",
+        `+++ b/${filePath}`
+    ];
+    if (lines.length > 0) {
+        patchLines.push(`@@ -0,0 +1,${lines.length} @@`);
+        patchLines.push(...lines.map((line)=>`+${line}`));
+        if (!endsWithNewline) {
+            patchLines.push("\");
+        }
+    }
+    return {
+        stat: lines.length > 0 ? `new file | ${lines.length} insertion${lines.length === 1 ? "" : "s"}(+)` : "new file | empty",
+        patch: patchLines.join("\n")
+    };
+}
 export async function resolveTargetBranch(repoRoot, configuredBranch) {
     const exists = await runCommand("git", [
         "show-ref",
@@ -149,6 +196,130 @@ export async function createGitignoreEntries(repoRoot) {
     const prefix = content.trimEnd() ? "\n" : "";
     await fs.writeFile(gitignorePath, `${content.trimEnd()}${prefix}${missing.join("\n")}\n`, "utf8");
 }
+export async function listWorktreeChangedPaths(worktreePath, baseCommit) {
+    const [committed, staged, unstaged, untracked] = await Promise.all([
+        runCommand("git", [
+            "diff",
+            "--name-only",
+            `${baseCommit}..HEAD`
+        ], {
+            cwd: worktreePath
+        }),
+        runCommand("git", [
+            "diff",
+            "--name-only",
+            "--cached"
+        ], {
+            cwd: worktreePath
+        }),
+        runCommand("git", [
+            "diff",
+            "--name-only"
+        ], {
+            cwd: worktreePath
+        }),
+        runCommand("git", [
+            "ls-files",
+            "--others",
+            "--exclude-standard"
+        ], {
+            cwd: worktreePath
+        })
+    ]);
+    const outputs = [
+        committed,
+        staged,
+        unstaged,
+        untracked
+    ];
+    const failures = outputs.filter((result)=>result.code !== 0);
+    if (failures.length > 0) {
+        throw new Error(failures.map((result)=>result.stderr.trim() || "Unable to inspect worktree changes.").join("\n"));
+    }
+    return uniqueSorted([
+        ...parsePathList(committed.stdout),
+        ...parsePathList(staged.stdout),
+        ...parsePathList(unstaged.stdout),
+        ...parsePathList(untracked.stdout)
+    ]);
+}
+export async function getWorktreeDiffReview(agent, worktreePath, baseCommit, filePath) {
+    const changedPaths = await listWorktreeChangedPaths(worktreePath, baseCommit);
+    const selectedPath = filePath && changedPaths.includes(filePath) ? filePath : changedPaths[0] ?? null;
+    if (!selectedPath) {
+        return {
+            agent,
+            changedPaths,
+            selectedPath: null,
+            stat: "No changed files in this worktree.",
+            patch: ""
+        };
+    }
+    if (await isUntrackedPath(worktreePath, selectedPath)) {
+        const synthetic = await buildSyntheticAddedFilePatch(worktreePath, selectedPath);
+        return {
+            agent,
+            changedPaths,
+            selectedPath,
+            stat: synthetic.stat,
+            patch: synthetic.patch
+        };
+    }
+    const [statResult, patchResult] = await Promise.all([
+        runCommand("git", [
+            "diff",
+            "--stat",
+            "--find-renames",
+            baseCommit,
+            "--",
+            selectedPath
+        ], {
+            cwd: worktreePath
+        }),
+        runCommand("git", [
+            "diff",
+            "--find-renames",
+            "--unified=3",
+            baseCommit,
+            "--",
+            selectedPath
+        ], {
+            cwd: worktreePath
+        })
+    ]);
+    if (statResult.code !== 0) {
+        throw new Error(statResult.stderr.trim() || `Unable to build diff stat for ${selectedPath}.`);
+    }
+    if (patchResult.code !== 0) {
+        throw new Error(patchResult.stderr.trim() || `Unable to build diff patch for ${selectedPath}.`);
+    }
+    return {
+        agent,
+        changedPaths,
+        selectedPath,
+        stat: statResult.stdout.trim() || "No diff stat available.",
+        patch: patchResult.stdout.trim() || "No textual patch available."
+    };
+}
+export async function findOverlappingWorktreePaths(worktrees, baseCommit) {
+    const pathSets = await Promise.all(worktrees.map(async (worktree)=>({
+            agent: worktree.agent,
+            paths: await listWorktreeChangedPaths(worktree.path, baseCommit)
+        })));
+    const overlaps = [];
+    for(let index = 0; index < pathSets.length; index += 1){
+        const current = pathSets[index];
+        const rest = pathSets.slice(index + 1);
+        for (const other of rest){
+            for (const filePath of current.paths){
+                if (other.paths.includes(filePath)) {
+                    overlaps.push(filePath);
+                }
+            }
+        }
+    }
+    return uniqueSorted(overlaps);
+}
 export async function landBranches(repoRoot, targetBranch, worktrees, validationCommand, sessionId, integrationRoot) {
     const commandsRun = [];
     const snapshotCommits = [];