ralph-hero-mcp-server 2.4.59 → 2.4.64

package/dist/github-client.js

@@ -8,6 +8,7 @@
 import { graphql } from "@octokit/graphql";
 import { RateLimiter } from "./lib/rate-limiter.js";
 import { SessionCache } from "./lib/cache.js";
+import { extractOperationName, sanitize } from "./lib/debug-logger.js";
 /**
  * The rateLimit fragment to include in every query for proactive tracking.
  */
@@ -23,7 +24,7 @@ const RATE_LIMIT_FRAGMENT = `
 /**
  * Create an authenticated GitHub GraphQL client.
  */
-export function createGitHubClient(clientConfig) {
+export function createGitHubClient(clientConfig, debugLogger) {
     const graphqlWithAuth = graphql.defaults({
         headers: {
             authorization: `token ${clientConfig.token}`,
@@ -61,6 +62,7 @@ export function createGitHubClient(clientConfig) {
                         fullQuery.slice(insertPos);
             }
         }
+        const t0 = Date.now();
         try {
             const response = await graphqlFn(fullQuery, variables || {});
             // Update rate limit tracker from response
@@ -70,9 +72,26 @@ export function createGitHubClient(clientConfig) {
                     rateLimiter.update(rl);
                 }
             }
+            debugLogger?.logGraphQL({
+                operation: extractOperationName(fullQuery),
+                variables: sanitize(variables),
+                durationMs: Date.now() - t0,
+                status: 200,
+                rateLimitRemaining: response.rateLimit?.remaining,
+                rateLimitCost: response.rateLimit?.cost,
+            });
             return response;
         }
         catch (error) {
+            debugLogger?.logGraphQL({
+                operation: extractOperationName(fullQuery),
+                variables: sanitize(variables),
+                durationMs: Date.now() - t0,
+                status: error && typeof error === "object" && "status" in error
+                    ? error.status
+                    : 500,
+                error: error instanceof Error ? error.message : String(error),
+            });
             // Handle rate limit errors (403)
             if (error &&
                 typeof error === "object" &&

package/dist/index.js

@@ -10,6 +10,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createGitHubClient } from "./github-client.js";
 import { FieldOptionCache } from "./lib/cache.js";
+import { createDebugLogger, wrapServerToolWithLogging } from "./lib/debug-logger.js";
 import { toolSuccess, resolveProjectOwner } from "./types.js";
 import { resolveRepoFromProject } from "./lib/helpers.js";
 import { registerProjectTools } from "./tools/project-tools.js";
@@ -22,6 +23,7 @@ import { registerProjectManagementTools } from "./tools/project-management-tools
 import { registerHygieneTools } from "./tools/hygiene-tools.js";
 import { registerRoutingTools } from "./tools/routing-tools.js";
 import { registerSyncTools } from "./tools/sync-tools.js";
+import { registerDebugTools } from "./tools/debug-tools.js";
 /**
  * Initialize the GitHub client from environment variables.
  */
@@ -32,7 +34,7 @@ function resolveEnv(name) {
         return undefined;
     return val;
 }
-function initGitHubClient() {
+function initGitHubClient(debugLogger) {
     // Repo token: for repository operations (issues, PRs, comments)
     const repoToken = resolveEnv("RALPH_GH_REPO_TOKEN") || resolveEnv("RALPH_HERO_GITHUB_TOKEN");
     // Project token: for Projects V2 operations (fields, workflow state)
@@ -97,7 +99,7 @@ function initGitHubClient() {
         projectNumbers,
         projectOwner: projectOwner || undefined,
         templateProjectNumber,
-    });
+    }, debugLogger);
 }
 /**
  * Register core tools on the MCP server.
@@ -238,7 +240,11 @@ function registerCoreTools(server, client) {
  */
 async function main() {
     console.error("[ralph-hero] Starting MCP server...");
-    const client = initGitHubClient();
+    const debugLogger = createDebugLogger();
+    if (debugLogger) {
+        console.error("[ralph-hero] Debug logging enabled (RALPH_DEBUG=true)");
+    }
+    const client = initGitHubClient(debugLogger);
     // Attempt lazy repo inference from project (non-fatal)
     try {
         await resolveRepoFromProject(client);
@@ -255,6 +261,10 @@ async function main() {
     });
     // Shared field option cache for project field lookups
     const fieldCache = new FieldOptionCache();
+    // Wrap server.tool with debug logging when RALPH_DEBUG=true
+    if (debugLogger) {
+        wrapServerToolWithLogging(server, debugLogger);
+    }
     // Register core tools
     registerCoreTools(server, client);
     // Phase 2: Project and view management tools
@@ -276,6 +286,10 @@ async function main() {
     registerRoutingTools(server, client, fieldCache);
     // Cross-project sync tools
     registerSyncTools(server, client, fieldCache);
+    // Debug tools (only when RALPH_DEBUG=true)
+    if (process.env.RALPH_DEBUG === 'true') {
+        registerDebugTools(server, client);
+    }
     // Connect via stdio transport
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/lib/debug-logger.js

@@ -0,0 +1,171 @@
+/**
+ * Debug logger for Ralph Hero MCP server.
+ *
+ * Captures tool calls, GraphQL operations, and hook events as JSONL
+ * when RALPH_DEBUG=true. Returns null when disabled for zero overhead.
+ * Follows the RateLimiter pattern (constructor + factory function).
+ */
+import { writeFile, appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
+// ---------------------------------------------------------------------------
+// Sanitization
+// ---------------------------------------------------------------------------
+const SENSITIVE_PATTERNS = /token|auth|secret|key|password|credential/i;
+/**
+ * Strip fields whose keys match sensitive patterns.
+ */
+export function sanitize(obj) {
+    if (!obj)
+        return obj;
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (SENSITIVE_PATTERNS.test(k)) {
+            result[k] = "[REDACTED]";
+        }
+        else {
+            result[k] = v;
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// DebugLogger
+// ---------------------------------------------------------------------------
+export class DebugLogger {
+    logPath = null;
+    logDir;
+    constructor(options) {
+        this.logDir =
+            options?.logDir ?? join(homedir(), ".ralph-hero", "logs");
+    }
+    async getLogPath() {
+        if (this.logPath)
+            return this.logPath;
+        await mkdir(this.logDir, { recursive: true });
+        const now = new Date();
+        const ts = now
+            .toISOString()
+            .replace(/[:.]/g, "-")
+            .replace("T", "-")
+            .replace("Z", "");
+        const rand = randomBytes(2).toString("hex");
+        this.logPath = join(this.logDir, `session-${ts}-${rand}.jsonl`);
+        // Create the file
+        await writeFile(this.logPath, "");
+        return this.logPath;
+    }
+    append(event) {
+        // Fire-and-forget — never block tool handlers
+        this.getLogPath()
+            .then((path) => appendFile(path, JSON.stringify(event) + "\n"))
+            .catch(console.error);
+    }
+    logGraphQL(fields) {
+        this.append({
+            ts: new Date().toISOString(),
+            cat: "graphql",
+            operation: fields.operation,
+            variables: sanitize(fields.variables),
+            durationMs: fields.durationMs,
+            status: fields.status,
+            rateLimitRemaining: fields.rateLimitRemaining,
+            rateLimitCost: fields.rateLimitCost,
+            ...(fields.error ? { error: fields.error } : {}),
+        });
+    }
+    logTool(fields) {
+        this.append({
+            ts: new Date().toISOString(),
+            cat: "tool",
+            tool: fields.tool,
+            params: sanitize(fields.params) ?? {},
+            durationMs: fields.durationMs,
+            ok: fields.ok,
+            ...(fields.error ? { error: fields.error } : {}),
+        });
+    }
+    /** Get the current log file path (for testing). */
+    getSessionLogPath() {
+        return this.logPath;
+    }
+}
+// ---------------------------------------------------------------------------
+// Factory & Wrapper
+// ---------------------------------------------------------------------------
+/**
+ * Create a DebugLogger if RALPH_DEBUG=true, otherwise null (zero overhead).
+ */
+export function createDebugLogger(options) {
+    if (process.env.RALPH_DEBUG !== "true")
+        return null;
+    return new DebugLogger(options);
+}
+/**
+ * Extract a GraphQL operation name from a query string.
+ */
+export function extractOperationName(queryString) {
+    const match = queryString.match(/(?:query|mutation)\s+(\w+)/);
+    return match?.[1];
+}
+/**
+ * Wrap a tool handler with debug logging.
+ * When logger is null, calls handler directly with zero overhead.
+ */
+export async function withLogging(logger, toolName, params, handler) {
+    if (!logger)
+        return handler();
+    const t0 = Date.now();
+    try {
+        const result = await handler();
+        logger.logTool({
+            tool: toolName,
+            params,
+            durationMs: Date.now() - t0,
+            ok: true,
+        });
+        return result;
+    }
+    catch (error) {
+        logger.logTool({
+            tool: toolName,
+            params,
+            durationMs: Date.now() - t0,
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+/**
+ * Monkey-patch McpServer.tool() to wrap all tool handlers with debug logging.
+ * Called once at startup when RALPH_DEBUG=true. Zero overhead when disabled
+ * (this function is never called).
+ *
+ * Uses `any` deliberately to handle McpServer's complex overloaded signatures.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function wrapServerToolWithLogging(server, logger) {
+    const originalTool = server.tool.bind(server);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    server.tool = (...args) => {
+        // server.tool(name, desc, schema, handler) or (name, desc, handler) or (name, handler)
+        // Handler is always the last argument and is a function
+        const name = args[0];
+        const handlerIdx = args.length - 1;
+        const originalHandler = args[handlerIdx];
+        if (typeof originalHandler !== "function") {
+            return originalTool(...args);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        args[handlerIdx] = async (...handlerArgs) => {
+            const params = handlerArgs[0] && typeof handlerArgs[0] === "object"
+                ? handlerArgs[0]
+                : {};
+            return withLogging(logger, name, params, () => originalHandler(...handlerArgs));
+        };
+        return originalTool(...args);
+    };
+}
+//# sourceMappingURL=debug-logger.js.map

package/dist/lib/pipeline-detection.js

@@ -167,6 +167,20 @@ export function detectStreamPipelinePositions(streams, issueStates) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+function computeSuggestedRoster(phase, issues) {
+    // Phase-aware: if past research, analyst = 0
+    const needsResearch = issues.filter(i => ['Research Needed', 'Research in Progress'].includes(i.workflowState));
+    let analyst = 0;
+    if (phase === 'RESEARCH' || phase === 'SPLIT' || phase === 'TRIAGE') {
+        analyst = needsResearch.length <= 1 ? 1
+            : needsResearch.length <= 5 ? 2
+                : 3;
+    }
+    // Builder scaling: default 1; 2 if 5+ issues with M/L estimates
+    const largeSized = issues.filter(i => i.estimate != null && ['M', 'L', 'XL'].includes(i.estimate));
+    const builder = largeSized.length >= 5 ? 2 : 1;
+    return { analyst, builder, validator: 1, integrator: 1 };
+}
 function buildResult(phase, reason, issues, isGroup, groupPrimary, convergence) {
     // Derive recommendation from convergence state
     let recommendation;
@@ -179,6 +193,7 @@ function buildResult(phase, reason, issues, isGroup, groupPrimary, convergence)
     else {
         recommendation = "wait";
     }
+    const suggestedRoster = computeSuggestedRoster(phase, issues);
     return {
         phase,
         reason,
@@ -187,6 +202,7 @@ function buildResult(phase, reason, issues, isGroup, groupPrimary, convergence)
         convergence: { ...convergence, recommendation },
         isGroup,
         groupPrimary,
+        suggestedRoster,
     };
 }
 //# sourceMappingURL=pipeline-detection.js.map

package/dist/tools/debug-tools.js

@@ -0,0 +1,338 @@
+/**
+ * MCP tools for debug log collation and statistics.
+ *
+ * Provides `ralph_hero__collate_debug` (error grouping + GitHub issue creation)
+ * and `ralph_hero__debug_stats` (tool call aggregation metrics).
+ *
+ * Only registered when RALPH_DEBUG=true. Reads JSONL logs written by DebugLogger.
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { toolSuccess, toolError } from "../types.js";
+// ---------------------------------------------------------------------------
+// JSONL Parsing
+// ---------------------------------------------------------------------------
+/**
+ * Read and parse all JSONL log files matching the time window.
+ */
+export async function readLogEvents(logDir, since) {
+    let files;
+    try {
+        files = await readdir(logDir);
+    }
+    catch {
+        return { events: [], sessionsAnalyzed: 0 };
+    }
+    const jsonlFiles = files
+        .filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"))
+        .sort();
+    const events = [];
+    let sessionsAnalyzed = 0;
+    for (const file of jsonlFiles) {
+        const content = await readFile(join(logDir, file), "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        let fileHasEvents = false;
+        for (const line of lines) {
+            try {
+                const event = JSON.parse(line);
+                if (new Date(event.ts) >= since) {
+                    events.push(event);
+                    fileHasEvents = true;
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        if (fileHasEvents)
+            sessionsAnalyzed++;
+    }
+    return { events, sessionsAnalyzed };
+}
+// ---------------------------------------------------------------------------
+// Error Collation
+// ---------------------------------------------------------------------------
+function isErrorEvent(event) {
+    return (event.ok === false ||
+        event.blocked === true ||
+        (event.exitCode !== undefined && event.exitCode !== 0));
+}
+function normalizeErrorMessage(msg) {
+    // Strip variable parts: numbers, hashes, timestamps, UUIDs
+    return msg
+        .replace(/\b[0-9a-f]{8,}\b/gi, "<HASH>")
+        .replace(/\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[.\dZ]*/g, "<TS>")
+        .replace(/\b\d+\b/g, "<N>")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 200);
+}
+function getEventName(event) {
+    return event.tool ?? event.operation ?? event.hook ?? "unknown";
+}
+function getErrorType(event) {
+    if (event.exitCode !== undefined)
+        return `exit:${event.exitCode}`;
+    if (event.blocked)
+        return "blocked";
+    return "error";
+}
+/**
+ * Build a signature string for grouping similar errors.
+ */
+export function buildSignature(event) {
+    const name = getEventName(event);
+    const errorType = getErrorType(event);
+    const normalized = normalizeErrorMessage(event.error ?? "");
+    return `${event.cat}:${name}:${errorType}:${normalized}`;
+}
+/**
+ * Hash a signature to an 8-char dedup key.
+ */
+export function hashSignature(signature) {
+    return createHash("sha256").update(signature).digest("hex").slice(0, 8);
+}
+/**
+ * Group error events by normalized signature.
+ */
+export function groupErrors(events) {
+    const errors = events.filter(isErrorEvent);
+    const groups = new Map();
+    for (const event of errors) {
+        const signature = buildSignature(event);
+        const hash = hashSignature(signature);
+        const existing = groups.get(hash);
+        if (existing) {
+            existing.count++;
+            if (event.ts > existing.lastSeen)
+                existing.lastSeen = event.ts;
+            if (event.ts < existing.firstSeen)
+                existing.firstSeen = event.ts;
+        }
+        else {
+            groups.set(hash, {
+                signature,
+                hash,
+                count: 1,
+                firstSeen: event.ts,
+                lastSeen: event.ts,
+                sample: event,
+            });
+        }
+    }
+    return Array.from(groups.values()).sort((a, b) => b.count - a.count);
+}
+// ---------------------------------------------------------------------------
+// Stats Aggregation
+// ---------------------------------------------------------------------------
+/**
+ * Aggregate tool call statistics.
+ */
+export function aggregateStats(events, groupBy) {
+    const toolEvents = events.filter((e) => e.cat === "tool");
+    const totalToolCalls = toolEvents.length;
+    const totalErrors = toolEvents.filter((e) => e.ok === false).length;
+    const groupMap = new Map();
+    for (const event of toolEvents) {
+        let key;
+        switch (groupBy) {
+            case "tool":
+                key = event.tool ?? "unknown";
+                break;
+            case "category":
+                key = event.cat;
+                break;
+            case "day":
+                key = event.ts.slice(0, 10); // YYYY-MM-DD
+                break;
+        }
+        const existing = groupMap.get(key) ?? { calls: 0, errors: 0, totalDuration: 0 };
+        existing.calls++;
+        if (event.ok === false)
+            existing.errors++;
+        existing.totalDuration += event.durationMs ?? 0;
+        groupMap.set(key, existing);
+    }
+    const groups = {};
+    for (const [key, data] of groupMap) {
+        groups[key] = {
+            calls: data.calls,
+            errors: data.errors,
+            errorRate: data.calls > 0 ? data.errors / data.calls : 0,
+            avgDurationMs: data.calls > 0 ? Math.round(data.totalDuration / data.calls) : 0,
+            totalDurationMs: data.totalDuration,
+        };
+    }
+    return {
+        totalToolCalls,
+        totalErrors,
+        errorRate: totalToolCalls > 0 ? totalErrors / totalToolCalls : 0,
+        groups,
+    };
+}
+// ---------------------------------------------------------------------------
+// Register Debug Tools
+// ---------------------------------------------------------------------------
+export function registerDebugTools(server, client) {
+    const logDir = join(homedir(), ".ralph-hero", "logs");
+    // -------------------------------------------------------------------------
+    // ralph_hero__collate_debug
+    // -------------------------------------------------------------------------
+    server.tool("ralph_hero__collate_debug", "Collate debug log errors into GitHub issues. Reads JSONL logs, groups errors by normalized signature, deduplicates against existing `debug-auto` labeled issues, and creates/updates issues. Returns: summary of issues created, updated, and total occurrences.", {
+        since: z
+            .string()
+            .optional()
+            .describe("ISO date string. Only process events after this time (default: 24h ago)"),
+        dryRun: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("If true, report what would be created/updated without making changes"),
+        projectNumber: z
+            .number()
+            .optional()
+            .describe("Project number override (defaults to configured project)"),
+    }, async (args) => {
+        try {
+            const sinceDate = args.since
+                ? new Date(args.since)
+                : new Date(Date.now() - 24 * 60 * 60 * 1000);
+            const { events, sessionsAnalyzed } = await readLogEvents(logDir, sinceDate);
+            const errorGroups = groupErrors(events);
+            if (errorGroups.length === 0) {
+                return toolSuccess({
+                    message: "No errors found in the specified time window.",
+                    sessionsAnalyzed,
+                    since: sinceDate.toISOString(),
+                });
+            }
+            let issuesCreated = 0;
+            let issuesUpdated = 0;
+            let totalOccurrences = 0;
+            const owner = client.config.owner;
+            const repo = client.config.repo;
+            for (const group of errorGroups) {
+                totalOccurrences += group.count;
+                if (args.dryRun)
+                    continue;
+                if (!owner || !repo) {
+                    return toolError("RALPH_GH_OWNER and RALPH_GH_REPO must be set for issue creation");
+                }
+                // Search for existing issue with this hash
+                const searchQuery = `repo:${owner}/${repo} is:issue is:open label:debug-auto "${group.hash}" in:body`;
+                let existingIssueNumber;
+                try {
+                    const searchResult = await client.query(`query SearchDebugIssues($q: String!) {
+                search(query: $q, type: ISSUE, first: 1) {
+                  nodes {
+                    ... on Issue { number }
+                  }
+                }
+              }`, { q: searchQuery });
+                    existingIssueNumber = searchResult.search.nodes[0]?.number;
+                }
+                catch {
+                    // Search failed, treat as no existing issue
+                }
+                if (existingIssueNumber) {
+                    // Add occurrence comment
+                    await client.mutate(`mutation AddComment($subjectId: ID!, $body: String!) {
+                addComment(input: { subjectId: $subjectId, body: $body }) {
+                  commentEdge { node { id } }
+                }
+              }`, {
+                        subjectId: `issue:${existingIssueNumber}`,
+                        body: `## Occurrence Report\n\n- Count: ${group.count}\n- Period: ${group.firstSeen} — ${group.lastSeen}\n- Signature: \`${group.signature}\``,
+                    }).catch(() => {
+                        // Best-effort comment
+                    });
+                    issuesUpdated++;
+                }
+                else {
+                    // Create new issue
+                    try {
+                        await client.mutate(`mutation CreateIssue($repoId: ID!, $title: String!, $body: String!) {
+                  createIssue(input: { repositoryId: $repoId, title: $title, body: $body }) {
+                    issue { number }
+                  }
+                }`, {
+                            repoId: `placeholder`, // Would need actual repo ID
+                            title: `[debug-auto] ${getEventName(group.sample)} ${getErrorType(group.sample)}`,
+                            body: `## Debug Auto-Report\n\n**Hash**: \`${group.hash}\`\n**Signature**: \`${group.signature}\`\n**Occurrences**: ${group.count}\n**First seen**: ${group.firstSeen}\n**Last seen**: ${group.lastSeen}\n\n### Sample Error\n\n\`\`\`json\n${JSON.stringify(group.sample, null, 2)}\n\`\`\`\n\n---\n_Auto-generated by ralph_hero__collate_debug_`,
+                        }).catch(() => {
+                            // Best-effort issue creation
+                        });
+                        issuesCreated++;
+                    }
+                    catch {
+                        // Skip failed creations
+                    }
+                }
+            }
+            return toolSuccess({
+                since: sinceDate.toISOString(),
+                sessionsAnalyzed,
+                errorGroups: errorGroups.length,
+                totalOccurrences,
+                issuesCreated: args.dryRun ? 0 : issuesCreated,
+                issuesUpdated: args.dryRun ? 0 : issuesUpdated,
+                dryRun: args.dryRun,
+                groups: errorGroups.map((g) => ({
+                    hash: g.hash,
+                    signature: g.signature,
+                    count: g.count,
+                    firstSeen: g.firstSeen,
+                    lastSeen: g.lastSeen,
+                })),
+            });
+        }
+        catch (error) {
+            return toolError(`Failed to collate debug logs: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    // -------------------------------------------------------------------------
+    // ralph_hero__debug_stats
+    // -------------------------------------------------------------------------
+    server.tool("ralph_hero__debug_stats", "Aggregate debug log statistics. Reads JSONL logs and returns tool call counts, error rates, and average durations grouped by tool, category, or day. Returns: totalToolCalls, totalErrors, errorRate, sessionsAnalyzed, per-group breakdown.", {
+        since: z
+            .string()
+            .optional()
+            .describe("ISO date string. Only process events after this time (default: 7 days ago)"),
+        groupBy: z
+            .enum(["tool", "category", "day"])
+            .optional()
+            .default("tool")
+            .describe("How to group statistics (default: 'tool')"),
+    }, async (args) => {
+        try {
+            const sinceDate = args.since
+                ? new Date(args.since)
+                : new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+            const { events, sessionsAnalyzed } = await readLogEvents(logDir, sinceDate);
+            if (events.length === 0) {
+                return toolSuccess({
+                    message: "No events found in the specified time window.",
+                    sessionsAnalyzed: 0,
+                    since: sinceDate.toISOString(),
+                });
+            }
+            const stats = aggregateStats(events, args.groupBy);
+            return toolSuccess({
+                since: sinceDate.toISOString(),
+                sessionsAnalyzed,
+                totalToolCalls: stats.totalToolCalls,
+                totalErrors: stats.totalErrors,
+                errorRate: Math.round(stats.errorRate * 10000) / 100, // percentage with 2 decimals
+                groupBy: args.groupBy,
+                groups: stats.groups,
+            });
+        }
+        catch (error) {
+            return toolError(`Failed to compute debug stats: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+}
+//# sourceMappingURL=debug-tools.js.map

package/dist/tools/project-management-tools.js

@@ -347,7 +347,7 @@ export function registerProjectManagementTools(server, client, fieldCache) {
               title: $title,
               body: $body
             }) {
-              projectItem { id }
+              draftIssue { id title }
             }
           }`, vars);
             return toolSuccess({

package/package.json

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