570 lines
23 KiB
TypeScript
570 lines
23 KiB
TypeScript
import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
|
|
import type { Db } from "@paperclipai/db";
|
|
import {
|
|
documentAnnotationComments,
|
|
documentAnnotationThreads,
|
|
documents,
|
|
issueDocuments,
|
|
issueThreadInteractions,
|
|
} from "@paperclipai/db";
|
|
import type {
|
|
DocumentReviewContext,
|
|
DocumentReviewContextDocument,
|
|
PlanReviewContext,
|
|
PlanReviewContextAuthor,
|
|
PlanReviewInteractionContext,
|
|
PlanReviewInteractionResultContext,
|
|
PlanReviewInteractionTargetContext,
|
|
} from "@paperclipai/shared";
|
|
import { parseObject } from "../adapters/utils.js";
|
|
|
|
export const PLAN_REVIEW_CONTEXT_LIMITS = {
|
|
maxThreads: 20,
|
|
maxComments: 80,
|
|
maxBodyChars: 1_200,
|
|
maxTotalBodyChars: 12_000,
|
|
maxAnchorTextChars: 500,
|
|
} as const;
|
|
|
|
type BuildPlanReviewContextInput = {
|
|
db: Db;
|
|
companyId: string;
|
|
issueId: string;
|
|
issueWorkMode?: string | null;
|
|
includeForIssueComment?: boolean;
|
|
includeForAnnotationDelta?: boolean;
|
|
interactionId?: string | null;
|
|
};
|
|
|
|
type BuildDocumentReviewContextInput = Omit<BuildPlanReviewContextInput, "issueWorkMode" | "interactionId">;
|
|
|
|
function nonEmptyString(value: unknown) {
|
|
return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
|
|
}
|
|
|
|
function truncateText(value: string, maxChars: number) {
|
|
if (value.length <= maxChars) return { text: value, truncated: false };
|
|
return { text: value.slice(0, maxChars), truncated: true };
|
|
}
|
|
|
|
function authorFrom(row: {
|
|
authorType?: string | null;
|
|
authorAgentId?: string | null;
|
|
authorUserId?: string | null;
|
|
}): PlanReviewContextAuthor {
|
|
if (row.authorAgentId) return { type: "agent", id: row.authorAgentId };
|
|
if (row.authorUserId) return { type: "user", id: row.authorUserId };
|
|
return {
|
|
type: row.authorType === "agent" || row.authorType === "user" || row.authorType === "system"
|
|
? row.authorType
|
|
: "system",
|
|
id: null,
|
|
};
|
|
}
|
|
|
|
function readPlanTarget(value: unknown, issueId: string): PlanReviewInteractionTargetContext | null {
|
|
const target = parseObject(value);
|
|
if (target.type !== "issue_document") return null;
|
|
if (target.key !== "plan") return null;
|
|
// Issue-scoped interaction routes historically allowed the target to omit
|
|
// issueId because the parent interaction already supplies that boundary.
|
|
// Preserve an explicit mismatch check without dropping otherwise valid
|
|
// plan-review results (including the reviewer's rejection reason).
|
|
const targetIssueId = nonEmptyString(target.issueId);
|
|
if (targetIssueId !== null && targetIssueId !== issueId) return null;
|
|
return {
|
|
issueId,
|
|
documentId: nonEmptyString(target.documentId),
|
|
key: "plan",
|
|
revisionId: nonEmptyString(target.revisionId),
|
|
revisionNumber: typeof target.revisionNumber === "number" ? target.revisionNumber : null,
|
|
};
|
|
}
|
|
|
|
function readResult(value: unknown): PlanReviewInteractionResultContext | null {
|
|
const result = parseObject(value);
|
|
if (Object.keys(result).length === 0) return null;
|
|
return {
|
|
outcome: nonEmptyString(result.outcome),
|
|
reason: nonEmptyString(result.reason) ?? nonEmptyString(result.rejectionReason),
|
|
commentId: nonEmptyString(result.commentId),
|
|
};
|
|
}
|
|
|
|
async function getPlanInteractionContext(input: {
|
|
db: Db;
|
|
companyId: string;
|
|
issueId: string;
|
|
interactionId: string | null;
|
|
}): Promise<PlanReviewInteractionContext | null> {
|
|
if (!input.interactionId) return null;
|
|
|
|
const row = await input.db
|
|
.select({
|
|
id: issueThreadInteractions.id,
|
|
kind: issueThreadInteractions.kind,
|
|
status: issueThreadInteractions.status,
|
|
continuationPolicy: issueThreadInteractions.continuationPolicy,
|
|
sourceCommentId: issueThreadInteractions.sourceCommentId,
|
|
sourceRunId: issueThreadInteractions.sourceRunId,
|
|
payload: issueThreadInteractions.payload,
|
|
result: issueThreadInteractions.result,
|
|
resolvedAt: issueThreadInteractions.resolvedAt,
|
|
})
|
|
.from(issueThreadInteractions)
|
|
.where(and(
|
|
eq(issueThreadInteractions.id, input.interactionId),
|
|
eq(issueThreadInteractions.companyId, input.companyId),
|
|
eq(issueThreadInteractions.issueId, input.issueId),
|
|
))
|
|
.then((rows) => rows[0] ?? null);
|
|
|
|
if (!row) return null;
|
|
const payload = parseObject(row.payload);
|
|
const target = readPlanTarget(payload.target, input.issueId);
|
|
if (!target) return null;
|
|
const result = readResult(row.result);
|
|
|
|
return {
|
|
id: row.id,
|
|
kind: row.kind,
|
|
status: row.status,
|
|
continuationPolicy: row.continuationPolicy,
|
|
sourceCommentId: row.sourceCommentId ?? null,
|
|
sourceRunId: row.sourceRunId ?? null,
|
|
target,
|
|
acceptedTargetRevision: row.status === "accepted" ? target : null,
|
|
result,
|
|
resolvedAt: row.resolvedAt ? row.resolvedAt.toISOString() : null,
|
|
};
|
|
}
|
|
|
|
export async function buildPlanReviewContext(input: BuildPlanReviewContextInput): Promise<PlanReviewContext | null> {
|
|
const interaction = await getPlanInteractionContext({
|
|
db: input.db,
|
|
companyId: input.companyId,
|
|
issueId: input.issueId,
|
|
interactionId: nonEmptyString(input.interactionId),
|
|
});
|
|
const shouldInclude =
|
|
input.issueWorkMode === "planning" ||
|
|
input.includeForIssueComment === true ||
|
|
input.includeForAnnotationDelta === true ||
|
|
interaction !== null;
|
|
if (!shouldInclude) return null;
|
|
|
|
const planDocument = await input.db
|
|
.select({
|
|
documentId: documents.id,
|
|
latestRevisionId: documents.latestRevisionId,
|
|
latestRevisionNumber: documents.latestRevisionNumber,
|
|
})
|
|
.from(issueDocuments)
|
|
.innerJoin(documents, eq(issueDocuments.documentId, documents.id))
|
|
.where(and(
|
|
eq(issueDocuments.companyId, input.companyId),
|
|
eq(issueDocuments.issueId, input.issueId),
|
|
eq(issueDocuments.key, "plan"),
|
|
eq(documents.companyId, input.companyId),
|
|
))
|
|
.then((rows) => rows[0] ?? null);
|
|
if (!planDocument) return null;
|
|
|
|
const [{ count: openThreadCount }] = await input.db
|
|
.select({ count: sql<number>`count(*)::int` })
|
|
.from(documentAnnotationThreads)
|
|
.where(and(
|
|
eq(documentAnnotationThreads.companyId, input.companyId),
|
|
eq(documentAnnotationThreads.issueId, input.issueId),
|
|
eq(documentAnnotationThreads.documentId, planDocument.documentId),
|
|
eq(documentAnnotationThreads.documentKey, "plan"),
|
|
eq(documentAnnotationThreads.status, "open"),
|
|
));
|
|
|
|
const threadRows = await input.db
|
|
.select({
|
|
id: documentAnnotationThreads.id,
|
|
documentId: documentAnnotationThreads.documentId,
|
|
documentKey: documentAnnotationThreads.documentKey,
|
|
status: documentAnnotationThreads.status,
|
|
revisionId: documentAnnotationThreads.currentRevisionId,
|
|
revisionNumber: documentAnnotationThreads.currentRevisionNumber,
|
|
anchorState: documentAnnotationThreads.anchorState,
|
|
anchorConfidence: documentAnnotationThreads.anchorConfidence,
|
|
selectedText: documentAnnotationThreads.selectedText,
|
|
prefixText: documentAnnotationThreads.prefixText,
|
|
suffixText: documentAnnotationThreads.suffixText,
|
|
createdByAgentId: documentAnnotationThreads.createdByAgentId,
|
|
createdByUserId: documentAnnotationThreads.createdByUserId,
|
|
createdAt: documentAnnotationThreads.createdAt,
|
|
updatedAt: documentAnnotationThreads.updatedAt,
|
|
})
|
|
.from(documentAnnotationThreads)
|
|
.where(and(
|
|
eq(documentAnnotationThreads.companyId, input.companyId),
|
|
eq(documentAnnotationThreads.issueId, input.issueId),
|
|
eq(documentAnnotationThreads.documentId, planDocument.documentId),
|
|
eq(documentAnnotationThreads.documentKey, "plan"),
|
|
eq(documentAnnotationThreads.status, "open"),
|
|
))
|
|
.orderBy(desc(documentAnnotationThreads.updatedAt), desc(documentAnnotationThreads.id))
|
|
.limit(PLAN_REVIEW_CONTEXT_LIMITS.maxThreads);
|
|
|
|
const threadIds = threadRows.map((thread) => thread.id);
|
|
const commentRows = threadIds.length === 0
|
|
? []
|
|
: await input.db
|
|
.select({
|
|
id: documentAnnotationComments.id,
|
|
threadId: documentAnnotationComments.threadId,
|
|
body: documentAnnotationComments.body,
|
|
authorType: documentAnnotationComments.authorType,
|
|
authorAgentId: documentAnnotationComments.authorAgentId,
|
|
authorUserId: documentAnnotationComments.authorUserId,
|
|
createdAt: documentAnnotationComments.createdAt,
|
|
updatedAt: documentAnnotationComments.updatedAt,
|
|
})
|
|
.from(documentAnnotationComments)
|
|
.where(and(
|
|
eq(documentAnnotationComments.companyId, input.companyId),
|
|
eq(documentAnnotationComments.issueId, input.issueId),
|
|
eq(documentAnnotationComments.documentId, planDocument.documentId),
|
|
inArray(documentAnnotationComments.threadId, threadIds),
|
|
))
|
|
.orderBy(asc(documentAnnotationComments.createdAt), asc(documentAnnotationComments.id))
|
|
.limit(PLAN_REVIEW_CONTEXT_LIMITS.maxComments);
|
|
|
|
const [{ count: commentCount }] = await input.db
|
|
.select({ count: sql<number>`count(*)::int` })
|
|
.from(documentAnnotationComments)
|
|
.innerJoin(documentAnnotationThreads, eq(documentAnnotationComments.threadId, documentAnnotationThreads.id))
|
|
.where(and(
|
|
eq(documentAnnotationComments.companyId, input.companyId),
|
|
eq(documentAnnotationComments.issueId, input.issueId),
|
|
eq(documentAnnotationComments.documentId, planDocument.documentId),
|
|
eq(documentAnnotationThreads.companyId, input.companyId),
|
|
eq(documentAnnotationThreads.issueId, input.issueId),
|
|
eq(documentAnnotationThreads.documentId, planDocument.documentId),
|
|
eq(documentAnnotationThreads.documentKey, "plan"),
|
|
eq(documentAnnotationThreads.status, "open"),
|
|
));
|
|
|
|
const commentsByThread = new Map<string, typeof commentRows>();
|
|
for (const comment of commentRows) {
|
|
const existing = commentsByThread.get(comment.threadId) ?? [];
|
|
existing.push(comment);
|
|
commentsByThread.set(comment.threadId, existing);
|
|
}
|
|
|
|
let remainingBodyChars = PLAN_REVIEW_CONTEXT_LIMITS.maxTotalBodyChars;
|
|
let includedCommentCount = 0;
|
|
let truncated = openThreadCount > threadRows.length;
|
|
const threads = threadRows.map((thread) => {
|
|
const selectedText = truncateText(thread.selectedText, PLAN_REVIEW_CONTEXT_LIMITS.maxAnchorTextChars);
|
|
const prefixText = truncateText(thread.prefixText, PLAN_REVIEW_CONTEXT_LIMITS.maxAnchorTextChars);
|
|
const suffixText = truncateText(thread.suffixText, PLAN_REVIEW_CONTEXT_LIMITS.maxAnchorTextChars);
|
|
if (selectedText.truncated || prefixText.truncated || suffixText.truncated) truncated = true;
|
|
|
|
const threadComments = commentsByThread.get(thread.id) ?? [];
|
|
const comments = [];
|
|
for (const comment of threadComments) {
|
|
if (includedCommentCount >= PLAN_REVIEW_CONTEXT_LIMITS.maxComments || remainingBodyChars <= 0) {
|
|
truncated = true;
|
|
break;
|
|
}
|
|
const allowedChars = Math.min(PLAN_REVIEW_CONTEXT_LIMITS.maxBodyChars, remainingBodyChars);
|
|
const body = truncateText(comment.body, allowedChars);
|
|
if (body.truncated) truncated = true;
|
|
remainingBodyChars -= body.text.length;
|
|
includedCommentCount += 1;
|
|
comments.push({
|
|
id: comment.id,
|
|
threadId: comment.threadId,
|
|
body: body.text,
|
|
bodyTruncated: body.truncated,
|
|
author: authorFrom(comment),
|
|
createdAt: comment.createdAt.toISOString(),
|
|
updatedAt: comment.updatedAt.toISOString(),
|
|
});
|
|
}
|
|
|
|
const commentsTruncated = comments.length < threadComments.length;
|
|
if (commentsTruncated) truncated = true;
|
|
|
|
return {
|
|
id: thread.id,
|
|
documentKey: thread.documentKey,
|
|
documentId: thread.documentId,
|
|
status: thread.status,
|
|
revisionId: thread.revisionId,
|
|
revisionNumber: thread.revisionNumber,
|
|
anchorState: thread.anchorState,
|
|
anchorConfidence: thread.anchorConfidence,
|
|
selectedText: selectedText.text,
|
|
selectedTextTruncated: selectedText.truncated,
|
|
prefixText: prefixText.text,
|
|
prefixTextTruncated: prefixText.truncated,
|
|
suffixText: suffixText.text,
|
|
suffixTextTruncated: suffixText.truncated,
|
|
author: authorFrom({ authorAgentId: thread.createdByAgentId, authorUserId: thread.createdByUserId }),
|
|
commentCount: threadComments.length,
|
|
comments,
|
|
commentsTruncated,
|
|
createdAt: thread.createdAt.toISOString(),
|
|
updatedAt: thread.updatedAt.toISOString(),
|
|
};
|
|
});
|
|
|
|
const omittedCommentCount = Math.max(0, commentCount - includedCommentCount);
|
|
if (omittedCommentCount > 0) truncated = true;
|
|
|
|
return {
|
|
documentKey: "plan",
|
|
issueId: input.issueId,
|
|
latestRevisionId: planDocument.latestRevisionId,
|
|
latestRevisionNumber: planDocument.latestRevisionNumber,
|
|
threads,
|
|
interaction,
|
|
totals: {
|
|
openThreadCount,
|
|
includedThreadCount: threads.length,
|
|
omittedThreadCount: Math.max(0, openThreadCount - threads.length),
|
|
commentCount,
|
|
includedCommentCount,
|
|
omittedCommentCount,
|
|
},
|
|
limits: { ...PLAN_REVIEW_CONTEXT_LIMITS },
|
|
truncated,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Builds the non-plan half of issue-document review context. Plan context stays
|
|
* on its legacy builder and payload field so plan-only wakes remain byte-for-byte
|
|
* compatible. Budgets are shared across documents, while each document also
|
|
* observes the legacy per-document limits.
|
|
*/
|
|
export async function buildDocumentReviewContext(
|
|
input: BuildDocumentReviewContextInput,
|
|
): Promise<DocumentReviewContext | null> {
|
|
if (input.includeForIssueComment !== true && input.includeForAnnotationDelta !== true) return null;
|
|
|
|
const documentRows = await input.db
|
|
.select({
|
|
documentId: documents.id,
|
|
documentKey: issueDocuments.key,
|
|
title: documents.title,
|
|
latestRevisionId: documents.latestRevisionId,
|
|
latestRevisionNumber: documents.latestRevisionNumber,
|
|
updatedAt: issueDocuments.updatedAt,
|
|
})
|
|
.from(issueDocuments)
|
|
.innerJoin(documents, eq(issueDocuments.documentId, documents.id))
|
|
.where(and(
|
|
eq(issueDocuments.companyId, input.companyId),
|
|
eq(issueDocuments.issueId, input.issueId),
|
|
eq(documents.companyId, input.companyId),
|
|
sql`${issueDocuments.key} <> 'plan'`,
|
|
))
|
|
.orderBy(desc(issueDocuments.updatedAt), desc(issueDocuments.id));
|
|
if (documentRows.length === 0) return null;
|
|
|
|
let remainingThreads = PLAN_REVIEW_CONTEXT_LIMITS.maxThreads;
|
|
let remainingComments = PLAN_REVIEW_CONTEXT_LIMITS.maxComments;
|
|
let remainingBodyChars = PLAN_REVIEW_CONTEXT_LIMITS.maxTotalBodyChars;
|
|
let totalOpenThreads = 0;
|
|
let totalComments = 0;
|
|
let includedThreads = 0;
|
|
let includedComments = 0;
|
|
let truncated = false;
|
|
const groupedDocuments: DocumentReviewContextDocument[] = [];
|
|
|
|
for (const document of documentRows) {
|
|
const [{ count: openThreadCount }] = await input.db
|
|
.select({ count: sql<number>`count(*)::int` })
|
|
.from(documentAnnotationThreads)
|
|
.where(and(
|
|
eq(documentAnnotationThreads.companyId, input.companyId),
|
|
eq(documentAnnotationThreads.issueId, input.issueId),
|
|
eq(documentAnnotationThreads.documentId, document.documentId),
|
|
eq(documentAnnotationThreads.documentKey, document.documentKey),
|
|
eq(documentAnnotationThreads.status, "open"),
|
|
));
|
|
if (openThreadCount === 0) continue;
|
|
|
|
const perDocumentThreadLimit = Math.min(PLAN_REVIEW_CONTEXT_LIMITS.maxThreads, remainingThreads);
|
|
const threadRows = perDocumentThreadLimit === 0 ? [] : await input.db
|
|
.select({
|
|
id: documentAnnotationThreads.id,
|
|
documentId: documentAnnotationThreads.documentId,
|
|
documentKey: documentAnnotationThreads.documentKey,
|
|
status: documentAnnotationThreads.status,
|
|
revisionId: documentAnnotationThreads.currentRevisionId,
|
|
revisionNumber: documentAnnotationThreads.currentRevisionNumber,
|
|
anchorState: documentAnnotationThreads.anchorState,
|
|
anchorConfidence: documentAnnotationThreads.anchorConfidence,
|
|
selectedText: documentAnnotationThreads.selectedText,
|
|
prefixText: documentAnnotationThreads.prefixText,
|
|
suffixText: documentAnnotationThreads.suffixText,
|
|
createdByAgentId: documentAnnotationThreads.createdByAgentId,
|
|
createdByUserId: documentAnnotationThreads.createdByUserId,
|
|
createdAt: documentAnnotationThreads.createdAt,
|
|
updatedAt: documentAnnotationThreads.updatedAt,
|
|
})
|
|
.from(documentAnnotationThreads)
|
|
.where(and(
|
|
eq(documentAnnotationThreads.companyId, input.companyId),
|
|
eq(documentAnnotationThreads.issueId, input.issueId),
|
|
eq(documentAnnotationThreads.documentId, document.documentId),
|
|
eq(documentAnnotationThreads.documentKey, document.documentKey),
|
|
eq(documentAnnotationThreads.status, "open"),
|
|
))
|
|
.orderBy(desc(documentAnnotationThreads.updatedAt), desc(documentAnnotationThreads.id))
|
|
.limit(perDocumentThreadLimit);
|
|
|
|
const threadIds = threadRows.map((thread) => thread.id);
|
|
const perDocumentCommentLimit = Math.min(PLAN_REVIEW_CONTEXT_LIMITS.maxComments, remainingComments);
|
|
const commentRows = threadIds.length === 0 || perDocumentCommentLimit === 0 ? [] : await input.db
|
|
.select({
|
|
id: documentAnnotationComments.id,
|
|
threadId: documentAnnotationComments.threadId,
|
|
body: documentAnnotationComments.body,
|
|
authorType: documentAnnotationComments.authorType,
|
|
authorAgentId: documentAnnotationComments.authorAgentId,
|
|
authorUserId: documentAnnotationComments.authorUserId,
|
|
createdAt: documentAnnotationComments.createdAt,
|
|
updatedAt: documentAnnotationComments.updatedAt,
|
|
})
|
|
.from(documentAnnotationComments)
|
|
.where(and(
|
|
eq(documentAnnotationComments.companyId, input.companyId),
|
|
eq(documentAnnotationComments.issueId, input.issueId),
|
|
eq(documentAnnotationComments.documentId, document.documentId),
|
|
inArray(documentAnnotationComments.threadId, threadIds),
|
|
))
|
|
.orderBy(asc(documentAnnotationComments.createdAt), asc(documentAnnotationComments.id))
|
|
.limit(perDocumentCommentLimit);
|
|
|
|
const [{ count: commentCount }] = await input.db
|
|
.select({ count: sql<number>`count(*)::int` })
|
|
.from(documentAnnotationComments)
|
|
.innerJoin(documentAnnotationThreads, eq(documentAnnotationComments.threadId, documentAnnotationThreads.id))
|
|
.where(and(
|
|
eq(documentAnnotationComments.companyId, input.companyId),
|
|
eq(documentAnnotationComments.issueId, input.issueId),
|
|
eq(documentAnnotationComments.documentId, document.documentId),
|
|
eq(documentAnnotationThreads.companyId, input.companyId),
|
|
eq(documentAnnotationThreads.issueId, input.issueId),
|
|
eq(documentAnnotationThreads.documentId, document.documentId),
|
|
eq(documentAnnotationThreads.documentKey, document.documentKey),
|
|
eq(documentAnnotationThreads.status, "open"),
|
|
));
|
|
|
|
const commentsByThread = new Map<string, typeof commentRows>();
|
|
for (const comment of commentRows) {
|
|
const current = commentsByThread.get(comment.threadId) ?? [];
|
|
current.push(comment);
|
|
commentsByThread.set(comment.threadId, current);
|
|
}
|
|
|
|
let documentIncludedComments = 0;
|
|
let documentTruncated = openThreadCount > threadRows.length;
|
|
const threads = threadRows.map((thread) => {
|
|
const selectedText = truncateText(thread.selectedText, PLAN_REVIEW_CONTEXT_LIMITS.maxAnchorTextChars);
|
|
const prefixText = truncateText(thread.prefixText, PLAN_REVIEW_CONTEXT_LIMITS.maxAnchorTextChars);
|
|
const suffixText = truncateText(thread.suffixText, PLAN_REVIEW_CONTEXT_LIMITS.maxAnchorTextChars);
|
|
if (selectedText.truncated || prefixText.truncated || suffixText.truncated) documentTruncated = true;
|
|
const sourceComments = commentsByThread.get(thread.id) ?? [];
|
|
const comments = [];
|
|
for (const comment of sourceComments) {
|
|
if (remainingComments <= 0 || remainingBodyChars <= 0) {
|
|
documentTruncated = true;
|
|
break;
|
|
}
|
|
const body = truncateText(
|
|
comment.body,
|
|
Math.min(PLAN_REVIEW_CONTEXT_LIMITS.maxBodyChars, remainingBodyChars),
|
|
);
|
|
if (body.truncated) documentTruncated = true;
|
|
remainingBodyChars -= body.text.length;
|
|
remainingComments -= 1;
|
|
documentIncludedComments += 1;
|
|
includedComments += 1;
|
|
comments.push({
|
|
id: comment.id,
|
|
threadId: comment.threadId,
|
|
body: body.text,
|
|
bodyTruncated: body.truncated,
|
|
author: authorFrom(comment),
|
|
createdAt: comment.createdAt.toISOString(),
|
|
updatedAt: comment.updatedAt.toISOString(),
|
|
});
|
|
}
|
|
const commentsTruncated = comments.length < sourceComments.length;
|
|
if (commentsTruncated) documentTruncated = true;
|
|
return {
|
|
id: thread.id,
|
|
documentKey: thread.documentKey,
|
|
documentId: thread.documentId,
|
|
status: thread.status,
|
|
revisionId: thread.revisionId,
|
|
revisionNumber: thread.revisionNumber,
|
|
anchorState: thread.anchorState,
|
|
anchorConfidence: thread.anchorConfidence,
|
|
selectedText: selectedText.text,
|
|
selectedTextTruncated: selectedText.truncated,
|
|
prefixText: prefixText.text,
|
|
prefixTextTruncated: prefixText.truncated,
|
|
suffixText: suffixText.text,
|
|
suffixTextTruncated: suffixText.truncated,
|
|
author: authorFrom({ authorAgentId: thread.createdByAgentId, authorUserId: thread.createdByUserId }),
|
|
commentCount: sourceComments.length,
|
|
comments,
|
|
commentsTruncated,
|
|
createdAt: thread.createdAt.toISOString(),
|
|
updatedAt: thread.updatedAt.toISOString(),
|
|
};
|
|
});
|
|
|
|
remainingThreads -= threads.length;
|
|
totalOpenThreads += openThreadCount;
|
|
totalComments += commentCount;
|
|
includedThreads += threads.length;
|
|
if (commentCount > documentIncludedComments) documentTruncated = true;
|
|
if (documentTruncated) truncated = true;
|
|
groupedDocuments.push({
|
|
documentKey: document.documentKey,
|
|
documentId: document.documentId,
|
|
title: document.title,
|
|
latestRevisionId: document.latestRevisionId,
|
|
latestRevisionNumber: document.latestRevisionNumber,
|
|
threads,
|
|
totals: {
|
|
openThreadCount,
|
|
includedThreadCount: threads.length,
|
|
omittedThreadCount: Math.max(0, openThreadCount - threads.length),
|
|
commentCount,
|
|
includedCommentCount: documentIncludedComments,
|
|
omittedCommentCount: Math.max(0, commentCount - documentIncludedComments),
|
|
},
|
|
truncated: documentTruncated,
|
|
});
|
|
}
|
|
|
|
if (groupedDocuments.length === 0) return null;
|
|
return {
|
|
issueId: input.issueId,
|
|
documents: groupedDocuments,
|
|
totals: {
|
|
openThreadCount: totalOpenThreads,
|
|
includedThreadCount: includedThreads,
|
|
omittedThreadCount: Math.max(0, totalOpenThreads - includedThreads),
|
|
commentCount: totalComments,
|
|
includedCommentCount: includedComments,
|
|
omittedCommentCount: Math.max(0, totalComments - includedComments),
|
|
},
|
|
limits: { ...PLAN_REVIEW_CONTEXT_LIMITS },
|
|
truncated,
|
|
};
|
|
}
|