doer-agent 0.9.6 → 0.9.7

package/dist/agent-thread-tags-rpc.js

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { StringCodec } from "nats";
 import { runCodexTextTask } from "./codex-text-task.js";
@@ -9,6 +9,8 @@ const MAX_THREADS_PER_REBUILD = 2_000;
 const MAX_TAGS = 12;
 const MIN_TAGS = 2;
 const OTHER_TAG_ID = "other";
+const MAX_REPOSITORIES = 200;
+const MAX_RELATED_REPOS = 3;
 const DEFAULT_TAGS = [
     { id: "deployment", label: "Deployment", description: "Deploy, release, publish, production rollout, or app-store delivery.", color: "#8b5cf6" },
     { id: "bug", label: "Bug · diagnosis", description: "Debugging, errors, failures, regressions, diagnosis, or fixes.", color: "#ef4444" },
@@ -55,6 +57,70 @@ function tagsFilePath(workspaceRoot, threadId) {
 function configFilePath(workspaceRoot) {
     return path.join(workspaceRoot, ".doer-agent", "thread-tags", "config.json");
 }
+async function isGitRepository(directoryPath) {
+    try {
+        const gitEntry = await stat(path.join(directoryPath, ".git"));
+        return gitEntry.isDirectory() || gitEntry.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function repositoryCandidate(workspaceRoot, absolutePath) {
+    const relativePath = path.relative(workspaceRoot, absolutePath).split(path.sep).join("/") || ".";
+    return {
+        id: relativePath,
+        label: path.basename(absolutePath),
+        relativePath,
+        absolutePath,
+    };
+}
+export async function discoverWorkspaceRepositories(workspaceRoot) {
+    const resolvedRoot = path.resolve(workspaceRoot);
+    const candidates = [];
+    if (await isGitRepository(resolvedRoot)) {
+        candidates.push(repositoryCandidate(resolvedRoot, resolvedRoot));
+    }
+    const entries = await readdir(resolvedRoot, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        if (candidates.length >= MAX_REPOSITORIES ||
+            !entry.isDirectory() ||
+            entry.name.startsWith(".")) {
+            continue;
+        }
+        const absolutePath = path.join(resolvedRoot, entry.name);
+        if (await isGitRepository(absolutePath)) {
+            candidates.push(repositoryCandidate(resolvedRoot, absolutePath));
+        }
+    }
+    return candidates.sort((left, right) => (left.label.localeCompare(right.label) || left.id.localeCompare(right.id)));
+}
+function repositoryFingerprint(repositories) {
+    return crypto.createHash("sha256").update(JSON.stringify(repositories.map((repository) => ({
+        id: repository.id,
+        label: repository.label,
+        relativePath: repository.relativePath,
+    })))).digest("hex");
+}
+function pathIsWithin(candidatePath, targetPath) {
+    const relative = path.relative(candidatePath, targetPath);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export function relatedReposFromCwd(cwd, repositories) {
+    if (!cwd) {
+        return [];
+    }
+    const resolvedCwd = path.resolve(cwd);
+    const repository = repositories
+        .filter((candidate) => pathIsWithin(candidate.absolutePath, resolvedCwd))
+        .sort((left, right) => right.absolutePath.length - left.absolutePath.length)[0];
+    return repository ? [{
+            id: repository.id,
+            label: repository.label,
+            confidence: 1,
+            source: "cwd",
+        }] : [];
+}
 function normalizeInputs(value, limit) {
     const rows = Array.isArray(value) ? value.slice(0, limit) : [];
     const seen = new Set();
@@ -191,9 +257,10 @@ function jsonObjectFromText(text) {
     }
     return payload;
 }
-export function parseThreadTagClassificationResponse(text, requestedThreadIds, allowedTagIds = new Set(DEFAULT_TAGS.map((tag) => tag.id))) {
+export function parseThreadTagClassificationResponse(text, requestedThreadIds, allowedTagIds = new Set(DEFAULT_TAGS.map((tag) => tag.id)), repositories = []) {
     const payload = jsonObjectFromText(text);
     const assignments = Array.isArray(payload.assignments) ? payload.assignments : [];
+    const repositoriesById = new Map(repositories.map((repository) => [repository.id, repository]));
     const seen = new Set();
     const results = [];
     for (const assignmentValue of assignments) {
@@ -207,11 +274,30 @@ export function parseThreadTagClassificationResponse(text, requestedThreadIds, a
             continue;
         }
         seen.add(threadId);
+        const seenRepositoryIds = new Set();
+        const relatedRepos = (Array.isArray(assignment?.relatedRepos) ? assignment.relatedRepos : [])
+            .flatMap((value) => {
+            const row = recordValue(value);
+            const id = stringValue(row?.id) || stringValue(value);
+            const repository = repositoriesById.get(id);
+            if (!repository || seenRepositoryIds.has(id)) {
+                return [];
+            }
+            seenRepositoryIds.add(id);
+            return [{
+                    id: repository.id,
+                    label: repository.label,
+                    confidence: boundedConfidence(row?.confidence),
+                    source: "ai",
+                }];
+        })
+            .slice(0, MAX_RELATED_REPOS);
         results.push({
             threadId,
             activityTag,
             confidence: boundedConfidence(assignment?.confidence),
             source: "ai",
+            relatedRepos,
         });
     }
     return results;
@@ -219,41 +305,61 @@ export function parseThreadTagClassificationResponse(text, requestedThreadIds, a
 export function parseSuggestedThreadTags(text) {
     return normalizeTagDefinitions(jsonObjectFromText(text).tags);
 }
-async function readStoredTags(workspaceRoot, input, config) {
+async function readStoredTags(workspaceRoot, input, config, repositories) {
     try {
         const row = recordValue(JSON.parse(await readFile(tagsFilePath(workspaceRoot, input.threadId), "utf8")));
         const activityTag = sanitizeTagId(stringValue(row?.activityTag));
         const allowedTagIds = new Set(config.tags.map((tag) => tag.id));
-        const isLegacyDefaultCache = row?.version === 1 && config.source === "default";
-        const isCurrentCache = row?.version === 2 && stringValue(row.configFingerprint) === config.fingerprint;
-        if ((!isLegacyDefaultCache && !isCurrentCache) ||
+        const isCurrentCache = row?.version === 3 &&
+            stringValue(row.configFingerprint) === config.fingerprint &&
+            stringValue(row.repositoryFingerprint) === repositoryFingerprint(repositories);
+        if (!isCurrentCache ||
             stringValue(row?.threadId) !== input.threadId ||
             stringValue(row?.contentFingerprint) !== contentFingerprint(input) ||
             !allowedTagIds.has(activityTag)) {
             return null;
         }
+        const repositoriesById = new Map(repositories.map((repository) => [repository.id, repository]));
+        const relatedRepos = (Array.isArray(row?.relatedRepos) ? row.relatedRepos : [])
+            .flatMap((value) => {
+            const stored = recordValue(value);
+            const repository = repositoriesById.get(stringValue(stored?.id));
+            if (!repository) {
+                return [];
+            }
+            return [{
+                    id: repository.id,
+                    label: repository.label,
+                    confidence: boundedConfidence(stored?.confidence),
+                    source: stored?.source === "cwd" ? "cwd" : "ai",
+                }];
+        })
+            .slice(0, MAX_RELATED_REPOS);
         return {
             threadId: input.threadId,
             activityTag,
             confidence: boundedConfidence(row?.confidence),
             source: "ai",
+            relatedRepos,
         };
     }
     catch {
         return null;
     }
 }
-async function writeStoredTags(workspaceRoot, input, classification, config) {
+async function writeStoredTags(workspaceRoot, input, classification, config, repositories) {
     const filePath = tagsFilePath(workspaceRoot, input.threadId);
     await mkdir(path.dirname(filePath), { recursive: true });
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
     const payload = {
-        version: 2,
+        version: 3,
         threadId: input.threadId,
         contentFingerprint: contentFingerprint(input),
         configFingerprint: config.fingerprint,
+        repositoryFingerprint: repositoryFingerprint(repositories),
         activityTag: classification.activityTag,
         confidence: classification.confidence,
+        relatedRepos: classification.relatedRepos,
         source: "ai",
         updatedAt: new Date().toISOString(),
     };
@@ -263,15 +369,23 @@ async function writeStoredTags(workspaceRoot, input, classification, config) {
 function configuredTagsPrompt(tags) {
     return tags.map((tag) => `- ${tag.id} (${tag.label}): ${tag.description}`);
 }
-function classifierPrompt(inputs, tags) {
+function classifierPrompt(inputs, tags, repositories) {
     return [
         "You classify Codex threads inside Doer.",
         "Return only one valid JSON object. Do not use Markdown fences or add explanations.",
         "Classify every input thread into exactly one activityTag from the configured list.",
         "Configured activityTag values:",
         ...configuredTagsPrompt(tags),
-        "Use label and preview as the main evidence. Use cwd only as supporting project context.",
-        `Output shape: {"assignments":[{"threadId":"...","activityTag":"${tags[0]?.id ?? OTHER_TAG_ID}","confidence":0.9}]}`,
+        "Also select zero to three relatedRepos for each thread from the repository candidates below.",
+        "A related repository is a code repository that the thread discusses, inspects, modifies, tests, deploys, or otherwise directly works on.",
+        "Do not invent repository ids and do not select a repository merely because it shares the agent workspace.",
+        `Repository candidates: ${JSON.stringify(repositories.map((repository) => ({
+            id: repository.id,
+            label: repository.label,
+            relativePath: repository.relativePath,
+        })))}`,
+        "Use label and preview as the main evidence. Use cwd as strong supporting repository evidence.",
+        `Output shape: {"assignments":[{"threadId":"...","activityTag":"${tags[0]?.id ?? OTHER_TAG_ID}","confidence":0.9,"relatedRepos":[{"id":"repository-id","confidence":0.9}]}]}`,
         "",
         JSON.stringify({ threads: inputs }),
     ].join("\n");
@@ -284,7 +398,7 @@ function suggestionPrompt(inputs, candidateTags) {
         "Every tag needs: a stable lowercase kebab-case id, a concise label, a one-sentence classification description, and a distinct #RRGGBB color.",
         "Write labels and descriptions in the predominant language of the supplied threads. Use Korean when the threads are predominantly Korean.",
         `Always include "${OTHER_TAG_ID}" as the final fallback tag.`,
-        "Avoid tags for project paths or running status; those are managed separately.",
+        "Avoid tags for repositories or running status; those are managed separately.",
         "Prefer work-intent categories that will remain useful for future threads.",
         'Output shape: {"tags":[{"id":"feature","label":"Feature","description":"Implementation and product changes.","color":"#22c55e"}]}',
         candidateTags?.length
@@ -299,12 +413,30 @@ function suggestionPrompt(inputs, candidateTags) {
         })}` : "",
     ].filter(Boolean).join("\n");
 }
+function withCwdRelatedRepos(classification, input, repositories) {
+    const merged = new Map();
+    for (const relatedRepo of classification.relatedRepos) {
+        merged.set(relatedRepo.id, relatedRepo);
+    }
+    for (const relatedRepo of relatedReposFromCwd(input.cwd, repositories)) {
+        merged.set(relatedRepo.id, relatedRepo);
+    }
+    return {
+        ...classification,
+        relatedRepos: [...merged.values()]
+            .sort((left, right) => (Number(right.source === "cwd") - Number(left.source === "cwd")
+            || right.confidence - left.confidence
+            || left.label.localeCompare(right.label)))
+            .slice(0, MAX_RELATED_REPOS),
+    };
+}
 async function classifyThreads(args) {
     const config = await readConfig(args.workspaceRoot);
+    const repositories = await discoverWorkspaceRepositories(args.workspaceRoot);
     const classifications = new Map();
     const staleInputs = [];
     for (const input of args.inputs) {
-        const stored = args.force ? null : await readStoredTags(args.workspaceRoot, input, config);
+        const stored = args.force ? null : await readStoredTags(args.workspaceRoot, input, config, repositories);
         if (stored) {
             classifications.set(input.threadId, stored);
         }
@@ -317,17 +449,18 @@ async function classifyThreads(args) {
         try {
             const resultText = await runCodexTextTask({
                 manager: args.manager,
-                prompt: classifierPrompt(staleInputs, config.tags),
+                prompt: classifierPrompt(staleInputs, config.tags, repositories),
             });
-            const resolved = parseThreadTagClassificationResponse(resultText, new Set(staleInputs.map((input) => input.threadId)), new Set(config.tags.map((tag) => tag.id)));
+            const resolved = parseThreadTagClassificationResponse(resultText, new Set(staleInputs.map((input) => input.threadId)), new Set(config.tags.map((tag) => tag.id)), repositories);
             const inputsById = new Map(staleInputs.map((input) => [input.threadId, input]));
             await Promise.all(resolved.map(async (classification) => {
                 const input = inputsById.get(classification.threadId);
                 if (!input) {
                     return;
                 }
-                await writeStoredTags(args.workspaceRoot, input, classification, config);
-                classifications.set(classification.threadId, classification);
+                const completedClassification = withCwdRelatedRepos(classification, input, repositories);
+                await writeStoredTags(args.workspaceRoot, input, completedClassification, config, repositories);
+                classifications.set(classification.threadId, completedClassification);
             }));
             if (resolved.length !== staleInputs.length) {
                 classificationError = `AI classified ${resolved.length} of ${staleInputs.length} threads`;

package/dist/agent-thread-tags-rpc.test.js

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import test from "node:test";
-import { parseSuggestedThreadTags, parseThreadTagClassificationResponse, } from "./agent-thread-tags-rpc.js";
+import { discoverWorkspaceRepositories, parseSuggestedThreadTags, parseThreadTagClassificationResponse, relatedReposFromCwd, } from "./agent-thread-tags-rpc.js";
 test("parses only requested valid thread tag assignments", () => {
     const result = parseThreadTagClassificationResponse(JSON.stringify({
         assignments: [
@@ -14,6 +17,7 @@ test("parses only requested valid thread tag assignments", () => {
             activityTag: "feature",
             confidence: 0.91,
             source: "ai",
+            relatedRepos: [],
         }]);
 });
 test("accepts fenced JSON and clamps confidence", () => {
@@ -24,6 +28,58 @@ test("accepts classifications from a custom configured range", () => {
     const result = parseThreadTagClassificationResponse("{\"assignments\":[{\"threadId\":\"a\",\"activityTag\":\"customer-request\",\"confidence\":0.8}]}", new Set(["a"]), new Set(["customer-request", "other"]));
     assert.equal(result[0]?.activityTag, "customer-request");
 });
+test("accepts only configured related repository ids", () => {
+    const repositories = [{
+            id: "doer",
+            label: "doer",
+            relativePath: "doer",
+            absolutePath: "/workspace/doer",
+        }];
+    const result = parseThreadTagClassificationResponse(JSON.stringify({
+        assignments: [{
+                threadId: "a",
+                activityTag: "feature",
+                confidence: 0.9,
+                relatedRepos: [
+                    { id: "doer", confidence: 0.82 },
+                    { id: "invented", confidence: 1 },
+                ],
+            }],
+    }), new Set(["a"]), new Set(["feature", "other"]), repositories);
+    assert.deepEqual(result[0]?.relatedRepos, [{
+            id: "doer",
+            label: "doer",
+            confidence: 0.82,
+            source: "ai",
+        }]);
+});
+test("uses the most specific repository containing cwd", () => {
+    const repositories = [
+        { id: ".", label: "workspace", relativePath: ".", absolutePath: "/workspace" },
+        { id: "doer", label: "doer", relativePath: "doer", absolutePath: "/workspace/doer" },
+    ];
+    assert.deepEqual(relatedReposFromCwd("/workspace/doer/src", repositories), [{
+            id: "doer",
+            label: "doer",
+            confidence: 1,
+            source: "cwd",
+        }]);
+});
+test("discovers the workspace root and immediate child git repositories", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "doer-thread-repos-"));
+    try {
+        await mkdir(path.join(root, ".git"));
+        await mkdir(path.join(root, "child", ".git"), { recursive: true });
+        await mkdir(path.join(root, "not-a-repo"), { recursive: true });
+        await mkdir(path.join(root, "worktree"), { recursive: true });
+        await writeFile(path.join(root, "worktree", ".git"), "gitdir: ../actual\n", "utf8");
+        const repositories = await discoverWorkspaceRepositories(root);
+        assert.deepEqual(repositories.map((repository) => repository.id).sort(), [".", "child", "worktree"]);
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
 test("normalizes AI suggested tags and always adds other", () => {
     const result = parseSuggestedThreadTags(JSON.stringify({
         tags: [

package/package.json

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