agentic-qe 3.15.8 → 3.15.10

package/dist/shared/base-domain-plugin.js

@@ -201,6 +201,12 @@ export class BaseDomainPlugin {
     canHandleTask(taskType) {
         return this.getTaskHandlers().has(taskType);
     }
+    /**
+     * Task types this domain executes, from its registered task handlers (#1075)
+     */
+    getSupportedTaskTypes() {
+        return Array.from(this.getTaskHandlers().keys());
+    }
     /**
      * Execute a task assigned by Queen Coordinator
      * Routes to the appropriate handler based on task type

package/dist/shared/git/git-analyzer.d.ts

@@ -57,6 +57,10 @@ export interface GitAnalyzerConfig {
     enableCache?: boolean;
     /** Cache TTL in milliseconds (default: 5 minutes) */
     cacheTtl?: number;
+    /** Deadline in milliseconds shared by the git calls of one analysis (default: 30 seconds) */
+    gitTimeoutMs?: number;
+    /** Deadline in milliseconds for all analyses of one file inside withFileDeadline() (default: 60 seconds) */
+    fileTimeoutMs?: number;
 }
 /**
  * Git Analyzer for defect prediction metrics
@@ -65,11 +69,27 @@ export declare class GitAnalyzer {
     private readonly config;
     private readonly cache;
     private isGitRepo;
+    /** After a rev-parse timeout, when to ask git again (until then: "timeout"). */
+    private repoRetryAt;
+    private readonly timedOutFiles;
+    /** Files inside withFileDeadline() and when their git time runs out. */
+    private readonly fileDeadlines;
     constructor(config?: GitAnalyzerConfig);
     /**
      * Check if current directory is a git repository
      */
     isGitRepository(): Promise<boolean>;
+    /**
+     * True when git timed out while analysing `filePath` since the last call, so
+     * the analysis returned its "git unavailable" default rather than a result.
+     */
+    consumeTimeout(filePath: string): boolean;
+    /**
+     * Run `work`, during which every analysis of `filePath` also stops at one
+     * shared `fileTimeoutMs` deadline. One file's analyses then wait for git at
+     * most that long together, rather than `gitTimeoutMs` each (#1115).
+     */
+    withFileDeadline<T>(filePath: string, work: () => Promise<T>): Promise<T>;
     /**
      * Get file change frequency (commits in last 90 days / 3)
      * Returns normalized value 0-1
@@ -98,6 +118,7 @@ export declare class GitAnalyzer {
      * Get files changed since a specific date
      * @param since - Date to check changes from (default: 24 hours ago)
      * @returns Array of changed file paths relative to repo root
+     * @throws GitTimeoutError when git does not answer within `gitTimeoutMs`
      */
     getChangedFiles(since?: Date): Promise<string[]>;
     /**
@@ -107,13 +128,41 @@ export declare class GitAnalyzer {
      * @throws Error when `commitHash` is option-shaped (starts with "-") or otherwise
      *   not a safe revision argument; git would otherwise parse it as an option
      *   (e.g. `--output=<path>` writes an arbitrary file). See issue #960.
+     * @throws GitTimeoutError when git does not answer within `gitTimeoutMs`
      */
     getCommitFiles(commitHash?: string): Promise<string[]>;
     /**
      * Get files with uncommitted changes (staged + unstaged)
      * @returns Array of modified file paths relative to repo root
+     * @throws GitTimeoutError when git does not answer within `gitTimeoutMs`
      */
     getUncommittedFiles(): Promise<string[]>;
+    /**
+     * Count commits whose message matches any bug keyword, in one `git log`
+     * (repeated --grep patterns are OR-ed). Keywords are sanitized arguments and
+     * never reach a shell.
+     */
+    private countBugFixCommits;
+    /**
+     * Run one file's analysis with every git call sharing one `gitTimeoutMs`
+     * deadline (#1115). When git is unavailable or times out, the analysis
+     * returns its default, which callers treat as "no git data", and a timeout
+     * is recorded for consumeTimeout(). A timeout never yields a measured 0.
+     */
+    private analyze;
+    /**
+     * Whether the repo root is a git work tree. A timeout is not an answer: it
+     * is remembered for `cacheTtl` so a hung git is not waited on for every
+     * file, and then git is asked again.
+     */
+    private repoState;
+    /**
+     * Git queries in the repo root that share a deadline of `gitTimeoutMs` from
+     * now, or `fileDeadline` when that comes first. Git runs asynchronously in its own process group, so a slow or hung
+     * git (a network filesystem, a credential prompt) neither blocks the MCP
+     * server's event loop nor outlives its deadline (#1115).
+     */
+    private query;
     /**
      * Get relative path from repo root
      */