@agent-native/core 0.90.2 → 0.90.3

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+
+import { defineAction } from "../../action.js";
+import { assertReviewableResourceAccess } from "../registry.js";
+import { getReviewCommentById, resolveReviewThread } 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().optional(),
+  commentId: z.string().optional(),
+});
+
+export default defineAction({
+  description: "Resolve an inline comment or review thread.",
+  schema,
+  run: async (args, ctx) => {
+    const actionCtx = ctx as ReviewResourceContext | undefined;
+    await assertReviewableResourceAccess(
+      args.resourceType,
+      args.resourceId,
+      actionCtx,
+      "editor",
+    );
+    let threadId = args.threadId;
+    if (!threadId && args.commentId) {
+      const comment = await getReviewCommentById(
+        args.commentId,
+        {
+          userEmail: actionCtx?.userEmail ?? null,
+          orgId: actionCtx?.orgId ?? null,
+        },
+        { bypassScope: true },
+      );
+      if (
+        !comment ||
+        comment.resourceType !== args.resourceType ||
+        comment.resourceId !== args.resourceId
+      ) {
+        throw new Error("Review comment not found");
+      }
+      threadId = comment.threadId;
+    }
+    if (!threadId) {
+      throw new Error("Provide threadId or commentId");
+    }
+    await resolveReviewThread(threadId, actionCtx?.userEmail ?? null, {
+      resourceType: args.resourceType,
+      resourceId: args.resourceId,
+    });
+    return { threadId, resolved: true };
+  },
+  audit: {
+    target: (args) => ({
+      type: args.resourceType,
+      id: args.resourceId,
+    }),
+  },
+});

package/corpus/core/src/review/actions/set-review-status.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+
+import { defineAction } from "../../action.js";
+import {
+  assertReviewableResourceAccess,
+  normalizeReviewVisibility,
+} from "../registry.js";
+import { upsertReviewStatus } from "../store.js";
+import type { ReviewResourceContext } from "../types.js";
+
+const schema = z.object({
+  resourceType: z.string().min(1),
+  resourceId: z.string().min(1),
+  status: z.enum(["draft", "in_review", "approved", "changes_requested"]),
+  note: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export default defineAction({
+  description: "Set the review status for a reusable resource.",
+  schema,
+  run: async (args, ctx) => {
+    const actionCtx = ctx as ReviewResourceContext | undefined;
+    const access = await assertReviewableResourceAccess(
+      args.resourceType,
+      args.resourceId,
+      actionCtx,
+      "editor",
+    );
+    return upsertReviewStatus({
+      resourceType: args.resourceType,
+      resourceId: args.resourceId,
+      status: args.status,
+      note: args.note,
+      updatedBy: actionCtx?.userEmail ?? null,
+      ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
+      orgId: access.orgId ?? actionCtx?.orgId ?? null,
+      visibility: normalizeReviewVisibility(access.visibility),
+      metadata: args.metadata,
+    });
+  },
+  audit: {
+    target: (args, result) => {
+      const status = result as {
+        ownerEmail?: string | null;
+        orgId?: string | null;
+        visibility?: "private" | "org" | "public";
+      };
+      return {
+        type: args.resourceType,
+        id: args.resourceId,
+        ownerEmail: status.ownerEmail,
+        orgId: status.orgId,
+        visibility: status.visibility,
+      };
+    },
+  },
+});

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

@@ -0,0 +1,36 @@
+export type {
+  ReviewActorKind,
+  ReviewComment,
+  ReviewCommentKind,
+  ReviewCommentStatus,
+  ReviewMention,
+  ReviewResolutionTarget,
+  ReviewResourceAccess,
+  ReviewResourceContext,
+  ReviewResourceRole,
+  ReviewScope,
+  ReviewStatus,
+  ReviewStatusEntry,
+  ReviewableResourceRegistration,
+} from "./types.js";
+export { extractReviewMentions, normalizeReviewMentions } from "./mentions.js";
+export {
+  __resetReviewableResourcesForTests,
+  assertReviewableResourceAccess,
+  getReviewableResource,
+  listReviewableResources,
+  registerReviewableResource,
+  resolveReviewableResourceAccess,
+} from "./registry.js";
+export {
+  __resetReviewInitForTests,
+  consumeReviewFeedback,
+  deleteReviewComment,
+  ensureReviewTables,
+  getReviewCommentById,
+  getReviewStatus,
+  insertReviewComment,
+  queryReviewComments,
+  resolveReviewThread,
+  upsertReviewStatus,
+} from "./store.js";

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

@@ -0,0 +1,44 @@
+import type { ReviewMention } from "./types.js";
+
+const MAILTO_MENTION_PATTERN = /@\[([^\]]+)\]\(mailto:([^)]+)\)/g;
+
+export function extractReviewMentions(body: string): ReviewMention[] {
+  const mentions: ReviewMention[] = [];
+  for (const match of body.matchAll(MAILTO_MENTION_PATTERN)) {
+    const label = match[1]?.trim();
+    const email = match[2]?.trim().toLowerCase();
+    if (label && email) {
+      mentions.push({ label, email });
+    }
+  }
+  return normalizeReviewMentions(mentions);
+}
+
+export function normalizeReviewMentions(
+  mentions: ReviewMention[] | null | undefined,
+): ReviewMention[] {
+  if (!mentions?.length) {
+    return [];
+  }
+  const seen = new Set<string>();
+  const normalized: ReviewMention[] = [];
+  for (const mention of mentions) {
+    const label = mention.label?.trim();
+    const email = mention.email?.trim().toLowerCase() || null;
+    const id = mention.id?.trim() || null;
+    if (!label && !email && !id) {
+      continue;
+    }
+    const key = email ?? id ?? label.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    normalized.push({
+      label: label || email || id || "Unknown",
+      email,
+      id,
+    });
+  }
+  return normalized;
+}

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

@@ -0,0 +1,99 @@
+import { ForbiddenError, resolveAccess } from "../sharing/access.js";
+import { getShareableResource } from "../sharing/registry.js";
+import { roleSatisfies, type Visibility } from "../sharing/schema.js";
+import type {
+  ReviewResourceAccess,
+  ReviewResourceContext,
+  ReviewResourceRole,
+  ReviewableResourceRegistration,
+} from "./types.js";
+
+const registrations = new Map<string, ReviewableResourceRegistration>();
+
+export function registerReviewableResource(
+  registration: ReviewableResourceRegistration,
+): void {
+  if (!registration.type.trim()) {
+    throw new Error(
+      "registerReviewableResource requires a non-empty resource type",
+    );
+  }
+  registrations.set(registration.type, registration);
+}
+
+export function getReviewableResource(
+  type: string,
+): ReviewableResourceRegistration | undefined {
+  return registrations.get(type);
+}
+
+export function listReviewableResources(): ReviewableResourceRegistration[] {
+  return Array.from(registrations.values());
+}
+
+export async function resolveReviewableResourceAccess(
+  resourceType: string,
+  resourceId: string,
+  ctx?: ReviewResourceContext,
+): Promise<ReviewResourceAccess | null> {
+  const registration = getReviewableResource(resourceType);
+  if (registration?.resolveAccess) {
+    return registration.resolveAccess(resourceId, ctx);
+  }
+
+  if (getShareableResource(resourceType)) {
+    const access = await resolveAccess(resourceType, resourceId);
+    if (!access) {
+      return null;
+    }
+    return {
+      role: access.role as ReviewResourceRole,
+      ownerEmail: access.resource.ownerEmail ?? null,
+      orgId: access.resource.orgId ?? null,
+      visibility: access.resource.visibility,
+      resource: access.resource,
+    };
+  }
+
+  const userEmail = ctx?.userEmail ?? null;
+  if (!userEmail) {
+    return null;
+  }
+  return {
+    role: "owner",
+    ownerEmail: userEmail,
+    orgId: ctx?.orgId ?? null,
+    visibility: "private",
+  };
+}
+
+export async function assertReviewableResourceAccess(
+  resourceType: string,
+  resourceId: string,
+  ctx: ReviewResourceContext | undefined,
+  minimumRole: ReviewResourceRole,
+): Promise<ReviewResourceAccess> {
+  const access = await resolveReviewableResourceAccess(
+    resourceType,
+    resourceId,
+    ctx,
+  );
+  if (!access || !roleSatisfies(access.role, minimumRole)) {
+    throw new ForbiddenError(
+      `Not allowed to access ${resourceType}:${resourceId}`,
+    );
+  }
+  return access;
+}
+
+export function normalizeReviewVisibility(
+  visibility: Visibility | null | undefined,
+): Visibility {
+  return visibility === "org" || visibility === "public"
+    ? visibility
+    : "private";
+}
+
+export function __resetReviewableResourcesForTests(): void {
+  registrations.clear();
+}