@agent-native/core 0.100.2 → 0.101.2

package/corpus/core/src/client/review/index.ts

@@ -1,3 +1,7 @@
+export {
+  ReviewCommentComposer,
+  type ReviewCommentComposerProps,
+} from "./ReviewCommentComposer.js";
 export {
   ReviewStatusBadge,
   type ReviewStatusBadgeProps,
@@ -6,6 +10,8 @@ export {
   ReviewThreadPanel,
   buildReviewThreads,
   type ReviewThread,
+  type ReviewCommentCapability,
+  type ReviewThreadCapability,
   type ReviewThreadPanelProps,
 } from "./ReviewThreadPanel.js";
 export {
@@ -17,6 +23,7 @@ export {
   useReviewComments,
   useReviewFeedback,
   useSetReviewStatus,
+  useSendReviewThreadToAgent,
   type ConsumeReviewFeedbackInput,
   type CreateReviewCommentInput,
   type DeleteReviewCommentInput,
@@ -27,4 +34,5 @@ export {
   type ReplyReviewCommentInput,
   type ResolveReviewThreadInput,
   type SetReviewStatusInput,
+  type SendReviewThreadToAgentInput,
 } from "./use-review.js";

package/corpus/core/src/client/review/use-review.ts

@@ -20,6 +20,10 @@ export interface ListReviewCommentsParams {
 export interface ListReviewCommentsResult {
   comments: ReviewComment[];
   reviewStatus: ReviewStatusEntry | null;
+  summary: {
+    openCount: number;
+    agentQueueCount: number;
+  };
 }
 
 export interface GetReviewFeedbackParams {
@@ -62,6 +66,7 @@ export interface ResolveReviewThreadInput {
   resourceId: string;
   threadId?: string;
   commentId?: string;
+  resolutionNote?: string;
 }
 
 export interface DeleteReviewCommentInput {
@@ -76,6 +81,12 @@ export interface ConsumeReviewFeedbackInput {
   commentIds: string[];
 }
 
+export interface SendReviewThreadToAgentInput {
+  resourceType: string;
+  resourceId: string;
+  threadId: string;
+}
+
 export interface SetReviewStatusInput {
   resourceType: string;
   resourceId: string;
@@ -126,7 +137,13 @@ export function useReplyReviewComment() {
 
 export function useResolveReviewThread() {
   return useActionMutation<
-    { threadId: string; resolved: true; updatedCount: number },
+    {
+      threadId: string;
+      resolved: true;
+      updatedCount: number;
+      resolutionNote: string | null;
+      comment: ReviewComment;
+    },
     ResolveReviewThreadInput
   >("resolve-review-thread");
 }
@@ -145,6 +162,23 @@ export function useConsumeReviewFeedback() {
   >("consume-review-feedback");
 }
 
+export function useSendReviewThreadToAgent() {
+  return useActionMutation<
+    {
+      resourceType: string;
+      resourceId: string;
+      threadId: string;
+      resolutionTarget: "agent";
+      consumedAt: null;
+      updatedCount: number;
+      ownerEmail: string | null;
+      orgId: string | null;
+      visibility: "private" | "org" | "public";
+    },
+    SendReviewThreadToAgentInput
+  >("send-review-thread-to-agent");
+}
+
 export function useSetReviewStatus() {
   return useActionMutation<ReviewStatusEntry, SetReviewStatusInput>(
     "set-review-status",

package/corpus/core/src/client/use-agent-chat-context.ts

@@ -26,7 +26,7 @@ export interface UseAgentChatContextResult extends AgentChatContextState {
  * composer's staged context chips. Simple send/prefill flows should use
  * `sendToAgentChat({ message, context, submit })` directly.
  */
-export function useAgentChatContext(): UseAgentChatContextResult {
+export function useAgentChatContext(enabled = true): UseAgentChatContextResult {
   const appStateVersion = useChangeVersion("app-state");
   const state = useSyncExternalStore(
     subscribeAgentChatContext,
@@ -35,8 +35,9 @@ export function useAgentChatContext(): UseAgentChatContextResult {
   );
 
   useEffect(() => {
+    if (!enabled) return;
     void refreshAgentChatContext();
-  }, [appStateVersion]);
+  }, [appStateVersion, enabled]);
 
   const set = useCallback((item: AgentChatContextSetOptions) => {
     setAgentChatContextItem(item);

package/corpus/core/src/review/actions/create-review-comment.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import { reviewAuthorNameFromContext } from "../identity.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
 import {
   assertReviewableResourceAccess,
@@ -68,7 +69,7 @@ export default defineAction({
       anchor: args.anchor ?? null,
       body: args.body,
       authorEmail: actionCtx?.userEmail ?? null,
-      authorName: args.authorName ?? actionCtx?.userEmail ?? null,
+      authorName: args.authorName ?? reviewAuthorNameFromContext(actionCtx),
       createdBy: actorKindFromContext(actionCtx),
       resolutionTarget,
       mentions,

package/corpus/core/src/review/actions/get-review-feedback.ts

@@ -37,18 +37,13 @@ export default defineAction({
       bypassScope: true,
       includeResolved: false,
       includeDeleted: false,
+      rootOnly: true,
+      resolutionTargets: args.includeHumanTargeted
+        ? undefined
+        : ["agent", null],
+      unconsumedOnly: true,
       limit: args.limit,
     });
-    return {
-      comments: comments.filter((comment) => {
-        if (comment.consumedAt) {
-          return false;
-        }
-        if (args.includeHumanTargeted) {
-          return true;
-        }
-        return comment.resolutionTarget !== "human";
-      }),
-    };
+    return { comments };
   },
 });

package/corpus/core/src/review/actions/list-review-comments.ts

@@ -1,8 +1,17 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import {
+  redactPublicReviewCommentIdentity,
+  redactPublicReviewStatusIdentity,
+  shouldRedactReviewIdentity,
+} from "../identity.js";
 import { assertReviewableResourceAccess } from "../registry.js";
-import { getReviewStatus, queryReviewComments } from "../store.js";
+import {
+  getReviewStatus,
+  getReviewThreadSummary,
+  queryReviewComments,
+} from "../store.js";
 import type { ReviewResourceContext } from "../types.js";
 
 const schema = z.object({
@@ -19,11 +28,12 @@ export default defineAction({
     "List inline comments, annotations, and review threads for a resource.",
   schema,
   http: { method: "GET" },
+  requiresAuth: false,
   readOnly: true,
   parallelSafe: true,
   run: async (args, ctx) => {
     const actionCtx = ctx as ReviewResourceContext | undefined;
-    await assertReviewableResourceAccess(
+    const access = await assertReviewableResourceAccess(
       args.resourceType,
       args.resourceId,
       actionCtx,
@@ -33,7 +43,7 @@ export default defineAction({
       userEmail: actionCtx?.userEmail ?? null,
       orgId: actionCtx?.orgId ?? null,
     };
-    const [comments, reviewStatus] = await Promise.all([
+    const [comments, reviewStatus, summary] = await Promise.all([
       queryReviewComments({
         resourceType: args.resourceType,
         resourceId: args.resourceId,
@@ -47,7 +57,31 @@ export default defineAction({
       getReviewStatus(args.resourceType, args.resourceId, scope, {
         bypassScope: true,
       }),
+      getReviewThreadSummary({
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+        scope,
+        bypassScope: true,
+        targetId: args.targetId,
+      }),
     ]);
-    return { comments, reviewStatus };
+    const redactIdentity = shouldRedactReviewIdentity(actionCtx, access);
+    const commentsWithCapabilities = comments.map((comment) => ({
+      ...comment,
+      canDelete:
+        access.role !== "viewer" ||
+        Boolean(
+          actionCtx?.userEmail && comment.authorEmail === actionCtx.userEmail,
+        ),
+    }));
+    return redactIdentity
+      ? {
+          comments: commentsWithCapabilities.map(
+            redactPublicReviewCommentIdentity,
+          ),
+          reviewStatus: redactPublicReviewStatusIdentity(reviewStatus),
+          summary,
+        }
+      : { comments: commentsWithCapabilities, reviewStatus, summary };
   },
 });

package/corpus/core/src/review/actions/reply-review-comment.ts

@@ -1,12 +1,13 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import { reviewAuthorNameFromContext } from "../identity.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
 import {
   assertReviewableResourceAccess,
   normalizeReviewVisibility,
 } from "../registry.js";
-import { getReviewCommentById, insertReviewComment } from "../store.js";
+import { getReviewCommentById, insertReviewReply } from "../store.js";
 import type { ReviewActorKind, ReviewResourceContext } from "../types.js";
 
 const mentionSchema = z.object({
@@ -51,32 +52,42 @@ export default defineAction({
     ) {
       throw new Error("Review comment not found");
     }
+    if (parent.status !== "open") {
+      throw new Error("Review thread is not open");
+    }
     const mentions = normalizeReviewMentions([
       ...normalizeReviewMentions(args.mentions),
       ...extractReviewMentions(args.body),
     ]);
 
-    return insertReviewComment({
-      resourceType: args.resourceType,
-      resourceId: args.resourceId,
-      threadId: parent.threadId,
-      parentCommentId: parent.id,
-      targetId: parent.targetId,
-      kind: parent.kind,
-      anchor: parent.anchor,
-      body: args.body,
-      authorEmail: actionCtx?.userEmail ?? null,
-      authorName: args.authorName ?? actionCtx?.userEmail ?? null,
-      createdBy: actorKindFromContext(actionCtx),
-      resolutionTarget:
-        args.resolutionTarget ??
-        (mentions.length > 0 ? "human" : parent.resolutionTarget),
-      mentions,
-      ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
-      orgId: access.orgId ?? actionCtx?.orgId ?? null,
-      visibility: normalizeReviewVisibility(access.visibility),
-      metadata: args.metadata,
-    });
+    const routeTarget =
+      args.resolutionTarget ?? (mentions.length > 0 ? "human" : null);
+    return insertReviewReply(
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+        threadId: parent.threadId,
+        parentCommentId: parent.id,
+        targetId: parent.targetId,
+        kind: parent.kind,
+        anchor: parent.anchor,
+        body: args.body,
+        authorEmail: actionCtx?.userEmail ?? null,
+        authorName: args.authorName ?? reviewAuthorNameFromContext(actionCtx),
+        createdBy: actorKindFromContext(actionCtx),
+        resolutionTarget: null,
+        mentions,
+        ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
+        orgId: access.orgId ?? actionCtx?.orgId ?? null,
+        visibility: normalizeReviewVisibility(access.visibility),
+        metadata: args.metadata,
+      },
+      routeTarget,
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+      },
+    );
   },
   audit: {
     target: (args, result) => {

package/corpus/core/src/review/actions/resolve-review-thread.ts

@@ -2,7 +2,11 @@ import { z } from "zod";
 
 import { defineAction } from "../../action.js";
 import { assertReviewableResourceAccess } from "../registry.js";
-import { getReviewCommentById, resolveReviewThread } from "../store.js";
+import {
+  getReviewCommentById,
+  getReviewThreadRoot,
+  resolveReviewThread,
+} from "../store.js";
 import type { ReviewResourceContext } from "../types.js";
 
 const schema = z.object({
@@ -10,6 +14,7 @@ const schema = z.object({
   resourceId: z.string().min(1),
   threadId: z.string().optional(),
   commentId: z.string().optional(),
+  resolutionNote: z.string().trim().min(1).max(2_000).optional(),
 });
 
 export default defineAction({
@@ -52,11 +57,33 @@ export default defineAction({
         resourceType: args.resourceType,
         resourceId: args.resourceId,
       },
+      args.resolutionNote,
     );
     if (updatedCount < 1) {
       throw new Error("Review thread not found");
     }
-    return { threadId, resolved: true as const, updatedCount };
+    const comment = await getReviewThreadRoot(
+      threadId,
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+      },
+      {
+        userEmail: actionCtx?.userEmail ?? null,
+        orgId: actionCtx?.orgId ?? null,
+      },
+      { bypassScope: true },
+    );
+    if (!comment) {
+      throw new Error("Resolved review thread could not be verified");
+    }
+    return {
+      threadId,
+      resolved: true as const,
+      updatedCount,
+      resolutionNote: comment.resolutionNote ?? null,
+      comment,
+    };
   },
   audit: {
     target: (args) => ({

package/corpus/core/src/review/actions/send-review-thread-to-agent.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+import { defineAction } from "../../action.js";
+import { assertReviewableResourceAccess } from "../registry.js";
+import { sendReviewThreadToAgent } from "../store.js";
+import type { ReviewResourceContext } from "../types.js";
+
+const schema = z.object({
+  resourceType: z.string().min(1),
+  resourceId: z.string().min(1),
+  threadId: z.string().min(1),
+});
+
+export default defineAction({
+  description:
+    "Send one open review thread to the agent queue without routing other threads.",
+  schema,
+  run: async (args, ctx) => {
+    const actionCtx = ctx as ReviewResourceContext | undefined;
+    const access = await assertReviewableResourceAccess(
+      args.resourceType,
+      args.resourceId,
+      actionCtx,
+      "editor",
+    );
+    const updatedCount = await sendReviewThreadToAgent(args.threadId, {
+      resourceType: args.resourceType,
+      resourceId: args.resourceId,
+    });
+    if (updatedCount < 1) {
+      throw new Error("Open review thread not found");
+    }
+    return {
+      resourceType: args.resourceType,
+      resourceId: args.resourceId,
+      threadId: args.threadId,
+      resolutionTarget: "agent" as const,
+      consumedAt: null,
+      updatedCount,
+      ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
+      orgId: access.orgId ?? actionCtx?.orgId ?? null,
+      visibility: access.visibility ?? "private",
+    };
+  },
+  audit: {
+    target: (args, result) => {
+      const routed = result as {
+        ownerEmail?: string | null;
+        orgId?: string | null;
+        visibility?: "private" | "org" | "public";
+      };
+      return {
+        type: args.resourceType,
+        id: args.resourceId,
+        ownerEmail: routed.ownerEmail,
+        orgId: routed.orgId,
+        visibility: routed.visibility,
+      };
+    },
+    summary: (args) => `Sent review thread ${args.threadId} to the agent`,
+  },
+});

package/corpus/core/src/review/identity.ts

@@ -0,0 +1,101 @@
+import type {
+  ReviewComment,
+  ReviewResourceAccess,
+  ReviewResourceContext,
+  ReviewStatusEntry,
+} from "./types.js";
+
+export function reviewAuthorNameFromContext(
+  ctx: ReviewResourceContext | undefined,
+): string | null {
+  const value = ctx?.userName;
+  if (typeof value !== "string") return null;
+  const name = value.trim();
+  if (!name || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(name)) return null;
+  return name;
+}
+
+export function shouldRedactReviewIdentity(
+  ctx: ReviewResourceContext | undefined,
+  access: Pick<ReviewResourceAccess, "role" | "visibility">,
+): boolean {
+  return (
+    !ctx?.userEmail ||
+    (access.visibility === "public" && access.role === "viewer")
+  );
+}
+
+export function redactPublicReviewCommentIdentity(
+  comment: ReviewComment,
+): ReviewComment {
+  return {
+    ...comment,
+    authorEmail: null,
+    authorName: safeReviewDisplayName(comment.authorName),
+    mentions: comment.mentions.map((mention) => ({
+      label: safeReviewDisplayName(mention.label) ?? "Mentioned user",
+    })),
+    ownerEmail: null,
+    orgId: null,
+    resolvedBy: null,
+    deletedBy: null,
+    metadata: redactPublicReviewMetadata(comment.metadata),
+  };
+}
+
+export function redactPublicReviewStatusIdentity(
+  status: ReviewStatusEntry | null,
+): ReviewStatusEntry | null {
+  return status
+    ? {
+        ...status,
+        updatedBy: null,
+        ownerEmail: null,
+        orgId: null,
+        metadata: redactPublicReviewMetadata(status.metadata),
+      }
+    : null;
+}
+
+function safeReviewDisplayName(
+  value: string | null | undefined,
+): string | null {
+  const name = value?.trim();
+  if (!name || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(name)) {
+    return null;
+  }
+  return name;
+}
+
+function redactPublicReviewMetadata(
+  metadata: Record<string, unknown> | null,
+): Record<string, unknown> | null {
+  if (!metadata) {
+    return null;
+  }
+  return Object.fromEntries(
+    Object.entries(metadata).flatMap(([key, value]) =>
+      /^(authorEmail|ownerEmail|orgId|updatedBy|resolvedBy|deletedBy|email|userEmail|userId)$/i.test(
+        key,
+      )
+        ? []
+        : [[key, redactPublicReviewMetadataValue(value)]],
+    ),
+  );
+}
+
+function redactPublicReviewMetadataValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(redactPublicReviewMetadataValue);
+  }
+  if (typeof value === "object" && value !== null) {
+    return redactPublicReviewMetadata(value as Record<string, unknown>);
+  }
+  if (
+    typeof value === "string" &&
+    /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim())
+  ) {
+    return null;
+  }
+  return value;
+}

package/corpus/core/src/review/index.ts

@@ -13,6 +13,12 @@ export type {
   ReviewStatusEntry,
   ReviewableResourceRegistration,
 } from "./types.js";
+export {
+  redactPublicReviewCommentIdentity,
+  redactPublicReviewStatusIdentity,
+  reviewAuthorNameFromContext,
+  shouldRedactReviewIdentity,
+} from "./identity.js";
 export { extractReviewMentions, normalizeReviewMentions } from "./mentions.js";
 export {
   __resetReviewableResourcesForTests,
@@ -27,5 +33,13 @@ export {
   ensureReviewTables,
   getReviewCommentById,
   getReviewStatus,
+  getReviewThreadSummary,
+  getReviewThreadRoot,
   queryReviewComments,
+  routeReviewThread,
+  sendReviewThreadToAgent,
+} from "./store.js";
+export type {
+  GetReviewThreadSummaryInput,
+  ReviewThreadSummary,
 } from "./store.js";