doer-agent 0.7.9 → 0.8.1

package/dist/agent-git-rpc.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import path from "node:path";
 import { StringCodec } from "nats";
 const gitRpcCodec = StringCodec();
 function runLocalCommand(command, args, cwd) {
@@ -43,6 +44,35 @@ function sanitizeGitPathspec(value) {
     }
     return trimmed;
 }
+function normalizeWorkspacePath(workspaceRoot, value) {
+    const trimmed = value.trim().replace(/\\/g, "/") || ".";
+    if (path.isAbsolute(trimmed)) {
+        throw new Error("absolute paths are not supported for agent git diff");
+    }
+    const abs = path.resolve(workspaceRoot, trimmed);
+    if (abs !== workspaceRoot && !abs.startsWith(workspaceRoot + path.sep)) {
+        throw new Error("path escapes workspace root");
+    }
+    return abs;
+}
+function pathspecsForRepo(args) {
+    const normalizedTargetPath = args.targetPath.trim().replace(/\\/g, "/").replace(/\/+$/g, "") || ".";
+    return args.pathspecs.map((pathspec) => {
+        if (path.isAbsolute(pathspec)) {
+            throw new Error("absolute pathspecs are not supported for agent git diff");
+        }
+        const normalizedPathspec = pathspec.trim().replace(/\\/g, "/").replace(/\/+$/g, "") || ".";
+        const workspaceAbs = normalizedPathspec === normalizedTargetPath
+            ? args.targetPathAbs
+            : path.resolve(args.workspaceRoot, pathspec);
+        const repoRelRaw = path.relative(args.repoRootAbs, workspaceAbs).split(path.sep).join("/");
+        const repoRel = repoRelRaw || ".";
+        if (repoRel && repoRel !== ".." && !repoRel.startsWith("../")) {
+            return repoRel;
+        }
+        return pathspec;
+    });
+}
 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() : "";
@@ -68,7 +98,7 @@ function normalizeGitRpcRequest(args) {
         args.request.diffAlgorithm === "histogram"
         ? args.request.diffAlgorithm
         : "default";
-    const contextRaw = Number(args.request.contextLines);
+    const contextRaw = typeof args.request.contextLines === "number" ? args.request.contextLines : Number.NaN;
     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 {
@@ -216,10 +246,9 @@ export async function handleGitRpcMessage(args) {
         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);
+        const workspaceRoot = path.resolve(args.workspaceRoot);
+        const targetPathAbs = normalizeWorkspacePath(workspaceRoot, request.targetPath);
+        const topLevelResult = await runLocalCommand("git", ["-C", targetPathAbs, "rev-parse", "--show-toplevel"], targetPathAbs);
         if (topLevelResult.code !== 0) {
             publishGitRpcResponse({
                 nc: args.nc,
@@ -233,7 +262,6 @@ export async function handleGitRpcMessage(args) {
                         source: "agent",
                         agent: { id: args.agentId, name: null },
                         currentPath: request.targetPath,
-                        repoRoot: null,
                         repoRelativePath: null,
                         branch: null,
                         gitDiff: {
@@ -249,17 +277,27 @@ export async function handleGitRpcMessage(args) {
             return;
         }
         const repoRootAbs = topLevelResult.stdout.trim();
-        const prefixResult = await runLocalCommand("git", ["-C", request.targetPath, "rev-parse", "--show-prefix"], request.targetPath);
+        const repoRequest = {
+            ...request,
+            pathspecs: pathspecsForRepo({
+                workspaceRoot,
+                repoRootAbs,
+                targetPath: request.targetPath,
+                targetPathAbs,
+                pathspecs: request.pathspecs,
+            }),
+        };
+        const prefixResult = await runLocalCommand("git", ["-C", targetPathAbs, "rev-parse", "--show-prefix"], targetPathAbs);
         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 gitDiffArgs = buildAgentGitDiffArgs(repoRootAbs, repoRequest);
         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);
+        const withUntracked = await appendAgentLocalUntrackedDiff(repoRootAbs, repoRequest, gitDiffResult.stdout);
         publishGitRpcResponse({
             nc: args.nc,
             responseSubject,
@@ -272,7 +310,6 @@ export async function handleGitRpcMessage(args) {
                     source: "agent",
                     agent: { id: args.agentId, name: null },
                     currentPath: request.targetPath,
-                    repoRoot: repoRootAbs,
                     repoRelativePath,
                     branch,
                     gitDiff: {

package/dist/agent-notes-local.js

@@ -187,6 +187,35 @@ export async function listAgentNotesLocal(workspaceRoot) {
     });
     return notes;
 }
+export async function listAgentNotePatchesLocal(workspaceRoot, limit = 10) {
+    const rootAbs = workspacePath(workspaceRoot, PATCHES_ROOT);
+    const patches = [];
+    async function visit(absDir, relDir) {
+        const rows = await readdir(absDir, { withFileTypes: true }).catch(() => []);
+        await Promise.all(rows.map(async (row) => {
+            const childAbs = path.join(absDir, row.name);
+            const childRel = path.posix.join(relDir, row.name);
+            if (row.isDirectory()) {
+                await visit(childAbs, childRel);
+                return;
+            }
+            if (!row.isFile() || !row.name.endsWith(".patch")) {
+                return;
+            }
+            const entry = await stat(childAbs);
+            patches.push({
+                id: childRel,
+                path: childRel,
+                name: row.name,
+                size: entry.size,
+                mtimeMs: entry.mtimeMs,
+            });
+        }));
+    }
+    await visit(rootAbs, PATCHES_ROOT);
+    patches.sort((a, b) => b.mtimeMs - a.mtimeMs || b.path.localeCompare(a.path));
+    return patches.slice(0, Math.max(0, Math.trunc(limit)));
+}
 export async function getAgentNoteLocal(workspaceRoot, noteId) {
     const id = sanitizeNoteId(noteId);
     const content = await readTextIfExists(workspacePath(workspaceRoot, noteRelPath(id)));

package/dist/agent-notes-rpc.js

@@ -1,9 +1,10 @@
 import { StringCodec } from "nats";
-import { agentNotesCapabilitiesLocal, createAgentNoteLocal, deleteAgentNoteLocal, getAgentNoteLocal, listAgentNotesLocal, renameAgentNoteLocal, saveAgentNoteLocal, } from "./agent-notes-local.js";
+import { agentNotesCapabilitiesLocal, createAgentNoteLocal, deleteAgentNoteLocal, listAgentNotePatchesLocal, getAgentNoteLocal, listAgentNotesLocal, renameAgentNoteLocal, saveAgentNoteLocal, } from "./agent-notes-local.js";
 const notesRpcCodec = StringCodec();
 function parseAction(value) {
     if (value === "capabilities" ||
         value === "list" ||
+        value === "listPatches" ||
         value === "get" ||
         value === "create" ||
         value === "save" ||
@@ -24,6 +25,10 @@ async function executeNotesRpc(workspaceRoot, request) {
     if (action === "list") {
         return { ok: true, action, notes: await listAgentNotesLocal(workspaceRoot) };
     }
+    if (action === "listPatches") {
+        const limit = typeof request.limit === "number" && Number.isFinite(request.limit) ? request.limit : 10;
+        return { ok: true, action, patches: await listAgentNotePatchesLocal(workspaceRoot, limit) };
+    }
     if (action === "get") {
         const notes = await listAgentNotesLocal(workspaceRoot);
         const noteId = stringValue(request.noteId) || notes[0]?.id || "";

package/dist/agent.js

@@ -84,6 +84,7 @@ function subscribeToGitRpc(args) {
                 msg,
                 nc: args.jetstream.nc,
                 agentId: args.agentId,
+                workspaceRoot: args.workspaceRoot,
                 onError: writeAgentError,
             });
         },
@@ -319,6 +320,7 @@ async function main() {
                     jetstream,
                     userId,
                     agentId: initialAgentId,
+                    workspaceRoot: resolveWorkspaceRoot(),
                 });
                 subscribeToSkillRpc({
                     nc: jetstream.nc,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.7.9",
+  "version": "0.8.1",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",