plugin-git-manager 1.0.3 → 1.0.11

package/dist/server/actions/review.js

@@ -0,0 +1,620 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var review_exports = {};
+__export(review_exports, {
+  branchMatches: () => branchMatches,
+  pickFlowMatchingBranch: () => pickFlowMatchingBranch,
+  recoverStuckReviews: () => recoverStuckReviews,
+  reviewApprovePost: () => reviewApprovePost,
+  reviewReject: () => reviewReject,
+  triggerReview: () => triggerReview,
+  triggerReviewInternal: () => triggerReviewInternal
+});
+module.exports = __toCommonJS(review_exports);
+var import_gitlab_url = require("../utils/gitlab-url");
+var import_redact = require("../utils/redact");
+function targetKey(args) {
+  if (args.targetType === "mr") return `${args.repositoryId}:mr:${args.mrIid}`;
+  if (args.targetType === "commit") return `${args.repositoryId}:commit:${args.commitSha}`;
+  return `${args.repositoryId}:branch:${args.branch}`;
+}
+const TRIGGER_LOCK_TTL_MS = 3e4;
+async function withTriggerLock(app, key, fn) {
+  const lockKey = `git-review:trigger:${key}`;
+  return app.lockManager.runExclusive(lockKey, fn, TRIGGER_LOCK_TTL_MS);
+}
+async function triggerReview(ctx, next) {
+  var _a, _b, _c;
+  const params = { ...ctx.action.params, ...(_a = ctx.action.params) == null ? void 0 : _a.values, ...ctx.request.body || {} };
+  const {
+    flowId,
+    repositoryId,
+    targetType,
+    mrIid,
+    commitSha,
+    branch,
+    extraInstructions
+  } = params;
+  if (!repositoryId) ctx.throw(400, "repositoryId is required");
+  if (!targetType) ctx.throw(400, "targetType is required");
+  if (!["mr", "commit", "branch"].includes(targetType)) ctx.throw(400, "invalid targetType");
+  if (targetType === "mr" && !mrIid) ctx.throw(400, "mrIid is required for MR review");
+  if (targetType === "commit" && !commitSha) ctx.throw(400, "commitSha is required for commit review");
+  if (targetType === "branch" && !branch) ctx.throw(400, "branch is required for branch review");
+  const userId = (_c = (_b = ctx.state) == null ? void 0 : _b.currentUser) == null ? void 0 : _c.id;
+  try {
+    const reviewId = await triggerReviewInternal(ctx.app, {
+      flowId,
+      repositoryId: Number(repositoryId),
+      targetType,
+      mrIid: mrIid != null ? Number(mrIid) : null,
+      commitSha: commitSha || null,
+      branch: branch || null,
+      extraInstructions,
+      triggeredBy: "manual",
+      userId
+    });
+    ctx.body = { success: true, data: { reviewId } };
+  } catch (err) {
+    ctx.throw(err.status || 400, err.message || "Failed to trigger review");
+  }
+  await next();
+}
+async function triggerReviewInternal(app, args) {
+  return withTriggerLock(app, targetKey(args), () => triggerReviewInternalLocked(app, args));
+}
+async function triggerReviewInternalLocked(app, args) {
+  const db = app.db;
+  const flowsRepo = db.getRepository("gitReviewFlows");
+  let flow = null;
+  if (args.flowId) {
+    flow = await flowsRepo.findOne({ filterByTk: args.flowId });
+    if (!flow) throwHttp(404, "Review flow not found");
+    if (!flow.get("enabled")) throwHttp(400, "Review flow is disabled");
+  } else {
+    const candidates = await flowsRepo.find({
+      filter: {
+        enabled: true,
+        $or: [{ repositoryId: args.repositoryId }, { repositoryId: null }]
+      },
+      sort: ["-repositoryId"]
+    });
+    flow = pickFlowMatchingBranch(candidates, args.branch || void 0);
+    if (!flow) throwHttp(400, "No enabled review flow found for this repository");
+  }
+  if (args.branch && !branchMatches(flow, args.branch)) {
+    throwHttp(400, `Branch '${args.branch}' does not match flow's branchFilter`);
+  }
+  const aiEmployeeUsername = flow.get("aiEmployeeUsername");
+  if (!aiEmployeeUsername) throwHttp(400, "Flow has no AI employee configured");
+  const repo = await db.getRepository("gitRepositories").findOne({ filterByTk: args.repositoryId });
+  if (!repo) throwHttp(404, "Repository not found");
+  let headSha = args.headSha || null;
+  if (args.targetType === "mr" && !headSha && args.mrIid) {
+    headSha = await fetchMrHeadSha(repo, args.mrIid).catch(() => null);
+  }
+  const reviewsRepo = db.getRepository("gitCodeReviews");
+  const targetFilter = {
+    repositoryId: args.repositoryId,
+    targetType: args.targetType
+  };
+  if (args.targetType === "mr") targetFilter.mrIid = args.mrIid;
+  else if (args.targetType === "commit") targetFilter.commitSha = args.commitSha;
+  else if (args.targetType === "branch") targetFilter.branch = args.branch;
+  const existing = await reviewsRepo.findOne({ filter: targetFilter });
+  const existingLatestSha = existing == null ? void 0 : existing.get("latestSha");
+  const baseValues = {
+    flowId: flow.get("id"),
+    repositoryId: args.repositoryId,
+    targetType: args.targetType,
+    mrIid: args.targetType === "mr" ? args.mrIid : null,
+    commitSha: args.targetType === "commit" ? args.commitSha : null,
+    branch: args.branch || null,
+    headSha,
+    latestSha: headSha || existingLatestSha || null,
+    triggeredBy: args.triggeredBy || "manual",
+    status: "pending",
+    // Stamp startedAt synchronously so `recoverStuckReviews` can sweep rows
+    // that get stuck in `pending` (process died before runReview ran).
+    // runReview's own update will refresh this on actual start.
+    startedAt: /* @__PURE__ */ new Date(),
+    finishedAt: null,
+    durationMs: null,
+    postStatus: flow.get("postMode") === "disabled" ? "skipped" : "pending_approval",
+    error: null
+  };
+  let reviewId;
+  if (existing) {
+    const st = existing.get("status");
+    if (st === "running" || st === "pending") {
+      return existing.get("id");
+    }
+    await reviewsRepo.update({
+      filterByTk: existing.get("id"),
+      values: baseValues
+    });
+    reviewId = existing.get("id");
+  } else {
+    const review = await reviewsRepo.create({ values: baseValues });
+    reviewId = review.get("id");
+  }
+  setImmediate(
+    () => runReview(app, {
+      reviewId,
+      flow,
+      repo,
+      targetType: args.targetType,
+      mrIid: args.targetType === "mr" ? args.mrIid : null,
+      commitSha: args.targetType === "commit" ? args.commitSha : null,
+      branch: args.branch || void 0,
+      headSha,
+      aiEmployeeUsername,
+      extraInstructions: args.extraInstructions,
+      userId: args.userId ?? null
+    }).catch((err) => {
+      var _a, _b;
+      (_b = (_a = app.log) == null ? void 0 : _a.error) == null ? void 0 : _b.call(_a, "runReview background error", err);
+    })
+  );
+  return reviewId;
+}
+async function reviewApprovePost(ctx, next) {
+  var _a, _b, _c;
+  const params = { ...ctx.action.params, ...(_a = ctx.action.params) == null ? void 0 : _a.values, ...ctx.request.body || {} };
+  const { reviewId, editedMarkdown } = params;
+  if (!reviewId) ctx.throw(400, "reviewId is required");
+  const reviewsRepo = ctx.db.getRepository("gitCodeReviews");
+  const review = await reviewsRepo.findOne({ filterByTk: reviewId });
+  if (!review) ctx.throw(404, "Review not found");
+  if (review.get("status") !== "completed") ctx.throw(400, "Review is not completed");
+  if (review.get("targetType") !== "mr") ctx.throw(400, "Only MR reviews can be posted");
+  const markdown = editedMarkdown ?? review.get("reviewMarkdown");
+  if (!markdown) ctx.throw(400, "No review content to post");
+  const repo = await ctx.db.getRepository("gitRepositories").findOne({
+    filterByTk: review.get("repositoryId")
+  });
+  if (!repo) ctx.throw(404, "Repository not found");
+  const noteId = await postNoteToGitLab(repo, Number(review.get("mrIid")), markdown);
+  const userId = (_c = (_b = ctx.state) == null ? void 0 : _b.currentUser) == null ? void 0 : _c.id;
+  await reviewsRepo.update({
+    filterByTk: reviewId,
+    values: {
+      reviewMarkdown: markdown,
+      postStatus: "posted",
+      postedNoteId: String(noteId),
+      approvedBy: userId ? String(userId) : null,
+      approvedAt: /* @__PURE__ */ new Date()
+    }
+  });
+  ctx.body = { success: true, data: { reviewId, postedNoteId: noteId } };
+  await next();
+}
+async function reviewReject(ctx, next) {
+  var _a, _b, _c;
+  const params = { ...ctx.action.params, ...(_a = ctx.action.params) == null ? void 0 : _a.values, ...ctx.request.body || {} };
+  const { reviewId, reason } = params;
+  if (!reviewId) ctx.throw(400, "reviewId is required");
+  const reviewsRepo = ctx.db.getRepository("gitCodeReviews");
+  const review = await reviewsRepo.findOne({ filterByTk: reviewId });
+  if (!review) ctx.throw(404, "Review not found");
+  const userId = (_c = (_b = ctx.state) == null ? void 0 : _b.currentUser) == null ? void 0 : _c.id;
+  await reviewsRepo.update({
+    filterByTk: reviewId,
+    values: {
+      postStatus: "rejected",
+      approvedBy: userId ? String(userId) : null,
+      approvedAt: /* @__PURE__ */ new Date(),
+      error: reason ? `Rejected: ${reason}` : "Rejected"
+    }
+  });
+  ctx.body = { success: true, data: { reviewId } };
+  await next();
+}
+async function runReview(app, args) {
+  var _a, _b, _c, _d;
+  const db = app.db;
+  const reviewsRepo = db.getRepository("gitCodeReviews");
+  const startedAt = /* @__PURE__ */ new Date();
+  let sessionId = null;
+  try {
+    await reviewsRepo.update({
+      filterByTk: args.reviewId,
+      values: { status: "running", startedAt }
+    });
+    const employeeRecord = await db.getRepository("aiEmployees").findOne({
+      filter: { username: args.aiEmployeeUsername }
+    });
+    if (!employeeRecord) {
+      throw new Error(`AI employee '${args.aiEmployeeUsername}' not found`);
+    }
+    const conversation = await db.getRepository("aiConversations").create({
+      values: {
+        userId: args.userId ?? null,
+        aiEmployee: { username: args.aiEmployeeUsername },
+        options: {},
+        thread: 1
+      }
+    });
+    sessionId = conversation.get("sessionId") || null;
+    if (!sessionId) {
+      throw new Error("Failed to resolve sessionId from created aiConversation");
+    }
+    await reviewsRepo.update({
+      filterByTk: args.reviewId,
+      values: { sessionId }
+    });
+    const prompt = buildReviewPrompt(args);
+    const syntheticCtx = {
+      app,
+      db,
+      state: { currentUser: args.userId ? { id: args.userId } : null },
+      req: { headers: { "x-timezone": "UTC", "x-locale": "en-US" } },
+      get(name) {
+        return this.req.headers[String(name).toLowerCase()];
+      },
+      getCurrentLocale() {
+        return "en-US";
+      },
+      t(key) {
+        return key;
+      },
+      i18n: {
+        t(key) {
+          return key;
+        }
+      }
+    };
+    let AIEmployee;
+    for (const importPath of [
+      "@nocobase/plugin-ai/dist/server/ai-employees/ai-employee.js",
+      "@nocobase/plugin-ai/dist/server/ai-employees/ai-employee",
+      "@nocobase/plugin-ai/server"
+    ]) {
+      try {
+        const mod = await import(
+          /* webpackIgnore: true */
+          importPath
+        );
+        AIEmployee = mod.AIEmployee || ((_a = mod.default) == null ? void 0 : _a.AIEmployee);
+        if (AIEmployee) break;
+      } catch {
+      }
+    }
+    if (!AIEmployee) throw new Error("AIEmployee class not found \u2014 plugin-ai may not be installed or its exports changed");
+    const llmService = args.flow.get("llmService");
+    const model = args.flow.get("model");
+    const modelRef = llmService && model ? { llmService, model } : void 0;
+    const aiEmployee = new AIEmployee(
+      syntheticCtx,
+      employeeRecord,
+      sessionId,
+      void 0,
+      void 0,
+      false,
+      modelRef,
+      false
+    );
+    const REVIEW_TIMEOUT_MS = 5 * 60 * 1e3;
+    const result = await Promise.race([
+      aiEmployee.invoke({
+        userMessages: [
+          {
+            role: "user",
+            content: { type: "text", content: prompt }
+          }
+        ]
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("AI review timed out after 5 minutes")), REVIEW_TIMEOUT_MS)
+      )
+    ]);
+    const content = extractLastAiMessageContent(result);
+    if (!content) {
+      throw new Error("AI employee returned empty review content");
+    }
+    const finishedAt = /* @__PURE__ */ new Date();
+    const durationMs = finishedAt.getTime() - startedAt.getTime();
+    const postMode = args.flow.get("postMode");
+    let postStatus = "pending_approval";
+    let postedNoteId = null;
+    if (postMode === "disabled") {
+      postStatus = "skipped";
+    } else if (postMode === "auto" && args.targetType === "mr" && args.mrIid) {
+      try {
+        postedNoteId = String(await postNoteToGitLab(args.repo, args.mrIid, content));
+        postStatus = "posted";
+      } catch (err) {
+        (_c = (_b = app.log) == null ? void 0 : _b.error) == null ? void 0 : _c.call(_b, "Auto-post review note failed", err);
+      }
+    }
+    await reviewsRepo.update({
+      filterByTk: args.reviewId,
+      values: {
+        status: "completed",
+        reviewMarkdown: content,
+        rawOutput: JSON.stringify({
+          messageCount: ((_d = result == null ? void 0 : result.messages) == null ? void 0 : _d.length) ?? 0,
+          llmService: llmService || "default",
+          model: model || "default"
+        }),
+        durationMs,
+        finishedAt,
+        postStatus,
+        postedNoteId,
+        metadata: {
+          flowName: args.flow.get("name"),
+          aiEmployeeUsername: args.aiEmployeeUsername,
+          llmService,
+          model
+        }
+      }
+    });
+    if (sessionId) {
+      db.getRepository("aiConversations").destroy({ filterByTk: sessionId }).catch(() => void 0);
+    }
+  } catch (err) {
+    const finishedAt = /* @__PURE__ */ new Date();
+    const safeMessage = (0, import_redact.redactPat)((err == null ? void 0 : err.message) || String(err));
+    await reviewsRepo.update({
+      filterByTk: args.reviewId,
+      values: {
+        status: "failed",
+        error: safeMessage,
+        finishedAt,
+        durationMs: finishedAt.getTime() - startedAt.getTime()
+      }
+    });
+    if (sessionId) {
+      db.getRepository("aiConversations").destroy({ filterByTk: sessionId }).catch(() => void 0);
+    }
+  }
+}
+function buildReviewPrompt(args) {
+  const lines = [];
+  lines.push(`You are performing a code review on repository "${args.repo.get("name")}" (id=${args.repo.get("id")}).`);
+  lines.push("");
+  if (args.targetType === "mr") {
+    lines.push(`Target: Merge Request !${args.mrIid}.`);
+    lines.push(`Use the \`git_get_merge_request\` tool with repositoryId=${args.repo.get("id")} and mrIid=${args.mrIid} to fetch the diff and metadata.`);
+    lines.push("Optionally call `git_get_merge_request_notes` to avoid duplicating prior comments.");
+  } else if (args.targetType === "commit") {
+    lines.push(`Target: Commit ${args.commitSha}.`);
+    lines.push(`Use the \`git_get_commit\` tool with repositoryId=${args.repo.get("id")} and commitHash=${args.commitSha} to fetch the diff.`);
+  } else {
+    lines.push(`Target: Branch ${args.branch}.`);
+    lines.push(`Use \`git_list_commits\`, \`git_get_diff\`, and \`git_get_file_content\` (with repositoryId=${args.repo.get("id")}) to inspect recent changes on this branch.`);
+  }
+  lines.push("");
+  lines.push("Produce a thorough but concise code review report in Markdown. Required sections:");
+  lines.push("1. **Summary** \u2014 overall assessment.");
+  lines.push("2. **Findings** \u2014 issues grouped by severity (`Critical`, `High`, `Medium`, `Low`, `Info`). For each finding include the file path, line/range when possible, the problem, and a suggested fix.");
+  lines.push("3. **Suggestions** \u2014 non-blocking improvements.");
+  lines.push("4. **Verdict** \u2014 one of: `LGTM`, `Approve with comments`, `Request changes`, `Block`.");
+  lines.push("");
+  lines.push("Cite code snippets in fenced code blocks. Do not output anything outside the Markdown report.");
+  const flowInstructions = args.flow.get("instructions");
+  if (flowInstructions) {
+    lines.push("");
+    lines.push("---");
+    lines.push("Additional instructions from the review flow:");
+    lines.push(flowInstructions);
+  }
+  if (args.extraInstructions) {
+    lines.push("");
+    lines.push("---");
+    lines.push("Additional instructions for this run:");
+    lines.push(args.extraInstructions);
+  }
+  return lines.join("\n");
+}
+function extractLastAiMessageContent(result) {
+  const messages = result == null ? void 0 : result.messages;
+  if (!Array.isArray(messages)) return "";
+  const isAiMessage = (msg) => {
+    var _a;
+    if (!msg) return false;
+    if (typeof msg._getType === "function") {
+      try {
+        return msg._getType() === "ai";
+      } catch {
+      }
+    }
+    if (typeof msg.role === "string") {
+      const r = msg.role.toLowerCase();
+      return r === "assistant" || r === "ai";
+    }
+    if (typeof msg.type === "string" && msg.type.toLowerCase() === "ai") return true;
+    const name = (_a = msg == null ? void 0 : msg.constructor) == null ? void 0 : _a.name;
+    if (name === "AIMessage" || name === "AIMessageChunk") return true;
+    return false;
+  };
+  const getContent = (msg) => {
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      const textBlock = msg.content.find((c) => (c == null ? void 0 : c.type) === "text");
+      if (typeof (textBlock == null ? void 0 : textBlock.text) === "string") return textBlock.text;
+    }
+    return "";
+  };
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (!isAiMessage(msg)) continue;
+    const content = getContent(msg);
+    if (content) return content;
+  }
+  return "";
+}
+async function fetchMrHeadSha(repo, mrIid) {
+  var _a, _b;
+  const repoUrl = repo.get("repoUrl");
+  const pat = repo.get("pat");
+  if (!pat) return null;
+  const isGitHub = repoUrl.includes("github.com");
+  try {
+    if (isGitHub) {
+      const { projectPath } = (0, import_gitlab_url.parseGitLabProject)(repoUrl);
+      const response = await fetch(`https://api.github.com/repos/${projectPath}/pulls/${mrIid}`, {
+        headers: { "Authorization": `Bearer ${pat}`, Accept: "application/vnd.github.v3+json" }
+      });
+      if (!response.ok) return null;
+      const data = await response.json();
+      return ((_a = data == null ? void 0 : data.head) == null ? void 0 : _a.sha) || null;
+    } else {
+      const { apiBase, encodedProject } = (0, import_gitlab_url.parseGitLabProject)(repoUrl);
+      const response = await fetch(`${apiBase}/projects/${encodedProject}/merge_requests/${mrIid}`, {
+        headers: { "PRIVATE-TOKEN": pat, Accept: "application/json" }
+      });
+      if (!response.ok) return null;
+      const data = await response.json();
+      return (data == null ? void 0 : data.sha) || ((_b = data == null ? void 0 : data.diff_refs) == null ? void 0 : _b.head_sha) || null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function postNoteToGitLab(repo, mrIid, body) {
+  const repoUrl = repo.get("repoUrl");
+  const pat = repo.get("pat");
+  const isGitHub = repoUrl.includes("github.com");
+  if (isGitHub) {
+    if (!pat) throw new Error("Repository has no PAT configured");
+    const { projectPath } = (0, import_gitlab_url.parseGitLabProject)(repoUrl);
+    const response = await fetch(`https://api.github.com/repos/${projectPath}/issues/${mrIid}/comments`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${pat}`,
+        "Content-Type": "application/json",
+        "Accept": "application/vnd.github.v3+json"
+      },
+      body: JSON.stringify({ body })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`GitHub note post failed ${response.status}: ${text}`);
+    }
+    const data = await response.json();
+    return data == null ? void 0 : data.id;
+  } else {
+    if (!pat) throw new Error("Repository has no PAT configured");
+    const { apiBase, encodedProject } = (0, import_gitlab_url.parseGitLabProject)(repoUrl);
+    const response = await fetch(`${apiBase}/projects/${encodedProject}/merge_requests/${mrIid}/notes`, {
+      method: "POST",
+      headers: {
+        "PRIVATE-TOKEN": pat,
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      },
+      body: JSON.stringify({ body })
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`GitLab note post failed ${response.status}: ${text}`);
+    }
+    const data = await response.json();
+    return data == null ? void 0 : data.id;
+  }
+}
+const MAX_BRANCH_FILTER_LENGTH = 200;
+const loggedBadFilters = /* @__PURE__ */ new Set();
+function warnInvalidBranchFilter(filter, reason) {
+  if (loggedBadFilters.has(filter)) return;
+  loggedBadFilters.add(filter);
+  console.warn(
+    `[plugin-git-manager] branchFilter rejected (${reason}): ${JSON.stringify(filter)}. Flow will not match any branch.`
+  );
+}
+function branchMatches(flow, branch) {
+  const filter = flow.get("branchFilter");
+  if (!filter) return true;
+  if (filter.length > MAX_BRANCH_FILTER_LENGTH) {
+    warnInvalidBranchFilter(filter, `too long (>${MAX_BRANCH_FILTER_LENGTH} chars)`);
+    return false;
+  }
+  try {
+    return new RegExp(filter).test(branch);
+  } catch (err) {
+    warnInvalidBranchFilter(filter, `invalid regex: ${(err == null ? void 0 : err.message) || err}`);
+    return false;
+  }
+}
+function pickFlowMatchingBranch(flows, branch) {
+  if (!(flows == null ? void 0 : flows.length)) return null;
+  if (!branch) return flows[0];
+  for (const f of flows) {
+    if (branchMatches(f, branch)) return f;
+  }
+  return null;
+}
+function throwHttp(status, message) {
+  const err = new Error(message);
+  err.status = status;
+  throw err;
+}
+const STUCK_REVIEW_CUTOFF_MS = 10 * 60 * 1e3;
+async function recoverStuckReviews(app) {
+  var _a, _b, _c, _d;
+  try {
+    const reviewsRepo = app.db.getRepository("gitCodeReviews");
+    const cutoff = new Date(Date.now() - STUCK_REVIEW_CUTOFF_MS);
+    const stuck = await reviewsRepo.find({
+      filter: {
+        status: { $in: ["running", "pending"] },
+        startedAt: { $lt: cutoff }
+      }
+    });
+    if (!(stuck == null ? void 0 : stuck.length)) return 0;
+    const finishedAt = /* @__PURE__ */ new Date();
+    for (const review of stuck) {
+      const startedAt = review.get("startedAt");
+      const durationMs = startedAt ? finishedAt.getTime() - new Date(startedAt).getTime() : null;
+      await reviewsRepo.update({
+        filterByTk: review.get("id"),
+        values: {
+          status: "failed",
+          error: "Review interrupted by application restart",
+          finishedAt,
+          durationMs
+        }
+      });
+    }
+    (_b = (_a = app.log) == null ? void 0 : _a.info) == null ? void 0 : _b.call(_a, `plugin-git-manager: marked ${stuck.length} stuck review(s) as failed after restart`);
+    return stuck.length;
+  } catch (err) {
+    (_d = (_c = app.log) == null ? void 0 : _c.error) == null ? void 0 : _d.call(_c, `plugin-git-manager: recoverStuckReviews failed: ${err == null ? void 0 : err.message}`);
+    return 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  branchMatches,
+  pickFlowMatchingBranch,
+  recoverStuckReviews,
+  reviewApprovePost,
+  reviewReject,
+  triggerReview,
+  triggerReviewInternal
+});

package/dist/server/ai-tools.d.ts

@@ -0,0 +1,10 @@
+import type { Application } from '@nocobase/server';
+/**
+ * Register AI tools that allow an AI employee to inspect git repositories,
+ * merge requests, commits, and file content during a review session.
+ *
+ * Each tool is invoked by the AI runtime; the `invoke` callback constructs a
+ * synthetic `ctx.action.params` payload then delegates to the existing
+ * resource action implementation.
+ */
+export declare function registerGitReviewAiTools(app: Application): void;