@debugg-ai/debugg-ai-mcp 3.7.4 → 3.8.0

package/dist/handlers/triggerCrawlHandler.js

@@ -20,6 +20,7 @@ import { probeLocalPort, probeTunnelHealth } from '../utils/localReachability.js
 import { extractLocalhostPort } from '../utils/urlParser.js';
 import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
 import { getCachedTemplateUuid, invalidateTemplateCache } from '../utils/handlerCaches.js';
+import { detectLocalGitRef } from '../utils/gitContext.js';
 import { getCrawlTemplateSlug } from '../services/workflows.js';
 import { isTransientWorkflowError, transientReasonTag } from '../utils/transientErrors.js';
 import { Telemetry, TelemetryEvents } from '../utils/telemetry.js';
@@ -179,6 +180,18 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
         contextData.headless = true; // D7: the MCP always runs headless — no opt-out.
         if (typeof input.timeoutSeconds === 'number')
             contextData.timeoutSeconds = input.timeoutSeconds;
+        // sentinal-lwtaw.13 (MCP side): the TRIGGER POINT owns the git fact. Attach
+        // the LOCAL checkout's branch + commit so the backend mints a git-backed
+        // Atlas version for this crawl — SAME snake_case contextData keys the
+        // PR-webhook path reads (commit_sha, branch). Best-effort + non-fatal:
+        // detectLocalGitRef never throws and a non-git target attaches nothing
+        // (honest no-git) and still crawls. Keys are set ONLY when present so we
+        // never fabricate a ref.
+        const gitRef = await detectLocalGitRef();
+        if (gitRef.commitSha)
+            contextData.commit_sha = gitRef.commitSha;
+        if (gitRef.branch)
+            contextData.branch = gitRef.branch;
         const env = {};
         if (input.environmentId)
             env.environmentId = input.environmentId;

package/dist/utils/gitContext.js

@@ -3,6 +3,9 @@
  * Parses the origin remote URL into "owner/repo" format.
  */
 import { execSync } from 'child_process';
+import { ProjectAnalyzer } from './projectAnalyzer.js';
+import { Logger } from './logger.js';
+const logger = new Logger({ module: 'gitContext' });
 let cached; // undefined = not yet checked
 /**
  * Detect the repo name (e.g. "debugg-ai/debugg-ai-frontend") from git remote origin.
@@ -25,6 +28,29 @@ export function detectRepoName() {
     }
     return cached;
 }
+/**
+ * Detect the LOCAL git ref (branch + commit sha) from the current working
+ * directory — the repo whose dev server the caller is crawling.
+ *
+ * sentinal-lwtaw.13 (MCP side): the TRIGGER POINT owns the git fact. The
+ * environment says WHERE to crawl; the caller supplies the ref it's running so
+ * the backend can mint a git-backed Atlas version. Delegates to
+ * ProjectAnalyzer's existing `.git/HEAD` readers — no new git parsing.
+ *
+ * Best-effort by contract: returns `{}` when cwd isn't a git repo (or the read
+ * fails). NEVER throws and NEVER fabricates a branch/sha — a git-less target
+ * must still crawl (honest no-git). NOT cached (unlike detectRepoName): the
+ * branch/commit change under a long-lived MCP process, so each crawl re-reads.
+ */
+export async function detectLocalGitRef() {
+    try {
+        return await new ProjectAnalyzer().getGitRef(process.cwd());
+    }
+    catch (err) {
+        logger.debug('Could not determine local git ref', err);
+        return {};
+    }
+}
 /**
  * Parse an origin URL into "owner/repo" format.
  * Handles SSH (git@github.com:owner/repo.git) and HTTPS (https://github.com/owner/repo.git).

package/dist/utils/projectAnalyzer.js

@@ -438,6 +438,29 @@ export class ProjectAnalyzer {
     extractRepoName(projectPath) {
         return projectPath.split('/').pop() || 'unknown';
     }
+    /**
+     * Best-effort local git ref (branch + full commit sha) for a project dir.
+     *
+     * Reuses the existing `.git/HEAD` readers (getCurrentBranch /
+     * getCurrentCommitHash) — no new git parsing. NEVER throws and NEVER
+     * fabricates: a non-git dir (or any read failure) yields `{}` so a git-less
+     * crawl target still crawls (honest no-git). Not cached — a long-lived MCP
+     * process must re-read after the caller checks out a branch or commits.
+     */
+    async getGitRef(repoPath) {
+        const projectPath = repoPath || process.cwd();
+        try {
+            const [branch, commitSha] = await Promise.all([
+                this.getCurrentBranch(projectPath),
+                this.getCurrentCommitHash(projectPath),
+            ]);
+            return { branch, commitSha };
+        }
+        catch (error) {
+            logger.debug('Could not determine local git ref', error);
+            return {};
+        }
+    }
     /**
      * Get current git branch (simplified)
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "3.7.4",
+  "version": "3.8.0",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {