@neuralnomads/codenomad-dev 0.14.0-dev-20260416-657e78da → 0.14.0-dev-20260418-e022a158

package/dist/server/http-server.js

@@ -7,7 +7,8 @@ import { connect as connectTcp } from "net";
 import path from "path";
 import { connect as connectTls } from "tls";
 import { fetch } from "undici";
-import { isValidWorktreeSlug, listWorktrees, resolveRepoRoot } from "../workspaces/git-worktrees";
+import { isValidWorktreeSlug } from "../workspaces/git-worktrees";
+import { resolveWorktreeDirectory } from "../workspaces/worktree-directory";
 import { registerWorkspaceRoutes } from "./routes/workspaces";
 import { registerSettingsRoutes } from "./routes/settings";
 import { registerFilesystemRoutes } from "./routes/filesystem";
@@ -602,36 +603,6 @@ function normalizeInstanceSuffix(pathSuffix) {
     const trimmed = pathSuffix.replace(/^\/+/, "");
     return trimmed.length === 0 ? "/" : `/${trimmed}`;
 }
-const WORKTREE_CACHE_TTL_MS = 2000;
-const worktreeCache = new Map();
-async function getCachedWorktrees(params) {
-    const cached = worktreeCache.get(params.workspaceId);
-    const now = Date.now();
-    if (cached && cached.expiresAt > now) {
-        return cached;
-    }
-    const { repoRoot } = await resolveRepoRoot(params.workspacePath, params.logger);
-    const worktrees = await listWorktrees({ repoRoot, workspaceFolder: params.workspacePath, logger: params.logger });
-    const entry = {
-        expiresAt: now + WORKTREE_CACHE_TTL_MS,
-        repoRoot,
-        worktrees: worktrees.map((wt) => ({ slug: wt.slug, directory: wt.directory })),
-    };
-    worktreeCache.set(params.workspaceId, entry);
-    return entry;
-}
-async function resolveWorktreeDirectory(params) {
-    const { worktreeSlug } = params;
-    const cached = await getCachedWorktrees({ workspaceId: params.workspaceId, workspacePath: params.workspacePath, logger: params.logger });
-    const match = cached.worktrees.find((wt) => wt.slug === worktreeSlug);
-    if (match) {
-        return match.directory;
-    }
-    // If the slug is new (e.g., created moments ago), refresh once.
-    worktreeCache.delete(params.workspaceId);
-    const refreshed = await getCachedWorktrees({ workspaceId: params.workspaceId, workspacePath: params.workspacePath, logger: params.logger });
-    return refreshed.worktrees.find((wt) => wt.slug === worktreeSlug)?.directory ?? null;
-}
 function setupStaticUi(app, uiDir, authManager) {
     if (!uiDir) {
         app.log.warn("UI static directory not provided; API endpoints only");

package/dist/server/routes/workspaces.js

@@ -1,4 +1,8 @@
 import { z } from "zod";
+import { getWorktreeGitDiff, getWorktreeGitStatus } from "../../workspaces/git-status";
+import { commitWorktreeChanges, isGitMutationError, stageWorktreePaths, unstageWorktreePaths } from "../../workspaces/git-mutations";
+import { isGitAvailable, resolveRepoRoot } from "../../workspaces/git-worktrees";
+import { resolveWorktreeDirectory } from "../../workspaces/worktree-directory";
 const WorkspaceCreateSchema = z.object({
     path: z.string(),
     name: z.string().optional(),
@@ -12,6 +16,17 @@ const WorkspaceFileContentQuerySchema = z.object({
 const WorkspaceFileContentBodySchema = z.object({
     contents: z.string(),
 });
+const WorktreeGitDiffQuerySchema = z.object({
+    path: z.string().trim().min(1, "Path is required"),
+    originalPath: z.string().trim().optional(),
+    scope: z.enum(["staged", "unstaged"]),
+});
+const WorktreeGitPathsBodySchema = z.object({
+    paths: z.array(z.string().trim().min(1, "Path is required")).min(1, "At least one path is required"),
+});
+const WorktreeGitCommitBodySchema = z.object({
+    message: z.string().trim().min(1, "Commit message is required"),
+});
 const WorkspaceFileSearchQuerySchema = z.object({
     q: z.string().trim().min(1, "Query is required"),
     limit: z.coerce.number().int().positive().max(200).optional(),
@@ -92,8 +107,111 @@ export function registerWorkspaceRoutes(app, deps) {
             return handleWorkspaceError(error, reply);
         }
     });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-status", async (request, reply) => {
+        try {
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitStatus({ workspaceFolder: directory, logger: request.log });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.get("/api/workspaces/:id/worktrees/:slug/git-diff", async (request, reply) => {
+        try {
+            const query = WorktreeGitDiffQuerySchema.parse(request.query ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            return await getWorktreeGitDiff({
+                workspaceFolder: directory,
+                path: query.path,
+                originalPath: query.originalPath,
+                scope: query.scope,
+            });
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-stage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await stageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-unstage", async (request, reply) => {
+        try {
+            const body = WorktreeGitPathsBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            await unstageWorktreePaths({ workspaceFolder: directory, paths: body.paths });
+            return { ok: true };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+    app.post("/api/workspaces/:id/worktrees/:slug/git-commit", async (request, reply) => {
+        try {
+            const body = WorktreeGitCommitBodySchema.parse(request.body ?? {});
+            const directory = await resolveGitWorktreeDirectory(deps.workspaceManager, request.params.id, request.params.slug, request.log, reply);
+            if (!directory)
+                return;
+            const result = await commitWorktreeChanges({ workspaceFolder: directory, message: body.message });
+            return { ok: true, ...result };
+        }
+        catch (error) {
+            return handleWorkspaceError(error, reply);
+        }
+    });
+}
+async function resolveGitWorktreeDirectory(workspaceManager, workspaceId, worktreeSlug, logger, reply) {
+    const workspace = workspaceManager.get(workspaceId);
+    if (!workspace) {
+        reply.code(404);
+        reply.send({ error: "Workspace not found" });
+        return null;
+    }
+    const gitAvailable = await isGitAvailable(workspace.path);
+    if (!gitAvailable) {
+        reply.code(503);
+        reply.send({ error: "Git is not installed or not available in PATH" });
+        return null;
+    }
+    const { isGitRepo } = await resolveRepoRoot(workspace.path, logger);
+    if (!isGitRepo) {
+        reply.code(400);
+        reply.send({ error: "Workspace is not a Git repository" });
+        return null;
+    }
+    const directory = await resolveWorktreeDirectory({
+        workspaceId: workspace.id,
+        workspacePath: workspace.path,
+        worktreeSlug,
+        logger,
+    });
+    if (!directory) {
+        reply.code(404);
+        reply.send({ error: "Worktree not found" });
+        return null;
+    }
+    return directory;
 }
 function handleWorkspaceError(error, reply) {
+    if (isGitMutationError(error)) {
+        reply.code(error.statusCode);
+        return { error: error.message };
+    }
     if (error instanceof Error && error.message === "Workspace not found") {
         reply.code(404);
         return { error: "Workspace not found" };

package/dist/workspaces/git-mutations.js

@@ -0,0 +1,98 @@
+import { spawn } from "child_process";
+import path from "path";
+class GitMutationError extends Error {
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.name = "GitMutationError";
+        this.statusCode = statusCode;
+    }
+}
+function runGit(args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", (error) => {
+            resolve({ ok: false, error, stdout, stderr });
+        });
+        child.once("close", (code) => {
+            if (code === 0) {
+                resolve({ ok: true, stdout });
+            }
+            else {
+                const error = new Error(stderr.trim() || `git ${args.join(" ")} failed with code ${code}`);
+                resolve({ ok: false, error, stdout, stderr });
+            }
+        });
+    });
+}
+export function normalizeGitWorktreeRelativePath(input) {
+    const normalized = input.trim().replace(/\\+/g, "/").replace(/^\.\//, "");
+    if (!normalized) {
+        throw new GitMutationError("Path is required", 400);
+    }
+    if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(normalized)) {
+        throw new GitMutationError(`Absolute paths are not allowed: ${input}`, 400);
+    }
+    if (normalized === "." || normalized === "..") {
+        throw new GitMutationError(`Invalid path: ${input}`, 400);
+    }
+    if (normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..")) {
+        throw new GitMutationError(`Path traversal is not allowed: ${input}`, 400);
+    }
+    return normalized;
+}
+function normalizeGitMutationPaths(paths) {
+    const deduped = new Set();
+    for (const rawPath of paths) {
+        deduped.add(normalizeGitWorktreeRelativePath(rawPath));
+    }
+    const normalized = Array.from(deduped);
+    if (normalized.length === 0) {
+        throw new GitMutationError("At least one path is required", 400);
+    }
+    return normalized;
+}
+async function ensureGitCommandSucceeded(resultPromise, fallbackMessage) {
+    const result = await resultPromise;
+    if (!result.ok) {
+        const message = result.stderr?.trim() || result.error.message || fallbackMessage;
+        throw new GitMutationError(message, 409);
+    }
+    return result.stdout;
+}
+export function isGitMutationError(error) {
+    return error instanceof GitMutationError;
+}
+export async function stageWorktreePaths(params) {
+    const paths = normalizeGitMutationPaths(params.paths);
+    await ensureGitCommandSucceeded(runGit(["add", "--", ...paths], params.workspaceFolder), "Failed to stage files");
+}
+export async function unstageWorktreePaths(params) {
+    const paths = normalizeGitMutationPaths(params.paths);
+    const headResult = await runGit(["rev-parse", "--verify", "HEAD"], params.workspaceFolder);
+    if (headResult.ok) {
+        await ensureGitCommandSucceeded(runGit(["restore", "--staged", "--", ...paths], params.workspaceFolder), "Failed to unstage files");
+        return;
+    }
+    await ensureGitCommandSucceeded(runGit(["rm", "--cached", "--quiet", "--", ...paths], params.workspaceFolder), "Failed to unstage files");
+}
+export async function commitWorktreeChanges(params) {
+    const message = params.message.trim();
+    if (!message) {
+        throw new GitMutationError("Commit message is required", 400);
+    }
+    await ensureGitCommandSucceeded(runGit(["commit", "-m", message], params.workspaceFolder), "Failed to create commit");
+    const shaResult = await runGit(["rev-parse", "HEAD"], params.workspaceFolder);
+    if (!shaResult.ok) {
+        return {};
+    }
+    const commitSha = shaResult.stdout.trim();
+    return commitSha ? { commitSha } : {};
+}

package/dist/workspaces/git-status.js

@@ -0,0 +1,323 @@
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import path from "path";
+import { normalizeGitWorktreeRelativePath } from "./git-mutations";
+async function readFileAsDiffText(filePath) {
+    return readFile(filePath, "utf-8");
+}
+async function readGitBlobAsDiffText(resultPromise, missingOk = false) {
+    const result = await resultPromise;
+    if (!result.ok) {
+        return decodeGitShowResult(result, missingOk);
+    }
+    return result.stdout;
+}
+function runGit(args, cwd, acceptedExitCodes = [0]) {
+    return new Promise((resolve) => {
+        const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once("error", (error) => {
+            resolve({ ok: false, error, stdout, stderr });
+        });
+        child.once("close", (code) => {
+            if (acceptedExitCodes.includes(code ?? 0)) {
+                resolve({ ok: true, stdout });
+            }
+            else {
+                const error = new Error(stderr.trim() || `git ${args.join(" ")} failed with code ${code}`);
+                resolve({ ok: false, error, stdout, stderr });
+            }
+        });
+    });
+}
+function ensureEntry(map, path) {
+    const existing = map.get(path);
+    if (existing)
+        return existing;
+    const next = {
+        path,
+        originalPath: null,
+        stagedStatus: null,
+        stagedAdditions: 0,
+        stagedDeletions: 0,
+        unstagedStatus: null,
+        unstagedAdditions: 0,
+        unstagedDeletions: 0,
+    };
+    map.set(path, next);
+    return next;
+}
+function normalizeGitStatusPath(value) {
+    return value.trim().replace(/\\+/g, "/");
+}
+function parseGitChangeKind(code) {
+    const normalized = code.trim().toUpperCase();
+    if (!normalized)
+        return null;
+    if (normalized === "A")
+        return "added";
+    if (normalized === "M")
+        return "modified";
+    if (normalized === "D")
+        return "deleted";
+    if (normalized.startsWith("R"))
+        return "renamed";
+    if (normalized.startsWith("C"))
+        return "copied";
+    if (normalized === "U")
+        return "unmerged";
+    return null;
+}
+function applyNameStatusOutput(map, output, target) {
+    const tokens = output.split("\0");
+    let index = 0;
+    while (index < tokens.length) {
+        const record = tokens[index++] ?? "";
+        if (!record)
+            continue;
+        const parts = record.split("\t");
+        const statusCode = parseGitChangeKind(parts[0] ?? "");
+        if (!statusCode)
+            continue;
+        const inlinePath = parts.slice(1).join("\t");
+        const firstPath = inlinePath || tokens[index++] || "";
+        const secondPath = statusCode === "renamed" || statusCode === "copied" ? tokens[index++] || "" : "";
+        const path = statusCode === "renamed" || statusCode === "copied" ? secondPath || firstPath : firstPath;
+        const normalizedPath = normalizeGitStatusPath(path);
+        if (!normalizedPath)
+            continue;
+        const entry = ensureEntry(map, normalizedPath);
+        entry[target] = statusCode;
+        if (statusCode === "renamed" || statusCode === "copied") {
+            const originalPath = normalizeGitStatusPath(firstPath);
+            entry.originalPath = originalPath || entry.originalPath || null;
+        }
+    }
+}
+function applyUntrackedOutput(map, output) {
+    for (const rawLine of output.split(/\r?\n/)) {
+        const path = normalizeGitStatusPath(rawLine);
+        if (!path)
+            continue;
+        ensureEntry(map, path).unstagedStatus = "untracked";
+    }
+}
+function parseSingleNumstat(output) {
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const parts = rawLine.split("\t");
+        const isBinary = parts[0] === "-" || parts[1] === "-";
+        return {
+            additions: isBinary ? 0 : Number.parseInt(parts[0] ?? "0", 10) || 0,
+            deletions: isBinary ? 0 : Number.parseInt(parts[1] ?? "0", 10) || 0,
+            isBinary,
+            found: true,
+        };
+    }
+    return { additions: 0, deletions: 0, isBinary: false, found: false };
+}
+async function getUntrackedFileNumstat(workspaceFolder, relativePath) {
+    const absolutePath = path.join(workspaceFolder, relativePath);
+    const result = await runGit(["diff", "--numstat", "--no-index", "--", "/dev/null", absolutePath], workspaceFolder, [0, 1]);
+    if (!result.ok) {
+        throw result.error;
+    }
+    const parsed = parseSingleNumstat(result.stdout);
+    return { additions: parsed.additions, deletions: parsed.deletions };
+}
+async function applyUntrackedFileStats(map, workspaceFolder) {
+    const pending = Array.from(map.values())
+        .filter((entry) => entry.unstagedStatus === "untracked")
+        .map(async (entry) => {
+        try {
+            const stats = await getUntrackedFileNumstat(workspaceFolder, entry.path);
+            entry.unstagedAdditions = stats.additions;
+            entry.unstagedDeletions = stats.deletions;
+        }
+        catch {
+            entry.unstagedAdditions = 0;
+            entry.unstagedDeletions = 0;
+        }
+    });
+    await Promise.all(pending);
+}
+function applyNumstatOutput(map, output, target) {
+    const tokens = output.split("\0");
+    let index = 0;
+    while (index < tokens.length) {
+        const record = tokens[index++] ?? "";
+        if (!record)
+            continue;
+        const parts = record.split("\t");
+        if (parts.length < 3)
+            continue;
+        const additions = parts[0] === "-" ? 0 : Number.parseInt(parts[0] ?? "0", 10);
+        const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1] ?? "0", 10);
+        const inlinePath = parts.slice(2).join("\t");
+        const isRenameLike = inlinePath === "";
+        const originalPath = isRenameLike ? normalizeGitStatusPath(tokens[index++] ?? "") : null;
+        const normalizedPath = normalizeGitStatusPath(isRenameLike ? tokens[index++] ?? "" : inlinePath);
+        if (!normalizedPath)
+            continue;
+        const entry = ensureEntry(map, normalizedPath);
+        if (originalPath) {
+            entry.originalPath = originalPath;
+        }
+        if (target === "staged") {
+            entry.stagedAdditions = Number.isFinite(additions) ? additions : 0;
+            entry.stagedDeletions = Number.isFinite(deletions) ? deletions : 0;
+        }
+        else {
+            entry.unstagedAdditions = Number.isFinite(additions) ? additions : 0;
+            entry.unstagedDeletions = Number.isFinite(deletions) ? deletions : 0;
+        }
+    }
+}
+export async function getWorktreeGitStatus(params) {
+    const { workspaceFolder, logger } = params;
+    const [stagedResult, unstagedResult, untrackedResult, stagedNumstatResult, unstagedNumstatResult] = await Promise.all([
+        runGit(["diff", "--name-status", "-z", "--cached", "--find-renames", "--find-copies"], workspaceFolder),
+        runGit(["diff", "--name-status", "-z", "--find-renames", "--find-copies"], workspaceFolder),
+        runGit(["ls-files", "--others", "--exclude-standard"], workspaceFolder),
+        runGit(["diff", "--numstat", "-z", "--cached", "--find-renames", "--find-copies"], workspaceFolder),
+        runGit(["diff", "--numstat", "-z", "--find-renames", "--find-copies"], workspaceFolder),
+    ]);
+    for (const result of [stagedResult, unstagedResult, untrackedResult, stagedNumstatResult, unstagedNumstatResult]) {
+        if (!result.ok) {
+            logger?.warn?.({ workspaceFolder, err: result.error }, "Failed to read git status for worktree");
+            throw result.error;
+        }
+    }
+    const stagedOutput = stagedResult.stdout;
+    const unstagedOutput = unstagedResult.stdout;
+    const untrackedOutput = untrackedResult.stdout;
+    const stagedNumstatOutput = stagedNumstatResult.stdout;
+    const unstagedNumstatOutput = unstagedNumstatResult.stdout;
+    const entries = new Map();
+    applyNameStatusOutput(entries, stagedOutput, "stagedStatus");
+    applyNameStatusOutput(entries, unstagedOutput, "unstagedStatus");
+    applyUntrackedOutput(entries, untrackedOutput);
+    applyNumstatOutput(entries, stagedNumstatOutput, "staged");
+    applyNumstatOutput(entries, unstagedNumstatOutput, "unstaged");
+    await applyUntrackedFileStats(entries, workspaceFolder);
+    return Array.from(entries.values()).sort((a, b) => a.path.localeCompare(b.path));
+}
+function decodeGitShowResult(result, missingOk = false) {
+    if (result.ok)
+        return result.stdout;
+    const message = result.stderr?.trim() || result.error.message || "";
+    if (missingOk &&
+        (message.includes("exists on disk, but not in") ||
+            message.includes("Path '") ||
+            message.includes("does not exist") ||
+            message.includes("unknown revision or path not in the working tree"))) {
+        return "";
+    }
+    throw result.error;
+}
+async function readGitIndexBlob(workspaceFolder, normalizedPath) {
+    return runGit(["cat-file", "-p", `:${normalizedPath}`], workspaceFolder);
+}
+async function getTrackedDiffMetadata(params) {
+    const args = ["diff", "--numstat"];
+    if (params.scope === "staged") {
+        args.push("--cached");
+    }
+    args.push("--find-renames", "--find-copies", "--");
+    args.push(params.normalizedPath);
+    if (params.normalizedOriginalPath && params.normalizedOriginalPath !== params.normalizedPath) {
+        args.push(params.normalizedOriginalPath);
+    }
+    const result = await runGit(args, params.workspaceFolder);
+    if (!result.ok) {
+        throw result.error;
+    }
+    const parsed = parseSingleNumstat(result.stdout);
+    return { isBinary: parsed.isBinary, found: parsed.found };
+}
+async function getUntrackedDiffMetadata(params) {
+    const absolutePath = path.join(params.workspaceFolder, params.normalizedPath);
+    const result = await runGit(["diff", "--numstat", "--no-index", "--", "/dev/null", absolutePath], params.workspaceFolder, [0, 1]);
+    if (!result.ok) {
+        throw result.error;
+    }
+    return { isBinary: parseSingleNumstat(result.stdout).isBinary };
+}
+async function resolveUnstagedBeforePath(params) {
+    const currentPathResult = await readGitIndexBlob(params.workspaceFolder, params.normalizedPath);
+    if (currentPathResult.ok || !params.normalizedOriginalPath || params.normalizedOriginalPath === params.normalizedPath) {
+        return currentPathResult;
+    }
+    return readGitIndexBlob(params.workspaceFolder, params.normalizedOriginalPath);
+}
+export async function getWorktreeGitDiff(params) {
+    const normalizedPath = normalizeGitWorktreeRelativePath(params.path);
+    const normalizedOriginalPath = params.originalPath ? normalizeGitWorktreeRelativePath(params.originalPath) : null;
+    const trackedMetadata = await getTrackedDiffMetadata({
+        workspaceFolder: params.workspaceFolder,
+        scope: params.scope,
+        normalizedPath,
+        normalizedOriginalPath,
+    });
+    const diffMetadata = params.scope === "unstaged" && !trackedMetadata.found
+        ? await getUntrackedDiffMetadata({
+            workspaceFolder: params.workspaceFolder,
+            normalizedPath,
+        })
+        : trackedMetadata;
+    if (diffMetadata.isBinary) {
+        return {
+            path: normalizedPath,
+            originalPath: normalizedOriginalPath,
+            scope: params.scope,
+            before: "",
+            after: "",
+            isBinary: true,
+        };
+    }
+    if (params.scope === "staged") {
+        const [beforeResult, afterResult] = await Promise.all([
+            readGitBlobAsDiffText(runGit(["show", `HEAD:${normalizedOriginalPath ?? normalizedPath}`], params.workspaceFolder), true),
+            readGitBlobAsDiffText(readGitIndexBlob(params.workspaceFolder, normalizedPath), true),
+        ]);
+        return {
+            path: normalizedPath,
+            originalPath: normalizedOriginalPath,
+            scope: params.scope,
+            before: beforeResult,
+            after: afterResult,
+            isBinary: false,
+        };
+    }
+    const indexResult = await resolveUnstagedBeforePath({
+        workspaceFolder: params.workspaceFolder,
+        normalizedPath,
+        normalizedOriginalPath,
+    });
+    const beforeResult = await readGitBlobAsDiffText(Promise.resolve(indexResult), true);
+    let after = beforeResult;
+    const fsPath = path.join(params.workspaceFolder, normalizedPath);
+    try {
+        after = await readFileAsDiffText(fsPath);
+    }
+    catch {
+        after = "";
+    }
+    return {
+        path: normalizedPath,
+        originalPath: normalizedOriginalPath,
+        scope: params.scope,
+        before: beforeResult,
+        after,
+        isBinary: false,
+    };
+}

package/dist/workspaces/git-worktrees.js

@@ -1,6 +1,9 @@
 import path from "path";
 import { spawn } from "child_process";
 import { promises as fsp } from "fs";
+function isGitUnavailableResult(result) {
+    return !result.ok && result.error?.code === "ENOENT";
+}
 function runGit(args, cwd) {
     return new Promise((resolve) => {
         const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
@@ -28,6 +31,9 @@ function runGit(args, cwd) {
 }
 export async function resolveRepoRoot(folder, logger) {
     const result = await runGit(["rev-parse", "--show-toplevel"], folder);
+    if (isGitUnavailableResult(result)) {
+        throw new Error("Git is not installed or not available in PATH");
+    }
     if (!result.ok) {
         logger?.debug?.({ folder, err: result.error }, "Folder is not a Git repository; using workspace folder as root");
         return { repoRoot: folder, isGitRepo: false };
@@ -38,6 +44,10 @@ export async function resolveRepoRoot(folder, logger) {
     }
     return { repoRoot, isGitRepo: true };
 }
+export async function isGitAvailable(folder) {
+    const result = await runGit(["--version"], folder);
+    return result.ok || !isGitUnavailableResult(result);
+}
 function parseWorktreePorcelain(output) {
     const records = [];
     const lines = output.split(/\r?\n/);
@@ -75,13 +85,20 @@ function parseWorktreePorcelain(output) {
 }
 export async function listWorktrees(params) {
     const { repoRoot, workspaceFolder, logger } = params;
-    const rootDescriptor = { slug: "root", directory: repoRoot, kind: "root" };
     const result = await runGit(["worktree", "list", "--porcelain"], workspaceFolder);
     if (!result.ok) {
+        const rootDescriptor = { slug: "root", directory: repoRoot, kind: "root" };
         logger?.debug?.({ repoRoot, err: result.error }, "Failed to list git worktrees; returning root only");
         return [rootDescriptor];
     }
     const records = parseWorktreePorcelain(result.stdout);
+    const rootRecord = records.find((record) => path.resolve(record.worktree) === path.resolve(repoRoot));
+    const rootDescriptor = {
+        slug: "root",
+        directory: repoRoot,
+        kind: "root",
+        branch: rootRecord?.branch,
+    };
     const worktrees = [rootDescriptor];
     const seen = new Set(["root"]);
     const normalizeSlug = (record) => {