claude-teammate 0.1.313 → 0.1.315

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-teammate",
-  "version": "0.1.313",
+  "version": "0.1.315",
   "description": "CLI bootstrapper for Claude Teammate.",
   "license": "MIT",
   "type": "module",

package/src/claude/prompts.js

@@ -23,6 +23,16 @@ function formatPriorWorkContext(input) {
   return `${sections.join("\n")}\n`;
 }
 
+// Pre-baked code-graph grounding (symbols + call paths) injected by the worker.
+// Empty when codegraph is unavailable, so prompts are unchanged in that case.
+function formatCodegraphContext(input) {
+  const ctx = String(input.codegraphContext || "").trim();
+  if (!ctx) {
+    return "";
+  }
+  return `\nCode graph context (symbols + call paths relevant to this task — use it to locate code precisely and avoid hallucinating APIs that do not exist in this repository):\n${ctx}\n`;
+}
+
 const INCLUDE_RESOURCE_LINKS_RULE =
   "When your response is posted as a comment on a Jira issue, GitHub issue, or GitHub PR, include the URL of every resource you created (e.g. Jira task, spreadsheet, test design, test cases, document, Confluence page) so the reader can navigate directly to it.";
 
@@ -400,7 +410,7 @@ ${input.latestComment?.body || "(none)"}
 
 Recent PR comments:
 ${recentComments || "(none)"}
-${formatPriorWorkContext(input)}
+${formatPriorWorkContext(input)}${formatCodegraphContext(input)}
 Instructions:
 - Checkout the branch above in this repository.
 - Implement the plan described in the pull request body.
@@ -522,7 +532,7 @@ ${JSON.stringify(input.memory?.epic || {}, null, 2)}
 
 Step to implement:
 ${input.step}
-${formatPriorWorkContext(input)}
+${formatPriorWorkContext(input)}${formatCodegraphContext(input)}
 Instructions:
 - Checkout the branch above in this repository.
 - Implement only the step described above. Do not implement other parts of the plan.

package/src/repo.js

@@ -1,5 +1,5 @@
 import { execFile } from "node:child_process";
-import { access, mkdir, rename, rm } from "node:fs/promises";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { buildGitEnvForRepoUrl, parseGitHubRepoUrl, parseRepoUrl } from "./forge/repo-host.js";
@@ -24,6 +24,38 @@ export class RepoCheckoutNotReadyError extends Error {
   }
 }
 
+// Idempotently add ignore patterns to this checkout's local exclude file
+// (`.git/info/exclude`). Worktree-safe: resolves the shared common git dir so a
+// single exclude file covers every worktree. Used to keep tooling artifacts
+// (e.g. `.codegraph/`) out of `git add -A` and `git clean -fd` without touching
+// the repository's tracked `.gitignore`.
+export async function ensureGitExcludes(repoPath, patterns) {
+  let commonDir;
+  try {
+    commonDir = (await execGitOutput(repoPath, ["rev-parse", "--git-common-dir"])).trim();
+  } catch {
+    return; // not a git checkout yet — nothing to exclude
+  }
+  const excludePath = path.isAbsolute(commonDir)
+    ? path.join(commonDir, "info", "exclude")
+    : path.join(repoPath, commonDir, "info", "exclude");
+
+  let current = "";
+  try {
+    current = await readFile(excludePath, "utf8");
+  } catch {
+    // exclude file may not exist yet — treated as empty
+  }
+  const present = new Set(current.split("\n").map((line) => line.trim()));
+  const missing = patterns.filter((pattern) => !present.has(pattern));
+  if (missing.length === 0) {
+    return; // idempotent: all patterns already excluded
+  }
+  const next = `${current.replace(/\n*$/u, "")}\n${missing.join("\n")}\n`;
+  await mkdir(path.dirname(excludePath), { recursive: true });
+  await writeFile(excludePath, next, "utf8");
+}
+
 export async function ensureLocalRepo(repoUrl, reposDir) {
   const repo = parseRepoUrl(repoUrl);
   const checkoutPath = path.join(reposDir, repo.owner, repo.name);
@@ -247,7 +279,9 @@ export async function prepareRepoForDefaultBranch(repoPath) {
 
 export async function commitAndPushRepoChanges(repoPath, branchName, commitMessage, baseRef) {
   await execGit(repoPath, ["checkout", branchName]);
-  await execGit(repoPath, ["add", "-A"]);
+  // Defense-in-depth: never stage the codegraph index even if the local
+  // exclude file was not applied to this checkout.
+  await execGit(repoPath, ["add", "-A", "--", ".", ":(exclude).codegraph"]);
   const statusOutput = await execGitOutput(repoPath, ["status", "--porcelain", "--ignore-submodules=dirty"]);
   if (!statusOutput.trim()) {
     const branchHasImplementation = await branchHasChangesAgainstMain(repoPath, baseRef);
@@ -770,6 +804,31 @@ export async function branchHasChangesAgainstMain(repoPath, baseRef) {
   return Number.isFinite(count) && count > 0;
 }
 
+/**
+ * True when HEAD's own work has already landed on the base branch (e.g. the
+ * branch was merged via another MR / a human merged it directly). In that case
+ * HEAD is an ancestor of the base tip while still being a distinct commit, so a
+ * branch-vs-base diff is empty and re-running Claude can never produce changes.
+ * Callers use this to terminate instead of looping on "no changes to commit".
+ * A brand-new branch that merely points at the base tip (HEAD === base) returns
+ * false — that is an unstarted PR, not a merged one. Best-effort; never throws.
+ */
+export async function branchMergedIntoBase(repoPath, baseRef) {
+  const branch = baseRef || (await resolveRemoteDefaultBranch(repoPath));
+  try {
+    const headSha = (await execGitOutput(repoPath, ["rev-parse", "HEAD"])).trim();
+    const baseSha = (await execGitOutput(repoPath, ["rev-parse", `origin/${branch}`])).trim();
+    if (!headSha || !baseSha || headSha === baseSha) {
+      return false;
+    }
+    // exit 0 → HEAD is an ancestor of the base tip → already merged.
+    await execGit(repoPath, ["merge-base", "--is-ancestor", "HEAD", `origin/${branch}`]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function resolveRemoteDefaultBranch(repoPath) {
   try {
     const output = await execGitOutput(repoPath, ["symbolic-ref", "refs/remotes/origin/HEAD"]);

package/src/worker/codegraph-context.js

@@ -0,0 +1,58 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+// Resolve binary: env override wins, otherwise rely on PATH (with the
+// user-local install dir prepended in runCg's env).
+function codegraphBin() {
+  return process.env.CODEGRAPH_BIN || "codegraph";
+}
+
+const INDEX_TIMEOUT_MS = 90_000;
+const EXPLORE_TIMEOUT_MS = 30_000;
+const CONTEXT_MAX_CHARS = 4000;
+
+async function runCg(args, { cwd, timeout, logger }) {
+  try {
+    const { stdout } = await execFileAsync(codegraphBin(), args, {
+      cwd,
+      timeout,
+      env: { ...process.env, PATH: `${process.env.HOME}/.local/bin:${process.env.PATH}` }
+    });
+    return stdout || "";
+  } catch (error) {
+    // Codegraph failure must never block the task (mirrors the Claude-CLI rule).
+    await logger?.error?.("codegraph command failed; continuing without graph context", {
+      command: args[0],
+      cwd,
+      error: error?.message || String(error)
+    });
+    return null;
+  }
+}
+
+// init on first use for this checkout, incremental sync afterwards. Never throws.
+export async function ensureCodegraphIndex(repoPath, logger) {
+  const indexed = existsSync(path.join(repoPath, ".codegraph"));
+  const args = indexed ? ["sync"] : ["init", "--force"];
+  await runCg(args, { cwd: repoPath, timeout: INDEX_TIMEOUT_MS, logger });
+}
+
+// Returns a grounding string (or "" when unavailable). Never throws.
+export async function exploreCodegraph(repoPath, query, logger) {
+  if (!query?.trim()) {
+    return "";
+  }
+  const out = await runCg(["explore", query.trim()], {
+    cwd: repoPath,
+    timeout: EXPLORE_TIMEOUT_MS,
+    logger
+  });
+  if (!out) {
+    return "";
+  }
+  return out.length > CONTEXT_MAX_CHARS ? `${out.slice(0, CONTEXT_MAX_CHARS)}\n[codegraph context truncated]` : out;
+}

package/src/worker/pull-request-workflow-support.js

@@ -6,12 +6,15 @@ import {
 } from "../claude.js";
 import {
   branchHasChangesAgainstMain,
+  branchMergedIntoBase,
   commitAndPushRepoChanges,
+  ensureGitExcludes,
   ensureWorktreeForBranch,
   getBranchDiffAgainstBase,
   prepareRepoForBranch,
   removeWorktree
 } from "../repo.js";
+import { ensureCodegraphIndex, exploreCodegraph } from "./codegraph-context.js";
 import { buildEpicMemoryPromptSnapshot, persistEpicImplementationKnowledge } from "./epic-memory.js";
 import {
   clearForgePullRequestBlocked,
@@ -189,6 +192,21 @@ export async function processPullRequestImplementation({
     const issueKey = githubIssueMemory?.jira_key || `PR-${detail.number}`;
     const epicSnapshot = buildEpicMemoryPromptSnapshot(epicMemory);
 
+    // Codegraph: keep the index local-only (never staged/pushed/cleaned), then
+    // (re)index every accessible checkout and pre-bake grounding context for the
+    // implementation prompt. All steps fail soft — codegraph is never required.
+    const codegraphRepoPaths =
+      Array.isArray(repoAccess.repoPaths) && repoAccess.repoPaths.length > 0 ? repoAccess.repoPaths : [repoPath];
+    for (const cgRepoPath of codegraphRepoPaths) {
+      await ensureGitExcludes(cgRepoPath, [".codegraph/"]);
+      await ensureCodegraphIndex(cgRepoPath, logger);
+    }
+    const codegraphContext = await exploreCodegraph(
+      repoPath,
+      `${issueKey} ${detail.title} ${stripImplementationPlan(nextBody).slice(0, 500)}`,
+      logger
+    );
+
     // Resume the prior Claude conversation for this PR branch so a follow-up
     // comment / reopen keeps the model's earlier context instead of rebuilding
     // it from memory (which dropped diffs/decisions and caused re-work). The
@@ -284,6 +302,7 @@ export async function processPullRequestImplementation({
       result = await services.runClaudeImplementationStep({
         pullRequest: { ...detail, body: nextBody },
         step: stepText,
+        codegraphContext,
         memory: { epic: epicSnapshot },
         epicContext: epicMemory,
         branchDiff: stepBranchDiff,
@@ -331,6 +350,16 @@ export async function processPullRequestImplementation({
         pr: detail.number
       });
       result = { result: "implemented", summary: "Implementation already committed on previous run." };
+    } else if (!latestComment && (await branchMergedIntoBase(repoPath, detail.baseRef).catch(() => false))) {
+      // The branch's work already landed on the base (merged via another MR or
+      // by a human). There is nothing left to implement, so skip Claude
+      // entirely — running it would only report "no changes" and loop. A human
+      // comment overrides this so feedback can still be addressed.
+      await logger.info("Head branch already merged into base; skipping Claude (nothing to implement)", {
+        repo: repo.url,
+        pr: detail.number
+      });
+      result = { result: "implemented", summary: "Changes already merged into the base branch." };
     } else {
       result = await services.runClaudeImplementation({
         pullRequest: { ...detail, body: nextBody },
@@ -338,6 +367,7 @@ export async function processPullRequestImplementation({
         epicContext: epicMemory,
         latestComment,
         branchDiff,
+        codegraphContext,
         repoPath,
         repoPaths: repoAccess.repoPaths,
         branchName: detail.headRef,
@@ -440,7 +470,53 @@ export async function processPullRequestImplementation({
       );
 
       if (!commitResult.committed && !commitResult.branchHasImplementation) {
-        throw new Error("Claude reported success but no repository changes were available to commit.");
+        // No diff to commit. If the branch's work already landed on the base
+        // (merged via another MR / by a human), re-running Claude can never
+        // produce changes — treat it as terminally implemented instead of
+        // looping. Otherwise stop without preserving STUCK_AT so the bot waits
+        // for human guidance rather than machine-gun retrying an unchangeable
+        // no-op every retry window.
+        const mergedIntoBase = await branchMergedIntoBase(repoPath, detail.baseRef).catch(() => false);
+        if (mergedIntoBase) {
+          const mergedBody = setPullRequestStatus(nextBody, "IMPLEMENTED");
+          await github.updatePullRequest(repo.url, detail.number, { title: detail.title, body: mergedBody });
+          await services.clearForgePullRequestBlocked(github, { ...detail, repoUrl: repo.url });
+          if (markReadyOnSuccess) {
+            await github.markPullRequestReady(repo.url, detail.number);
+            await services.transitionLinkedJiraIssueToReview(detail.title, jira, logger, detail.number);
+          }
+          const mergedComment =
+            successCommentBody ||
+            formatPullRequestOutcomeComment(
+              result.summary,
+              "The requested changes are already merged into the base branch; nothing left to implement."
+            );
+          await postPullRequestComment(github, repo.url, detail.number, mergedComment);
+          await postLinkedJiraComment(extractJiraKey(detail.title), mergedComment, jira, logger);
+          await logger.info("Branch already merged into base; PR marked IMPLEMENTED", {
+            repo: repo.url,
+            pr: detail.number
+          });
+          return buildDraftPrState(
+            { ...detail, body: mergedBody, draft: markReadyOnSuccess ? false : detail.draft },
+            "IMPLEMENTED",
+            "implemented"
+          );
+        }
+        const noChangeBody = clearStuckAt(setPullRequestStatus(nextBody, "STUCK"));
+        await github.updatePullRequest(repo.url, detail.number, { title: detail.title, body: noChangeBody });
+        await services.setForgePullRequestBlocked(github, { ...detail, repoUrl: repo.url });
+        const noChangeComment = formatPullRequestOutcomeComment(
+          result.summary,
+          "Claude reported success but produced no repository changes, so there was nothing to commit. Halting automatic retries until there is new guidance."
+        );
+        await postPullRequestComment(github, repo.url, detail.number, noChangeComment);
+        await postLinkedJiraComment(extractJiraKey(detail.title), noChangeComment, jira, logger);
+        await logger.error("Pull request produced no repository changes; halting auto-retry", {
+          repo: repo.url,
+          pr: detail.number
+        });
+        return buildDraftPrState({ ...detail, body: noChangeBody }, "STUCK", "stuck");
       }
 
       const implementedBody = setPullRequestStatus(nextBody, "IMPLEMENTED");