doer-agent 0.4.2 → 0.4.3

package/dist/agent-fs-rpc.js

@@ -0,0 +1,402 @@
+import path from "node:path";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { mkdir, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { StringCodec } from "nats";
+const fsRpcCodec = StringCodec();
+function normalizeFsRpcPath(workspaceRoot, rawPath) {
+    const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
+    const normalizedRaw = raw.replace(/\\/g, "/");
+    const useAbsolute = path.isAbsolute(normalizedRaw);
+    const rel = normalizedRaw.replace(/^\/+/, "") || ".";
+    const abs = useAbsolute ? path.resolve(normalizedRaw) : path.resolve(workspaceRoot, rel);
+    if (!useAbsolute && abs !== workspaceRoot && !abs.startsWith(workspaceRoot + path.sep)) {
+        throw new Error("path escapes workspace root");
+    }
+    const formatPath = (target) => {
+        if (useAbsolute) {
+            return target.split(path.sep).join("/") || "/";
+        }
+        return path.relative(workspaceRoot, target).split(path.sep).join("/") || ".";
+    };
+    return { abs, formatPath };
+}
+function parseFsRpcAction(value) {
+    if (value === "list" ||
+        value === "stat" ||
+        value === "fetch_file" ||
+        value === "read_text" ||
+        value === "read_file" ||
+        value === "write_file" ||
+        value === "download_file" ||
+        value === "delete_path" ||
+        value === "archive_dir" ||
+        value === "extract_archive") {
+        return value;
+    }
+    throw new Error("unsupported action");
+}
+function normalizeFsRpcNumber(value, fallback) {
+    const n = Number(value);
+    if (!Number.isFinite(n)) {
+        return fallback;
+    }
+    return Math.floor(n);
+}
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".txt" || ext === ".md" || ext === ".log") {
+        return "text/plain";
+    }
+    if (ext === ".json") {
+        return "application/json";
+    }
+    if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+        return "text/javascript";
+    }
+    if (ext === ".ts" || ext === ".tsx") {
+        return "text/typescript";
+    }
+    if (ext === ".jsx") {
+        return "text/jsx";
+    }
+    if (ext === ".css") {
+        return "text/css";
+    }
+    if (ext === ".html" || ext === ".htm") {
+        return "text/html";
+    }
+    if (ext === ".xml") {
+        return "application/xml";
+    }
+    if (ext === ".svg") {
+        return "image/svg+xml";
+    }
+    if (ext === ".png") {
+        return "image/png";
+    }
+    if (ext === ".jpg" || ext === ".jpeg") {
+        return "image/jpeg";
+    }
+    if (ext === ".gif") {
+        return "image/gif";
+    }
+    if (ext === ".webp") {
+        return "image/webp";
+    }
+    if (ext === ".pdf") {
+        return "application/pdf";
+    }
+    return "application/octet-stream";
+}
+function normalizeArchiveRelativePath(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    if (!normalized || normalized.includes("..")) {
+        throw new Error("invalid archive entry path");
+    }
+    return normalized;
+}
+async function collectDirectoryFiles(absDir, rootDir = absDir) {
+    const rows = await readdir(absDir, { withFileTypes: true });
+    const files = [];
+    for (const row of rows.sort((a, b) => a.name.localeCompare(b.name))) {
+        const child = path.join(absDir, row.name);
+        if (row.isDirectory()) {
+            files.push(...await collectDirectoryFiles(child, rootDir));
+            continue;
+        }
+        if (!row.isFile()) {
+            continue;
+        }
+        const bytes = await readFile(child);
+        files.push({
+            relPath: normalizeArchiveRelativePath(path.relative(rootDir, child)),
+            contentBase64: Buffer.from(bytes).toString("base64"),
+            sizeBytes: bytes.byteLength,
+        });
+    }
+    return files;
+}
+async function executeFsRpc(args) {
+    const action = parseFsRpcAction(args.request.action);
+    const { abs, formatPath } = normalizeFsRpcPath(args.workspaceRoot, args.request.path);
+    if (action === "stat") {
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            kind: entry.isDirectory() ? "dir" : "file",
+            size: entry.size,
+            mtimeMs: entry.mtimeMs,
+        };
+    }
+    if (action === "list") {
+        const entry = await stat(abs);
+        if (!entry.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        const limit = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.limit, 200), 1000));
+        const rows = await readdir(abs, { withFileTypes: true });
+        const items = await Promise.all(rows.map(async (row) => {
+            const child = path.join(abs, row.name);
+            const childStat = await stat(child);
+            return {
+                name: row.name,
+                path: formatPath(child),
+                kind: row.isDirectory() ? "dir" : "file",
+                size: childStat.size,
+                mtimeMs: childStat.mtimeMs,
+            };
+        }));
+        items.sort((a, b) => (a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "dir" ? -1 : 1));
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            items: items.slice(0, limit),
+            truncated: items.length > limit,
+            total: items.length,
+        };
+    }
+    if (action === "archive_dir") {
+        const entry = await stat(abs);
+        if (!entry.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        const rawArchivePath = typeof args.request.archivePath === "string" ? args.request.archivePath : "";
+        if (!rawArchivePath) {
+            throw new Error("archivePath is required");
+        }
+        const archiveTarget = normalizeFsRpcPath(args.workspaceRoot, rawArchivePath);
+        const files = await collectDirectoryFiles(abs);
+        if (!files.some((file) => file.relPath === "SKILL.md")) {
+            throw new Error("Selected skill directory must contain SKILL.md");
+        }
+        const payload = gzipSync(Buffer.from(JSON.stringify({ files }), "utf8"));
+        await mkdir(path.dirname(archiveTarget.abs), { recursive: true });
+        await writeFile(archiveTarget.abs, payload);
+        const archiveStat = await stat(archiveTarget.abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            archivePath: archiveTarget.formatPath(archiveTarget.abs),
+            size: archiveStat.size,
+        };
+    }
+    if (action === "fetch_file") {
+        const entry = await stat(abs);
+        if (!entry.isFile()) {
+            throw new Error("path is not a file");
+        }
+        const uploadUrl = typeof args.request.uploadUrl === "string" ? args.request.uploadUrl : "";
+        const agentId = typeof args.request.agentId === "string" ? args.request.agentId : "";
+        if (!uploadUrl || !agentId) {
+            throw new Error("missing upload parameters");
+        }
+        const resolvedUploadUrl = new URL(uploadUrl, `${args.serverBaseUrl}/`).toString();
+        const data = await readFile(abs);
+        const fileName = path.basename(abs) || "file";
+        const form = new FormData();
+        form.append("file", new File([data], fileName));
+        form.append("agentId", agentId);
+        const response = await fetch(resolvedUploadUrl, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${args.agentToken}` },
+            body: form,
+        });
+        const text = await response.text();
+        let upload = {};
+        try {
+            upload = JSON.parse(text || "{}");
+        }
+        catch {
+            upload = {};
+        }
+        if (!response.ok) {
+            const message = typeof upload.error === "string" ? upload.error : `upload failed: ${response.status}`;
+            throw new Error(message);
+        }
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            size: entry.size,
+            upload,
+        };
+    }
+    if (action === "write_file") {
+        const contentBase64 = typeof args.request.contentBase64 === "string" ? args.request.contentBase64 : "";
+        if (!contentBase64) {
+            throw new Error("contentBase64 is required");
+        }
+        const parentDir = path.dirname(abs);
+        await mkdir(parentDir, { recursive: true });
+        const bytes = Buffer.from(contentBase64, "base64");
+        await writeFile(abs, bytes);
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+            size: entry.size,
+            mimeType: inferMimeType(abs),
+            mtimeMs: entry.mtimeMs,
+        };
+    }
+    if (action === "delete_path") {
+        await rm(abs, { recursive: true, force: true });
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+        };
+    }
+    if (action === "download_file") {
+        const downloadPath = typeof args.request.downloadPath === "string" ? args.request.downloadPath.trim() : "";
+        if (!downloadPath) {
+            throw new Error("downloadPath is required");
+        }
+        const downloadUrl = new URL(downloadPath, `${args.serverBaseUrl}/`).toString();
+        const response = await fetch(downloadUrl, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${args.agentToken}`,
+            },
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new Error(text || `download failed: ${response.status}`);
+        }
+        const bytes = Buffer.from(await response.arrayBuffer());
+        const parentDir = path.dirname(abs);
+        await mkdir(parentDir, { recursive: true });
+        await writeFile(abs, bytes);
+        const entry = await stat(abs);
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: abs.split(path.sep).join("/"),
+            size: entry.size,
+            mimeType: inferMimeType(abs),
+            mtimeMs: entry.mtimeMs,
+        };
+    }
+    if (action === "extract_archive") {
+        const archiveEntry = await stat(abs);
+        if (!archiveEntry.isFile()) {
+            throw new Error("path is not a file");
+        }
+        const rawDestinationPath = typeof args.request.destinationPath === "string" ? args.request.destinationPath : "";
+        if (!rawDestinationPath) {
+            throw new Error("destinationPath is required");
+        }
+        const destinationTarget = normalizeFsRpcPath(args.workspaceRoot, rawDestinationPath);
+        const archiveBytes = await readFile(abs);
+        const decoded = JSON.parse(gunzipSync(archiveBytes).toString("utf8"));
+        const files = Array.isArray(decoded.files) ? decoded.files : [];
+        await mkdir(destinationTarget.abs, { recursive: true });
+        for (const file of files) {
+            const relPath = typeof file.relPath === "string" ? normalizeArchiveRelativePath(file.relPath) : "";
+            const contentBase64 = typeof file.contentBase64 === "string" ? file.contentBase64 : "";
+            if (!relPath || !contentBase64) {
+                throw new Error("archive contains an invalid file entry");
+            }
+            const targetPath = path.join(destinationTarget.abs, relPath);
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, Buffer.from(contentBase64, "base64"));
+        }
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            absolutePath: destinationTarget.formatPath(destinationTarget.abs),
+        };
+    }
+    const entry = await stat(abs);
+    if (!entry.isFile()) {
+        throw new Error("path is not a file");
+    }
+    if (action === "read_file") {
+        const maxBytes = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.maxBytes, 2_000_000), 5_000_000));
+        const data = await readFile(abs);
+        const truncated = data.byteLength > maxBytes;
+        const bytes = truncated ? data.subarray(0, maxBytes) : data;
+        return {
+            ok: true,
+            action,
+            path: formatPath(abs),
+            mimeType: inferMimeType(abs),
+            size: entry.size,
+            truncated,
+            contentBase64: bytes.toString("base64"),
+        };
+    }
+    const offset = Math.max(0, normalizeFsRpcNumber(args.request.offset, 0));
+    const length = Math.max(1, Math.min(normalizeFsRpcNumber(args.request.length, 65536), 262144));
+    const encoding = typeof args.request.encoding === "string" && args.request.encoding ? args.request.encoding : "utf8";
+    const fd = await open(abs, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const readResult = await fd.read(buffer, 0, length, offset);
+        const slice = buffer.subarray(0, readResult.bytesRead);
+        try {
+            const text = slice.toString(encoding);
+            return {
+                ok: true,
+                action,
+                path: formatPath(abs),
+                offset,
+                length: readResult.bytesRead,
+                totalSize: entry.size,
+                eof: offset + readResult.bytesRead >= entry.size,
+                encoding,
+                text,
+                bytesRead: readResult.bytesRead,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to decode text";
+            return {
+                ok: false,
+                action,
+                path: formatPath(abs),
+                error: message,
+            };
+        }
+    }
+    finally {
+        await fd.close();
+    }
+}
+export async function handleFsRpcMessage(args) {
+    let payload = {};
+    try {
+        payload = JSON.parse(fsRpcCodec.decode(args.msg.data));
+        if (typeof payload.agentId === "string" && payload.agentId.trim() && payload.agentId !== args.agentId) {
+            throw new Error("agent id mismatch");
+        }
+        const result = await executeFsRpc({
+            workspaceRoot: args.workspaceRoot,
+            request: payload,
+            serverBaseUrl: args.serverBaseUrl,
+            agentToken: args.agentToken,
+        });
+        args.msg.respond(fsRpcCodec.encode(JSON.stringify(result)));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        const action = typeof payload.action === "string" ? payload.action : "";
+        const response = {
+            ok: false,
+            action,
+            path: typeof payload.path === "string" ? payload.path : ".",
+            error: message,
+        };
+        args.msg.respond(fsRpcCodec.encode(JSON.stringify(response)));
+        args.onError(`fs rpc failed action=${action || "unknown"} error=${message}`);
+    }
+}

package/dist/agent-git-rpc.js

@@ -0,0 +1,299 @@
+import { spawn } from "node:child_process";
+import { StringCodec } from "nats";
+const gitRpcCodec = StringCodec();
+function runLocalCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+function sanitizeGitRef(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("-") || /\s/.test(trimmed) || trimmed.includes("..") || trimmed.includes(":")) {
+        throw new Error(`Invalid git ref: ${trimmed}`);
+    }
+    return trimmed;
+}
+function sanitizeGitPathspec(value) {
+    if (typeof value !== "string") {
+        throw new Error("Invalid pathspec");
+    }
+    const trimmed = value.trim().replace(/\\/g, "/");
+    if (!trimmed || trimmed.startsWith("-") || trimmed.includes("\0")) {
+        throw new Error(`Invalid pathspec: ${trimmed}`);
+    }
+    return trimmed;
+}
+function normalizeGitRpcRequest(args) {
+    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
+    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
+    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
+    const targetPath = typeof args.request.targetPath === "string" ? args.request.targetPath.trim() : "";
+    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId || !targetPath) {
+        throw new Error("invalid git rpc request");
+    }
+    const format = args.request.format === "name-only" ||
+        args.request.format === "name-status" ||
+        args.request.format === "stat" ||
+        args.request.format === "numstat" ||
+        args.request.format === "raw"
+        ? args.request.format
+        : "patch";
+    const ignoreWhitespace = args.request.ignoreWhitespace === "at-eol" ||
+        args.request.ignoreWhitespace === "change" ||
+        args.request.ignoreWhitespace === "all"
+        ? args.request.ignoreWhitespace
+        : "none";
+    const diffAlgorithm = args.request.diffAlgorithm === "minimal" ||
+        args.request.diffAlgorithm === "patience" ||
+        args.request.diffAlgorithm === "histogram"
+        ? args.request.diffAlgorithm
+        : "default";
+    const contextRaw = Number(args.request.contextLines);
+    const contextLines = Number.isFinite(contextRaw) ? Math.max(0, Math.min(200, Math.trunc(contextRaw))) : null;
+    const pathspecs = Array.isArray(args.request.pathspecs) ? args.request.pathspecs.map((item) => sanitizeGitPathspec(item)) : [];
+    return {
+        requestId,
+        responseSubject,
+        targetPath,
+        base: sanitizeGitRef(args.request.base),
+        target: sanitizeGitRef(args.request.target),
+        mergeBase: args.request.mergeBase === true,
+        staged: args.request.staged === true,
+        format,
+        contextLines,
+        ignoreWhitespace,
+        diffAlgorithm,
+        findRenames: args.request.findRenames === true,
+        pathspecs,
+    };
+}
+function buildAgentGitDiffArgs(repoRootAbs, request) {
+    const args = ["-C", repoRootAbs, "diff", "--no-color"];
+    const displayParts = ["git", "diff", "--no-color"];
+    if (request.staged) {
+        args.push("--cached");
+        displayParts.push("--cached");
+    }
+    if (typeof request.contextLines === "number") {
+        args.push(`-U${request.contextLines}`);
+        displayParts.push(`-U${request.contextLines}`);
+    }
+    if (request.ignoreWhitespace === "at-eol") {
+        args.push("--ignore-space-at-eol");
+        displayParts.push("--ignore-space-at-eol");
+    }
+    else if (request.ignoreWhitespace === "change") {
+        args.push("--ignore-space-change");
+        displayParts.push("--ignore-space-change");
+    }
+    else if (request.ignoreWhitespace === "all") {
+        args.push("--ignore-all-space");
+        displayParts.push("--ignore-all-space");
+    }
+    if (request.diffAlgorithm !== "default") {
+        args.push(`--diff-algorithm=${request.diffAlgorithm}`);
+        displayParts.push(`--diff-algorithm=${request.diffAlgorithm}`);
+    }
+    if (request.findRenames) {
+        args.push("--find-renames");
+        displayParts.push("--find-renames");
+    }
+    if (request.format === "name-only") {
+        args.push("--name-only");
+        displayParts.push("--name-only");
+    }
+    else if (request.format === "name-status") {
+        args.push("--name-status");
+        displayParts.push("--name-status");
+    }
+    else if (request.format === "stat") {
+        args.push("--stat");
+        displayParts.push("--stat");
+    }
+    else if (request.format === "numstat") {
+        args.push("--numstat");
+        displayParts.push("--numstat");
+    }
+    else if (request.format === "raw") {
+        args.push("--raw");
+        displayParts.push("--raw");
+    }
+    if (request.mergeBase) {
+        if (!request.base || !request.target) {
+            throw new Error("mergeBase mode requires both base and target");
+        }
+        const merged = `${request.base}...${request.target}`;
+        args.push(merged);
+        displayParts.push(merged);
+    }
+    else {
+        if (request.base) {
+            args.push(request.base);
+            displayParts.push(request.base);
+        }
+        if (request.target) {
+            args.push(request.target);
+            displayParts.push(request.target);
+        }
+    }
+    if (request.pathspecs.length > 0) {
+        args.push("--", ...request.pathspecs);
+        displayParts.push("--", ...request.pathspecs);
+    }
+    return { args, display: displayParts.join(" ") };
+}
+function buildUntrackedText(format, untrackedPaths) {
+    if (untrackedPaths.length === 0) {
+        return "";
+    }
+    if (format === "name-status" || format === "raw") {
+        return `${untrackedPaths.map((item) => `??\t${item}`).join("\n")}\n`;
+    }
+    if (format === "name-only") {
+        return `${untrackedPaths.join("\n")}\n`;
+    }
+    return `\n# Untracked files\n${untrackedPaths.join("\n")}\n`;
+}
+async function appendAgentLocalUntrackedDiff(repoRootAbs, request, baseOutput) {
+    const listArgs = ["-C", repoRootAbs, "ls-files", "--others", "--exclude-standard"];
+    if (request.pathspecs.length > 0) {
+        listArgs.push("--", ...request.pathspecs);
+    }
+    const listResult = await runLocalCommand("git", listArgs, repoRootAbs);
+    if (listResult.code !== 0) {
+        return { output: baseOutput, hasUntracked: false };
+    }
+    const untrackedPaths = listResult.stdout.split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+    if (untrackedPaths.length === 0) {
+        return { output: baseOutput, hasUntracked: false };
+    }
+    if (request.format !== "patch") {
+        return { output: `${baseOutput}${buildUntrackedText(request.format, untrackedPaths)}`, hasUntracked: true };
+    }
+    let output = baseOutput;
+    for (const relPath of untrackedPaths) {
+        const diffResult = await runLocalCommand("git", ["-C", repoRootAbs, "diff", "--no-color", "--no-index", "--", "/dev/null", relPath], repoRootAbs);
+        if (diffResult.code !== 0 && diffResult.code !== 1) {
+            throw new Error(diffResult.stderr.trim() || `Failed to render agent untracked diff: ${relPath}`);
+        }
+        if (diffResult.stdout) {
+            output += diffResult.stdout;
+            if (!output.endsWith("\n")) {
+                output += "\n";
+            }
+        }
+    }
+    return { output, hasUntracked: true };
+}
+function publishGitRpcResponse(args) {
+    args.nc.publish(args.responseSubject, gitRpcCodec.encode(JSON.stringify(args.payload)));
+}
+export async function handleGitRpcMessage(args) {
+    let requestId = "unknown";
+    let responseSubject = "";
+    try {
+        const payload = JSON.parse(gitRpcCodec.decode(args.msg.data));
+        const request = normalizeGitRpcRequest({ request: payload, agentId: args.agentId });
+        requestId = request.requestId;
+        responseSubject = request.responseSubject;
+        if (!request.targetPath.startsWith("/")) {
+            throw new Error("agent source requires an absolute directory path");
+        }
+        const topLevelResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-toplevel"], request.targetPath);
+        if (topLevelResult.code !== 0) {
+            publishGitRpcResponse({
+                nc: args.nc,
+                responseSubject,
+                payload: {
+                    requestId,
+                    ok: true,
+                    payload: {
+                        isGitRepo: false,
+                        mode: "git_diff",
+                        source: "agent",
+                        agent: { id: args.agentId, name: null },
+                        currentPath: request.targetPath,
+                        repoRoot: null,
+                        repoRelativePath: null,
+                        branch: null,
+                        gitDiff: {
+                            command: "git diff --no-color",
+                            format: "patch",
+                            output: "",
+                            outputTruncated: false,
+                        },
+                        message: "현재 경로가 Git 저장소가 아닙니다.",
+                    },
+                },
+            });
+            return;
+        }
+        const repoRootAbs = topLevelResult.stdout.trim();
+        const prefixResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-prefix"], request.targetPath);
+        const repoRelativePath = prefixResult.code === 0 ? (prefixResult.stdout.trim().replace(/\/$/, "") || ".") : ".";
+        const branchResult = await runLocalCommand("git", ["-C", repoRootAbs, "symbolic-ref", "--quiet", "--short", "HEAD"], repoRootAbs);
+        const detachedResult = branchResult.code === 0 ? null : await runLocalCommand("git", ["-C", repoRootAbs, "rev-parse", "--short", "HEAD"], repoRootAbs);
+        const branch = branchResult.code === 0 ? branchResult.stdout.trim() || null : detachedResult && detachedResult.code === 0 ? detachedResult.stdout.trim() || null : null;
+        const gitDiffArgs = buildAgentGitDiffArgs(repoRootAbs, request);
+        const gitDiffResult = await runLocalCommand("git", gitDiffArgs.args, repoRootAbs);
+        if (gitDiffResult.code !== 0) {
+            throw new Error(gitDiffResult.stderr.trim() || "Failed to run agent git diff");
+        }
+        const withUntracked = await appendAgentLocalUntrackedDiff(repoRootAbs, request, gitDiffResult.stdout);
+        publishGitRpcResponse({
+            nc: args.nc,
+            responseSubject,
+            payload: {
+                requestId,
+                ok: true,
+                payload: {
+                    isGitRepo: true,
+                    mode: "git_diff",
+                    source: "agent",
+                    agent: { id: args.agentId, name: null },
+                    currentPath: request.targetPath,
+                    repoRoot: repoRootAbs,
+                    repoRelativePath,
+                    branch,
+                    gitDiff: {
+                        command: withUntracked.hasUntracked ? `${gitDiffArgs.display} (+ untracked)` : gitDiffArgs.display,
+                        format: request.format,
+                        output: withUntracked.output,
+                        outputTruncated: false,
+                    },
+                },
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (responseSubject) {
+            publishGitRpcResponse({
+                nc: args.nc,
+                responseSubject,
+                payload: { requestId, ok: false, error: message },
+            });
+        }
+        args.onError(`git rpc failed requestId=${requestId} error=${message}`);
+    }
+}