doer-agent 0.7.8 → 0.8.0

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

@@ -4,18 +4,83 @@ import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/p
 import { formatPatch, structuredPatch } from "diff";
 const AGENT_NOTES_ROOT = ".doer-agent/notes";
 const PATCHES_ROOT = `${AGENT_NOTES_ROOT}/patches`;
+function resolveSystemTimeZone() {
+    const configured = process.env.TZ?.trim();
+    if (configured) {
+        return configured;
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+function resolveTimeZoneOffsetString(date, timeZone) {
+    try {
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            timeZoneName: "shortOffset",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        }).formatToParts(date);
+        const token = parts.find((part) => part.type === "timeZoneName")?.value || "GMT+0";
+        const matched = token.match(/GMT([+-]\d{1,2})(?::?(\d{2}))?/i);
+        if (!matched) {
+            return "+00:00";
+        }
+        const hourRaw = matched[1] || "+0";
+        const minuteRaw = matched[2] || "00";
+        const sign = hourRaw.startsWith("-") ? "-" : "+";
+        const absHour = String(Math.abs(Number.parseInt(hourRaw, 10))).padStart(2, "0");
+        const absMinute = String(Math.abs(Number.parseInt(minuteRaw, 10))).padStart(2, "0");
+        return `${sign}${absHour}:${absMinute}`;
+    }
+    catch {
+        return "+00:00";
+    }
+}
+function systemTimeParts(date) {
+    const timeZone = resolveSystemTimeZone();
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+        hourCycle: "h23",
+    }).formatToParts(date);
+    const pick = (type) => {
+        return parts.find((part) => part.type === type)?.value || "00";
+    };
+    return {
+        year: pick("year"),
+        month: pick("month"),
+        day: pick("day"),
+        hours: pick("hour"),
+        minutes: pick("minute"),
+        seconds: pick("second"),
+        milliseconds: String(date.getMilliseconds()).padStart(3, "0"),
+        offset: resolveTimeZoneOffsetString(date, timeZone),
+    };
+}
 function nowIso() {
-    return new Date().toISOString();
+    const parts = systemTimeParts(new Date());
+    return `${parts.year}-${parts.month}-${parts.day}T${parts.hours}:${parts.minutes}:${parts.seconds}.${parts.milliseconds}${parts.offset}`;
 }
 function createTimeBasedPatchId(createdAt) {
-    const stamp = createdAt.replace(/[-:.]/g, "").replace("T", "t").replace("Z", "z");
+    const stamp = createdAt
+        .replace("T", "t")
+        .replace(/([+-])(\d{2}):?(\d{2})$/, (_match, sign, hours, minutes) => {
+        return `${sign === "-" ? "m" : "p"}${hours}${minutes}`;
+    })
+        .replace(/[-:.]/g, "")
+        .replace("Z", "z");
     const random = Math.random().toString(36).slice(2, 8);
     return `${stamp}-${random}`;
 }
 function patchRelPath(id, createdAt) {
     const date = new Date(createdAt);
-    const year = String(date.getUTCFullYear());
-    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const { year, month } = systemTimeParts(Number.isNaN(date.getTime()) ? new Date() : date);
     return path.posix.join(PATCHES_ROOT, year, month, `${id}.patch`);
 }
 export function sanitizeNoteId(value) {

package/dist/agent-runtime-utils.js

@@ -171,7 +171,10 @@ export function writeRpcStream(requestId, stream, chunk) {
 }
 function resolveLogTimeZone() {
     const configured = process.env.DOER_AGENT_LOG_TIMEZONE?.trim() || process.env.TZ?.trim();
-    return configured && configured.length > 0 ? configured : "Asia/Seoul";
+    if (configured && configured.length > 0) {
+        return configured;
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
 }
 function resolveTimeZoneOffsetString(date, timeZone) {
     try {
@@ -210,6 +213,7 @@ export function formatLocalTimestamp(date = new Date()) {
             minute: "2-digit",
             second: "2-digit",
             hour12: false,
+            hourCycle: "h23",
         }).formatToParts(date);
         const pick = (type) => {
             return parts.find((part) => part.type === type)?.value || "00";

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.8",
+  "version": "0.8.0",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",