ralph-hero-mcp-server 2.5.3 → 2.5.13

package/dist/lib/debug-logger.js

@@ -35,14 +35,19 @@ export function sanitize(obj) {
 // ---------------------------------------------------------------------------
 export class DebugLogger {
     logPath = null;
+    logPathPromise = null;
     logDir;
     constructor(options) {
         this.logDir =
             options?.logDir ?? join(homedir(), ".ralph-hero", "logs");
     }
-    async getLogPath() {
-        if (this.logPath)
-            return this.logPath;
+    getLogPath() {
+        if (!this.logPathPromise) {
+            this.logPathPromise = this.initLogPath();
+        }
+        return this.logPathPromise;
+    }
+    async initLogPath() {
         await mkdir(this.logDir, { recursive: true });
         const now = new Date();
         const ts = now

package/dist/lib/group-detection.js

@@ -26,8 +26,8 @@ const SEED_QUERY = `query($owner: String!, $repo: String!, $number: Int!) {
             number
             title
             state
-            blocking(first: 20) { nodes { number } }
-            blockedBy(first: 20) { nodes { number } }
+            blocking(first: 20) { nodes { number repository { owner { login } name } } }
+            blockedBy(first: 20) { nodes { number repository { owner { login } name } } }
           }
         }
       }
@@ -37,15 +37,15 @@ const SEED_QUERY = `query($owner: String!, $repo: String!, $number: Int!) {
           number
           title
           state
-          blocking(first: 20) { nodes { number } }
-          blockedBy(first: 20) { nodes { number } }
+          blocking(first: 20) { nodes { number repository { owner { login } name } } }
+          blockedBy(first: 20) { nodes { number repository { owner { login } name } } }
         }
       }
       blocking(first: 20) {
-        nodes { id number title state }
+        nodes { id number title state repository { owner { login } name } }
       }
       blockedBy(first: 20) {
-        nodes { id number title state }
+        nodes { id number title state repository { owner { login } name } }
       }
     }
   }
@@ -69,8 +69,8 @@ const EXPAND_QUERY = `query($owner: String!, $repo: String!, $number: Int!) {
             number
             title
             state
-            blocking(first: 20) { nodes { number } }
-            blockedBy(first: 20) { nodes { number } }
+            blocking(first: 20) { nodes { number repository { owner { login } name } } }
+            blockedBy(first: 20) { nodes { number repository { owner { login } name } } }
           }
         }
       }
@@ -80,15 +80,15 @@ const EXPAND_QUERY = `query($owner: String!, $repo: String!, $number: Int!) {
           number
           title
           state
-          blocking(first: 20) { nodes { number } }
-          blockedBy(first: 20) { nodes { number } }
+          blocking(first: 20) { nodes { number repository { owner { login } name } } }
+          blockedBy(first: 20) { nodes { number repository { owner { login } name } } }
         }
       }
       blocking(first: 20) {
-        nodes { id number title state }
+        nodes { id number title state repository { owner { login } name } }
       }
       blockedBy(first: 20) {
-        nodes { id number title state }
+        nodes { id number title state repository { owner { login } name } }
       }
     }
   }
@@ -111,18 +111,36 @@ export async function detectGroup(client, owner, repo, seedNumber) {
     const issueMap = new Map();
     // Queue of issue numbers to expand
     const expandQueue = [];
+    // Cross-repo info for dependency targets (number -> { owner, repo })
+    const depRepoInfo = new Map();
+    // Helper to store cross-repo info from dependency nodes
+    function trackDepRepoInfo(nodes) {
+        for (const dep of nodes) {
+            if (dep.repository) {
+                depRepoInfo.set(dep.number, {
+                    owner: dep.repository.owner.login,
+                    repo: dep.repository.name,
+                });
+            }
+        }
+    }
     // Step 1: Seed query
     const seedResult = await client.query(SEED_QUERY, { owner, repo, number: seedNumber });
     const seedIssue = seedResult.repository?.issue;
     if (!seedIssue) {
         throw new Error(`Issue #${seedNumber} not found in ${owner}/${repo}`);
     }
+    // Track cross-repo info from seed's direct dependencies
+    trackDepRepoInfo(seedIssue.blocking.nodes);
+    trackDepRepoInfo(seedIssue.blockedBy.nodes);
     // Process seed issue
     addIssueToMap(issueMap, {
         id: seedIssue.id,
         number: seedIssue.number,
         title: seedIssue.title,
         state: seedIssue.state,
+        repoOwner: owner,
+        repoName: repo,
         parentNumber: seedIssue.parent?.number ?? null,
         subIssueNumbers: seedIssue.subIssues.nodes.map((n) => n.number),
         blockingNumbers: seedIssue.blocking.nodes.map((n) => n.number),
@@ -136,17 +154,24 @@ export async function detectGroup(client, owner, repo, seedNumber) {
             number: parent.number,
             title: parent.title,
             state: parent.state,
+            repoOwner: owner,
+            repoName: repo,
             parentNumber: null,
             subIssueNumbers: parent.subIssues.nodes.map((n) => n.number),
             blockingNumbers: [],
             blockedByNumbers: [],
         });
         for (const sibling of parent.subIssues.nodes) {
+            // Track cross-repo info from sibling dependencies
+            trackDepRepoInfo(sibling.blocking?.nodes ?? []);
+            trackDepRepoInfo(sibling.blockedBy?.nodes ?? []);
             addIssueToMap(issueMap, {
                 id: sibling.id,
                 number: sibling.number,
                 title: sibling.title,
                 state: sibling.state,
+                repoOwner: owner,
+                repoName: repo,
                 parentNumber: parent.number,
                 subIssueNumbers: [],
                 blockingNumbers: sibling.blocking?.nodes.map((n) => n.number) ?? [],
@@ -156,11 +181,16 @@ export async function detectGroup(client, owner, repo, seedNumber) {
     }
     // Process sub-issues of seed
     for (const child of seedIssue.subIssues.nodes) {
+        // Track cross-repo info from child dependencies
+        trackDepRepoInfo(child.blocking?.nodes ?? []);
+        trackDepRepoInfo(child.blockedBy?.nodes ?? []);
         addIssueToMap(issueMap, {
             id: child.id,
             number: child.number,
             title: child.title,
             state: child.state,
+            repoOwner: owner,
+            repoName: repo,
             parentNumber: seedIssue.number,
             subIssueNumbers: [],
             blockingNumbers: child.blocking?.nodes.map((n) => n.number) ?? [],
@@ -169,12 +199,16 @@ export async function detectGroup(client, owner, repo, seedNumber) {
     }
     // Process direct dependencies
     for (const dep of seedIssue.blocking.nodes) {
+        const depOwner = dep.repository?.owner.login ?? owner;
+        const depRepo = dep.repository?.name ?? repo;
         if (!issueMap.has(dep.number)) {
             addIssueToMap(issueMap, {
                 id: dep.id,
                 number: dep.number,
                 title: dep.title,
                 state: dep.state,
+                repoOwner: depOwner,
+                repoName: depRepo,
                 parentNumber: null,
                 subIssueNumbers: [],
                 blockingNumbers: [],
@@ -184,12 +218,16 @@ export async function detectGroup(client, owner, repo, seedNumber) {
         }
     }
     for (const dep of seedIssue.blockedBy.nodes) {
+        const depOwner = dep.repository?.owner.login ?? owner;
+        const depRepo = dep.repository?.name ?? repo;
         if (!issueMap.has(dep.number)) {
             addIssueToMap(issueMap, {
                 id: dep.id,
                 number: dep.number,
                 title: dep.title,
                 state: dep.state,
+                repoOwner: depOwner,
+                repoName: depRepo,
                 parentNumber: null,
                 subIssueNumbers: [],
                 blockingNumbers: [],
@@ -220,16 +258,35 @@ export async function detectGroup(client, owner, repo, seedNumber) {
             continue;
         }
         expanded.add(num);
+        // Resolve owner/repo for this issue — check cross-repo info first
+        const crossRepoInfo = depRepoInfo.get(num);
+        const expandOwner = crossRepoInfo?.owner ?? owner;
+        const expandRepo = crossRepoInfo?.repo ?? repo;
         try {
-            const expandResult = await client.query(EXPAND_QUERY, { owner, repo, number: num });
+            const expandResult = await client.query(EXPAND_QUERY, { owner: expandOwner, repo: expandRepo, number: num });
             const expandedIssue = expandResult.repository?.issue;
             if (!expandedIssue)
-                continue; // Cross-repo or deleted issue, skip
+                continue; // Deleted issue, skip
+            // Track cross-repo info from expanded issue's dependency nodes
+            trackDepRepoInfo(expandedIssue.blocking.nodes);
+            trackDepRepoInfo(expandedIssue.blockedBy.nodes);
+            for (const child of expandedIssue.subIssues.nodes) {
+                trackDepRepoInfo(child.blocking?.nodes ?? []);
+                trackDepRepoInfo(child.blockedBy?.nodes ?? []);
+            }
+            if (expandedIssue.parent) {
+                for (const sibling of expandedIssue.parent.subIssues.nodes) {
+                    trackDepRepoInfo(sibling.blocking?.nodes ?? []);
+                    trackDepRepoInfo(sibling.blockedBy?.nodes ?? []);
+                }
+            }
             addIssueToMap(issueMap, {
                 id: expandedIssue.id,
                 number: expandedIssue.number,
                 title: expandedIssue.title,
                 state: expandedIssue.state,
+                repoOwner: expandOwner,
+                repoName: expandRepo,
                 parentNumber: expandedIssue.parent?.number ?? null,
                 subIssueNumbers: expandedIssue.subIssues.nodes.map((n) => n.number),
                 blockingNumbers: expandedIssue.blocking.nodes.map((n) => n.number),
@@ -247,7 +304,7 @@ export async function detectGroup(client, owner, repo, seedNumber) {
         }
         catch {
             // Skip issues that can't be fetched (cross-repo, permissions, etc.)
-            console.error(`[group-detection] Could not fetch issue #${num}, skipping (may be cross-repo)`);
+            console.error(`[group-detection] Could not fetch issue #${num} from ${expandOwner}/${expandRepo}, skipping`);
         }
     }
     // Step 3: Topological sort
@@ -258,13 +315,18 @@ export async function detectGroup(client, owner, repo, seedNumber) {
     // Step 4: Build result
     const groupTickets = sorted.map((num, index) => {
         const issue = issueMap.get(num);
-        return {
+        const result = {
             id: issue.id,
             number: issue.number,
             title: issue.title,
             state: issue.state,
             order: index + 1,
         };
+        // Include repository only for cross-repo issues
+        if (issue.repoOwner !== owner || issue.repoName !== repo) {
+            result.repository = `${issue.repoOwner}/${issue.repoName}`;
+        }
+        return result;
     });
     const primary = groupTickets[0] || {
         id: seedIssue.id,
@@ -301,13 +363,17 @@ function addIssueToMap(map, data) {
         if (data.parentNumber !== null && existing.parentNumber === null) {
             existing.parentNumber = data.parentNumber;
         }
-        // Prefer non-empty id/title/state
+        // Prefer non-empty id/title/state/repo
         if (!existing.id && data.id)
             existing.id = data.id;
         if (!existing.title && data.title)
             existing.title = data.title;
         if (!existing.state && data.state)
             existing.state = data.state;
+        if (!existing.repoOwner && data.repoOwner)
+            existing.repoOwner = data.repoOwner;
+        if (!existing.repoName && data.repoName)
+            existing.repoName = data.repoName;
     }
     else {
         map.set(data.number, { ...data });

package/dist/tools/decompose-tools.js

@@ -259,49 +259,51 @@ export function registerDecomposeTools(server, client, fieldCache) {
                     projectItemId,
                 });
             }
-            // Step 5: Wire dependencies (addSubIssue for dependency edges)
-            // Parse "a -> b" edges from dependency_chain; cross-repo sub-issues
-            // may not be supported — catch and continue.
+            // Step 5: Wire dependencies (addBlockedBy for dependency-flow edges)
+            // Parse "a -> b" edges: a blocks b (b is blocked by a)
             const wiringResults = [];
             for (const edge of decomposition.dependency_chain) {
                 const match = edge.match(/^\s*(\S+)\s*->\s*(\S+)\s*$/);
                 if (!match) {
                     wiringResults.push({
                         edge,
+                        type: "blockedBy",
                         status: "skipped",
                         reason: "Unrecognized edge format (expected 'a -> b')",
                     });
                     continue;
                 }
-                const [, fromRepo, toRepo] = match;
-                const fromIssue = createdIssues.find((i) => i.repoKey === fromRepo);
-                const toIssue = createdIssues.find((i) => i.repoKey === toRepo);
-                if (!fromIssue || !toIssue) {
+                const [, blockingRepo, blockedRepo] = match;
+                const blockingIssue = createdIssues.find((i) => i.repoKey === blockingRepo);
+                const blockedIssue = createdIssues.find((i) => i.repoKey === blockedRepo);
+                if (!blockingIssue || !blockedIssue) {
                     wiringResults.push({
                         edge,
+                        type: "blockedBy",
                         status: "skipped",
-                        reason: `Could not find created issue for repo "${fromRepo}" or "${toRepo}"`,
+                        reason: `Could not find created issue for repo "${blockingRepo}" or "${blockedRepo}"`,
                     });
                     continue;
                 }
                 try {
-                    await client.mutate(`mutation($parentId: ID!, $childId: ID!) {
-                addSubIssue(input: {
-                  issueId: $parentId,
-                  subIssueId: $childId
+                    await client.mutate(`mutation($blockedId: ID!, $blockingId: ID!) {
+                addBlockedBy(input: {
+                  issueId: $blockedId,
+                  blockingIssueId: $blockingId
                 }) {
                   issue { id }
-                  subIssue { id }
+                  blockingIssue { id }
                 }
-              }`, { parentId: fromIssue.id, childId: toIssue.id });
-                    wiringResults.push({ edge, status: "ok" });
+              }`, { blockedId: blockedIssue.id, blockingId: blockingIssue.id });
+                    wiringResults.push({ edge, type: "blockedBy", status: "ok" });
                 }
                 catch (err) {
                     const reason = err instanceof Error ? err.message : String(err);
                     wiringResults.push({
                         edge,
+                        type: "blockedBy",
                         status: "skipped",
-                        reason: `addSubIssue failed (cross-repo sub-issues may not be supported): ${reason}`,
+                        reason: `addBlockedBy failed: ${reason}`,
                     });
                 }
             }

package/dist/tools/relationship-tools.js

@@ -193,33 +193,55 @@ export function registerRelationshipTools(server, client, fieldCache) {
     // -------------------------------------------------------------------------
     // ralph_hero__add_dependency
     // -------------------------------------------------------------------------
-    server.tool("ralph_hero__add_dependency", "Create a blocking dependency between two GitHub issues. The 'blockingNumber' issue blocks the 'blockedNumber' issue.", {
+    server.tool("ralph_hero__add_dependency", "Create a blocking dependency between two GitHub issues. Supports cross-repo: " +
+        "the blocked and blocking issues can be in different repositories. " +
+        "The 'blockingNumber' issue blocks the 'blockedNumber' issue.", {
         owner: z
             .string()
             .optional()
-            .describe("GitHub owner. Defaults to GITHUB_OWNER env var"),
+            .describe("Default GitHub owner for both issues. Defaults to GITHUB_OWNER env var"),
         repo: z
             .string()
             .optional()
-            .describe("Repository name. Defaults to GITHUB_REPO env var"),
+            .describe("Default repository for both issues. Defaults to GITHUB_REPO env var"),
         blockedNumber: z
             .number()
             .describe("Issue number that IS blocked (cannot proceed until blocker is done)"),
+        blockedOwner: z
+            .string()
+            .optional()
+            .describe("GitHub owner for the blocked issue. Defaults to 'owner' param"),
+        blockedRepo: z
+            .string()
+            .optional()
+            .describe("Repository for the blocked issue. Defaults to 'repo' param"),
         blockingNumber: z
             .number()
             .describe("Issue number that IS the blocker (must be completed first)"),
+        blockingOwner: z
+            .string()
+            .optional()
+            .describe("GitHub owner for the blocking issue. Defaults to 'owner' param"),
+        blockingRepo: z
+            .string()
+            .optional()
+            .describe("Repository for the blocking issue. Defaults to 'repo' param"),
     }, async (args) => {
         try {
             const { owner, repo } = resolveConfig(client, args);
-            const blockedId = await resolveIssueNodeId(client, owner, repo, args.blockedNumber);
-            const blockingId = await resolveIssueNodeId(client, owner, repo, args.blockingNumber);
+            const bOwner = args.blockedOwner || owner;
+            const bRepo = args.blockedRepo || repo;
+            const kOwner = args.blockingOwner || owner;
+            const kRepo = args.blockingRepo || repo;
+            const blockedId = await resolveIssueNodeId(client, bOwner, bRepo, args.blockedNumber);
+            const blockingId = await resolveIssueNodeId(client, kOwner, kRepo, args.blockingNumber);
             const result = await client.mutate(`mutation($blockedId: ID!, $blockingId: ID!) {
             addBlockedBy(input: {
               issueId: $blockedId,
               blockingIssueId: $blockingId
             }) {
-              issue { id number title }
-              blockingIssue { id number title }
+              issue { id number title repository { nameWithOwner } }
+              blockingIssue { id number title repository { nameWithOwner } }
             }
           }`, { blockedId, blockingId });
             return toolSuccess({
@@ -227,11 +249,13 @@ export function registerRelationshipTools(server, client, fieldCache) {
                     id: result.addBlockedBy.issue.id,
                     number: result.addBlockedBy.issue.number,
                     title: result.addBlockedBy.issue.title,
+                    repository: result.addBlockedBy.issue.repository.nameWithOwner,
                 },
                 blocking: {
                     id: result.addBlockedBy.blockingIssue.id,
                     number: result.addBlockedBy.blockingIssue.number,
                     title: result.addBlockedBy.blockingIssue.title,
+                    repository: result.addBlockedBy.blockingIssue.repository.nameWithOwner,
                 },
             });
         }
@@ -243,29 +267,50 @@ export function registerRelationshipTools(server, client, fieldCache) {
     // -------------------------------------------------------------------------
     // ralph_hero__remove_dependency
     // -------------------------------------------------------------------------
-    server.tool("ralph_hero__remove_dependency", "Remove a blocking dependency between two GitHub issues", {
+    server.tool("ralph_hero__remove_dependency", "Remove a blocking dependency between two GitHub issues. Supports cross-repo: " +
+        "the blocked and blocking issues can be in different repositories.", {
         owner: z
             .string()
             .optional()
-            .describe("GitHub owner. Defaults to GITHUB_OWNER env var"),
+            .describe("Default GitHub owner for both issues. Defaults to GITHUB_OWNER env var"),
         repo: z
             .string()
             .optional()
-            .describe("Repository name. Defaults to GITHUB_REPO env var"),
+            .describe("Default repository for both issues. Defaults to GITHUB_REPO env var"),
         blockedNumber: z.coerce.number().describe("Issue number that was blocked"),
+        blockedOwner: z
+            .string()
+            .optional()
+            .describe("GitHub owner for the blocked issue. Defaults to 'owner' param"),
+        blockedRepo: z
+            .string()
+            .optional()
+            .describe("Repository for the blocked issue. Defaults to 'repo' param"),
         blockingNumber: z.coerce.number().describe("Issue number that was the blocker"),
+        blockingOwner: z
+            .string()
+            .optional()
+            .describe("GitHub owner for the blocking issue. Defaults to 'owner' param"),
+        blockingRepo: z
+            .string()
+            .optional()
+            .describe("Repository for the blocking issue. Defaults to 'repo' param"),
     }, async (args) => {
         try {
             const { owner, repo } = resolveConfig(client, args);
-            const blockedId = await resolveIssueNodeId(client, owner, repo, args.blockedNumber);
-            const blockingId = await resolveIssueNodeId(client, owner, repo, args.blockingNumber);
+            const bOwner = args.blockedOwner || owner;
+            const bRepo = args.blockedRepo || repo;
+            const kOwner = args.blockingOwner || owner;
+            const kRepo = args.blockingRepo || repo;
+            const blockedId = await resolveIssueNodeId(client, bOwner, bRepo, args.blockedNumber);
+            const blockingId = await resolveIssueNodeId(client, kOwner, kRepo, args.blockingNumber);
             const result = await client.mutate(`mutation($blockedId: ID!, $blockingId: ID!) {
             removeBlockedBy(input: {
               issueId: $blockedId,
               blockingIssueId: $blockingId
             }) {
-              issue { id number title }
-              blockingIssue { id number title }
+              issue { id number title repository { nameWithOwner } }
+              blockingIssue { id number title repository { nameWithOwner } }
             }
           }`, { blockedId, blockingId });
             return toolSuccess({
@@ -273,11 +318,13 @@ export function registerRelationshipTools(server, client, fieldCache) {
                     id: result.removeBlockedBy.issue.id,
                     number: result.removeBlockedBy.issue.number,
                     title: result.removeBlockedBy.issue.title,
+                    repository: result.removeBlockedBy.issue.repository.nameWithOwner,
                 },
                 blocking: {
                     id: result.removeBlockedBy.blockingIssue.id,
                     number: result.removeBlockedBy.blockingIssue.number,
                     title: result.removeBlockedBy.blockingIssue.title,
+                    repository: result.removeBlockedBy.blockingIssue.repository.nameWithOwner,
                 },
             });
         }
@@ -286,6 +333,85 @@ export function registerRelationshipTools(server, client, fieldCache) {
             return toolError(`Failed to remove dependency: ${message}`);
         }
     });
+    // -------------------------------------------------------------------------
+    // ralph_hero__list_dependencies
+    // -------------------------------------------------------------------------
+    server.tool("ralph_hero__list_dependencies", "List all blocking dependencies for a GitHub issue. Returns both 'blocking' " +
+        "(issues this issue blocks) and 'blockedBy' (issues blocking this issue) " +
+        "with full cross-repo context including repository name.", {
+        owner: z
+            .string()
+            .optional()
+            .describe("GitHub owner. Defaults to GITHUB_OWNER env var"),
+        repo: z
+            .string()
+            .optional()
+            .describe("Repository name. Defaults to GITHUB_REPO env var"),
+        number: z.coerce.number().describe("Issue number to query dependencies for"),
+    }, async (args) => {
+        try {
+            const { owner, repo } = resolveConfig(client, args);
+            const result = await client.query(`query($owner: String!, $repo: String!, $number: Int!) {
+            repository(owner: $owner, name: $repo) {
+              issue(number: $number) {
+                id
+                number
+                title
+                state
+                blocking(first: 50) {
+                  nodes {
+                    id number title state
+                    repository { nameWithOwner }
+                  }
+                }
+                blockedBy(first: 50) {
+                  nodes {
+                    id number title state
+                    repository { nameWithOwner }
+                  }
+                }
+              }
+            }
+          }`, { owner, repo, number: args.number });
+            const issue = result.repository?.issue;
+            if (!issue) {
+                return toolError(`Issue #${args.number} not found in ${owner}/${repo}`);
+            }
+            return toolSuccess({
+                issue: {
+                    id: issue.id,
+                    number: issue.number,
+                    title: issue.title,
+                    state: issue.state,
+                    repository: `${owner}/${repo}`,
+                },
+                blocking: issue.blocking.nodes.map((n) => ({
+                    id: n.id,
+                    number: n.number,
+                    title: n.title,
+                    state: n.state,
+                    repository: n.repository.nameWithOwner,
+                })),
+                blockedBy: issue.blockedBy.nodes.map((n) => ({
+                    id: n.id,
+                    number: n.number,
+                    title: n.title,
+                    state: n.state,
+                    repository: n.repository.nameWithOwner,
+                })),
+                summary: {
+                    blockingCount: issue.blocking.nodes.length,
+                    blockedByCount: issue.blockedBy.nodes.length,
+                    isBlocked: issue.blockedBy.nodes.length > 0,
+                    isBlocking: issue.blocking.nodes.length > 0,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return toolError(`Failed to list dependencies: ${message}`);
+        }
+    });
     // ralph_hero__advance_issue
     // -------------------------------------------------------------------------
     server.tool("ralph_hero__advance_issue", "Advance workflow state for related issues. " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-hero-mcp-server",
-  "version": "2.5.3",
+  "version": "2.5.13",
   "description": "MCP server for GitHub Projects V2 - Ralph workflow automation",
   "type": "module",
   "main": "dist/index.js",