@agent-native/core 0.132.1 → 0.133.0

package/corpus/templates/factory/server/triage/pr-babysit.ts

@@ -0,0 +1,100 @@
+import type { PullRequestCheckObservation } from "./pr-monitor.js";
+
+export interface ReviewCommentObservation {
+  id: string;
+  author: string;
+  inReplyToId: string | null;
+  body: string;
+  path?: string;
+  line?: number;
+  createdAt: string;
+  // Provider thread resolution. `undefined` means the provider could not tell
+  // us — its lookup can fail or page out — so it is unknown, never resolved.
+  isResolved?: boolean;
+}
+
+export interface BabysitInput {
+  comments: readonly ReviewCommentObservation[];
+  checks: readonly PullRequestCheckObservation[];
+  failingJobLog?: string;
+  botAuthors?: readonly string[];
+  commentsTruncated?: boolean;
+}
+
+export interface BabysitProposal {
+  unansweredComments: ReviewCommentObservation[];
+  failingChecks: PullRequestCheckObservation[];
+  missingChangesetPackages: string[];
+  pendingChecks: PullRequestCheckObservation[];
+  commentsTruncated: boolean;
+  isClean: boolean;
+}
+
+const MISSING_CHANGESET_LINE = /^MISSING_CHANGESET_PACKAGES:\s*(.*)$/m;
+
+function parseMissingChangesetPackages(log: string | undefined): string[] {
+  const match = log ? MISSING_CHANGESET_LINE.exec(log) : null;
+  if (!match) return [];
+  return match[1]
+    .split(",")
+    .map((pkg) => pkg.trim())
+    .filter((pkg) => pkg.length > 0);
+}
+
+// Provider resolution wins when the provider knows it. `undefined` falls back
+// to reply state rather than clearing the thread: treating unknown as resolved
+// would silently mark every open thread handled whenever the provider's
+// resolution lookup fails.
+function isAnswered(
+  comment: ReviewCommentObservation,
+  repliedToIds: ReadonlySet<string>,
+): boolean {
+  if (comment.isResolved !== undefined) return comment.isResolved;
+  return repliedToIds.has(comment.id);
+}
+
+export function reconcileBabysitState(input: BabysitInput): BabysitProposal {
+  const botAuthors = new Set(input.botAuthors ?? []);
+  // Reply state, not a timestamp: a comment with any reply anywhere in the
+  // set is answered, regardless of when it was posted relative to a prior
+  // check. Filtering by "since" would re-hide an earlier unanswered round.
+  const repliedToIds = new Set(
+    input.comments
+      .map((comment) => comment.inReplyToId)
+      .filter((id): id is string => id !== null),
+  );
+
+  const unansweredComments = input.comments.filter(
+    (comment) =>
+      comment.inReplyToId === null &&
+      !isAnswered(comment, repliedToIds) &&
+      !botAuthors.has(comment.author),
+  );
+  const failingChecks = input.checks.filter(
+    (check) => check.state === "failed",
+  );
+  const pendingChecks = input.checks.filter(
+    (check) => check.state === "queued" || check.state === "in_progress",
+  );
+  const missingChangesetPackages = parseMissingChangesetPackages(
+    input.failingJobLog,
+  );
+
+  // A capped comment page hides unanswered threads beyond it, which reads as
+  // clean — the same false all-clear a "since" filter produces.
+  const commentsTruncated = input.commentsTruncated === true;
+
+  return {
+    unansweredComments,
+    failingChecks,
+    missingChangesetPackages,
+    pendingChecks,
+    commentsTruncated,
+    isClean:
+      !commentsTruncated &&
+      unansweredComments.length === 0 &&
+      failingChecks.length === 0 &&
+      missingChangesetPackages.length === 0 &&
+      pendingChecks.length === 0,
+  };
+}

package/corpus/templates/factory/server/triage/pr-monitor.ts

@@ -0,0 +1,220 @@
+import type { ExecutorState, TriageItemStatus } from "./contracts.js";
+
+export type PullRequestReviewState =
+  | "approved"
+  | "changes_requested"
+  | "commented"
+  | "pending";
+
+export interface PullRequestReviewObservation {
+  author: string;
+  state: PullRequestReviewState;
+  observedAt: string;
+}
+
+export type PullRequestCheckState =
+  | "queued"
+  | "in_progress"
+  | "passed"
+  | "failed"
+  | "cancelled";
+
+export interface PullRequestCheckObservation {
+  name: string;
+  state: PullRequestCheckState;
+  observedAt: string;
+}
+
+export interface PullRequestObservation {
+  readonly repo: string;
+  readonly pullRequestNumber: number;
+  readonly headSha: string;
+  readonly reviews: readonly PullRequestReviewObservation[];
+  readonly checks: readonly PullRequestCheckObservation[];
+  readonly observedAt: string;
+}
+
+export interface PullRequestMonitorCallback {
+  state: ExecutorState;
+  observedAt: string;
+  terminalReason?: string;
+}
+
+export interface PullRequestMonitorInput {
+  triageItemId: string;
+  runId: string;
+  callback?: PullRequestMonitorCallback;
+  providerObservation?: PullRequestObservation;
+  heartbeatAt?: string;
+  now: string;
+  timeoutMs: number;
+}
+
+export type PullRequestMonitorTerminalState = Extract<
+  ExecutorState,
+  "completed" | "failed" | "cancelled" | "timed_out" | "reconciliation_required"
+>;
+
+export interface TriageItemPatch {
+  repository: string;
+  pullRequestNumber: number;
+  headSha: string;
+  coverage: "complete" | "partial" | "unknown" | "unavailable";
+  status: TriageItemStatus;
+  metadataJson: string;
+  lastSeenAt: string;
+  updatedAt: string;
+}
+
+export interface PullRequestMonitorResult {
+  triageItemId: string;
+  runId: string;
+  state: ExecutorState;
+  terminalState: PullRequestMonitorTerminalState | null;
+  triageItemPatch: TriageItemPatch | null;
+  reason: string;
+}
+
+function isTerminalCheck(
+  check: PullRequestCheckObservation,
+): check is PullRequestCheckObservation & {
+  state: "passed" | "failed" | "cancelled";
+} {
+  return (
+    check.state === "passed" ||
+    check.state === "failed" ||
+    check.state === "cancelled"
+  );
+}
+
+function getProviderTerminalState(
+  observation: PullRequestObservation,
+): Exclude<
+  PullRequestMonitorTerminalState,
+  "timed_out" | "reconciliation_required"
+> | null {
+  if (
+    observation.checks.length === 0 ||
+    !observation.checks.every(isTerminalCheck)
+  ) {
+    return null;
+  }
+  if (observation.checks.some((check) => check.state === "failed")) {
+    return "failed";
+  }
+  if (observation.checks.some((check) => check.state === "cancelled")) {
+    return "cancelled";
+  }
+  return "completed";
+}
+
+function isTimedOut(input: PullRequestMonitorInput): boolean {
+  if (input.timeoutMs < 0 || !input.heartbeatAt) {
+    return false;
+  }
+  const heartbeatAge = Date.parse(input.now) - Date.parse(input.heartbeatAt);
+  return Number.isFinite(heartbeatAge) && heartbeatAge >= input.timeoutMs;
+}
+
+function buildPatch(
+  observation: PullRequestObservation,
+  state: ExecutorState,
+  now: string,
+): TriageItemPatch {
+  return {
+    repository: observation.repo,
+    pullRequestNumber: observation.pullRequestNumber,
+    headSha: observation.headSha,
+    coverage: "complete",
+    status:
+      state === "reconciliation_required"
+        ? "reconciliation_required"
+        : state === "failed" || state === "cancelled" || state === "timed_out"
+          ? "failed"
+          : "evidence_ready",
+    metadataJson: JSON.stringify({
+      checks: observation.checks,
+      reviews: observation.reviews,
+      monitorState: state,
+    }),
+    lastSeenAt: observation.observedAt,
+    updatedAt: now,
+  };
+}
+
+export function reconcilePullRequestRun(
+  input: PullRequestMonitorInput,
+): PullRequestMonitorResult {
+  const providerState = input.providerObservation
+    ? getProviderTerminalState(input.providerObservation)
+    : null;
+  const callback = input.callback;
+  const timedOut = isTimedOut(input);
+  let state: ExecutorState;
+  let reason: string;
+
+  if (timedOut && !providerState) {
+    state = "timed_out";
+    reason =
+      "The run heartbeat exceeded its timeout without a terminal provider observation.";
+  } else if (providerState) {
+    state = providerState;
+    reason = "The provider observation supplies a terminal result for the run.";
+  } else if (callback?.state === "completed") {
+    state = "reconciliation_required";
+    reason =
+      "The callback claims completion, but no terminal provider observation was observed.";
+  } else if (
+    callback?.state === "failed" ||
+    callback?.state === "cancelled" ||
+    callback?.state === "timed_out" ||
+    callback?.state === "reconciliation_required"
+  ) {
+    state = callback.state;
+    reason =
+      callback.terminalReason ?? "The callback supplied a terminal run state.";
+  } else if (callback) {
+    state = callback.state;
+    reason =
+      input.providerObservation && !providerState
+        ? "The provider observation is not terminal; continue monitoring the run."
+        : "The run has a non-terminal callback and remains in progress.";
+  } else if (!input.providerObservation) {
+    state = "reconciliation_required";
+    reason =
+      "No callback or provider observation was available to reconcile the run.";
+  } else {
+    state = "reconciliation_required";
+    reason =
+      "The callback was missed and the provider observation is not terminal.";
+  }
+
+  return {
+    triageItemId: input.triageItemId,
+    runId: input.runId,
+    state,
+    terminalState:
+      state === "submitted" || state === "acknowledged" || state === "running"
+        ? null
+        : state,
+    triageItemPatch: input.providerObservation
+      ? buildPatch(input.providerObservation, state, input.now)
+      : null,
+    reason,
+  };
+}
+
+export function dedupePullRequestMonitorResults(
+  results: readonly PullRequestMonitorResult[],
+): PullRequestMonitorResult[] {
+  const seen = new Set<string>();
+  const deduped: PullRequestMonitorResult[] = [];
+  for (const result of results) {
+    const key = result.triageItemId;
+    if (!seen.has(key)) {
+      seen.add(key);
+      deduped.push(result);
+    }
+  }
+  return deduped;
+}

package/corpus/templates/factory/server/triage/slack-client.ts

@@ -0,0 +1,55 @@
+import { resolveConnectorSecret } from "../connectors/credentials.js";
+import {
+  getChannelHistory as readChannelHistory,
+  getTeamInfo as readTeamInfo,
+  type ChannelHistoryResult,
+  type SlackTeamInfo,
+  type SlackTokenResolver,
+  type Workspace,
+} from "../connectors/slack.js";
+
+export interface SlackReaderIdentity {
+  ownerEmail: string;
+  orgId?: string | null;
+}
+
+function createTokenResolver({
+  ownerEmail,
+  orgId,
+}: SlackReaderIdentity): SlackTokenResolver {
+  return async (workspace) => {
+    const key =
+      workspace === "secondary" ? "SLACK_BOT_TOKEN_2" : "SLACK_BOT_TOKEN";
+    const token = await resolveConnectorSecret(key, ownerEmail, { orgId });
+    if (!token) {
+      throw new Error(
+        `No Slack bot token configured. Connect Slack in Settings → Messaging, or set ${key}.`,
+      );
+    }
+    return token;
+  };
+}
+
+export function createSlackReader(identity: SlackReaderIdentity) {
+  const tokenResolver = createTokenResolver(identity);
+
+  return {
+    getChannelHistory(
+      workspace: Workspace,
+      channelId: string,
+      limit?: number,
+      cursor?: string,
+    ): Promise<ChannelHistoryResult> {
+      return readChannelHistory(
+        workspace,
+        channelId,
+        limit,
+        cursor,
+        tokenResolver,
+      );
+    },
+    getTeamInfo(workspace: Workspace): Promise<SlackTeamInfo> {
+      return readTeamInfo(workspace, tokenResolver);
+    },
+  };
+}

package/corpus/templates/factory/server/triage/slack-poller.ts

@@ -0,0 +1,152 @@
+import type { SlackMessage, Workspace } from "../connectors/slack.js";
+import type { IngestionEnvelope } from "./contracts";
+import { createSlackReader } from "./slack-client";
+
+const SLACK_HISTORY_LIMIT = 100;
+const MAX_HISTORY_PAGES = 5;
+const MAX_SUMMARY_LENGTH = 500;
+
+export interface SlackPollInput {
+  workspace: Workspace;
+  channelId: string;
+  priorLastSlackTs: string;
+  historyCursor?: string | null;
+  ownerEmail: string;
+  orgId?: string | null;
+}
+
+export interface SlackPollResult {
+  envelopes: IngestionEnvelope[];
+  nextLastSlackTs: string;
+  nextHistoryCursor: string | null;
+  hasMore: boolean;
+}
+
+function numericTs(ts: string): number {
+  const value = Number(ts);
+  if (!Number.isFinite(value)) {
+    throw new Error(`Slack message has an invalid timestamp: ${ts}`);
+  }
+  return value;
+}
+
+function compactText(text: string): string {
+  const compact = text.replace(/\s+/g, " ").trim();
+  return compact.length > MAX_SUMMARY_LENGTH
+    ? `${compact.slice(0, MAX_SUMMARY_LENGTH - 1)}…`
+    : compact;
+}
+
+function messageLabel(message: SlackMessage): string {
+  if (message.bot_id || message.username) {
+    return `Slack bot ${message.username ?? message.bot_id ?? "unknown"}`;
+  }
+  return `Slack user ${message.user ?? "unknown"}`;
+}
+
+function toEnvelope(
+  channelId: string,
+  message: SlackMessage,
+  teamDomain?: string,
+): IngestionEnvelope {
+  const threadTs = message.thread_ts ?? message.ts;
+  const suppliedPermalink = (message as SlackMessage & { permalink?: string })
+    .permalink;
+  const sourceUrl =
+    suppliedPermalink ??
+    (teamDomain
+      ? `https://${teamDomain}.slack.com/archives/${channelId}/p${message.ts.replace(".", "")}${threadTs !== message.ts ? `?thread_ts=${threadTs}` : ""}`
+      : undefined);
+
+  return {
+    source: "slack",
+    externalId: `${channelId}:${message.ts}`,
+    receivedAt: new Date().toISOString(),
+    ...(sourceUrl ? { sourceUrl } : {}),
+    title: messageLabel(message),
+    summary: compactText(message.text),
+    channelId,
+    threadTs,
+    coverage:
+      message.reply_count && message.reply_count > 0 ? "partial" : "complete",
+  };
+}
+
+export async function pollSlackChannel({
+  workspace,
+  channelId,
+  priorLastSlackTs,
+  historyCursor,
+  ownerEmail,
+  orgId,
+}: SlackPollInput): Promise<SlackPollResult> {
+  const slack = createSlackReader({ ownerEmail, orgId });
+  const priorTs = numericTs(priorLastSlackTs);
+  const messages: SlackMessage[] = [];
+  let cursor = historyCursor ?? undefined;
+  let nextHistoryCursor: string | null = null;
+  let hasMore = false;
+
+  for (let page = 0; page < MAX_HISTORY_PAGES; page += 1) {
+    const history = cursor
+      ? await slack.getChannelHistory(
+          workspace,
+          channelId,
+          SLACK_HISTORY_LIMIT,
+          cursor,
+        )
+      : await slack.getChannelHistory(
+          workspace,
+          channelId,
+          SLACK_HISTORY_LIMIT,
+        );
+    messages.push(...history.messages);
+
+    const reachedPriorMessage = history.messages.some(
+      (message) => numericTs(message.ts) <= priorTs,
+    );
+    if (!history.has_more || reachedPriorMessage || !history.next_cursor) {
+      nextHistoryCursor = null;
+      hasMore = false;
+      break;
+    }
+
+    nextHistoryCursor = history.next_cursor;
+    hasMore = page === MAX_HISTORY_PAGES - 1;
+    if (hasMore) break;
+    cursor = history.next_cursor;
+  }
+
+  let teamDomain: string | undefined;
+  try {
+    const team = await slack.getTeamInfo(workspace);
+    teamDomain = team.domain
+      .replace(/^https?:\/\//, "")
+      .replace(/\.slack\.com\/?$/, "")
+      .replace(/\/$/, "");
+    // coercion-ok: workspace metadata is optional; fetched channel history remains valid without it.
+  } catch {
+    // History remains useful when Slack does not expose workspace metadata.
+  }
+
+  const newMessages = messages
+    .map((message) => ({ message, ts: numericTs(message.ts) }))
+    .filter(({ ts }) => ts > priorTs)
+    .sort((a, b) => a.ts - b.ts);
+  const maxSeen = messages.reduce(
+    (max, message) => {
+      const ts = numericTs(message.ts);
+      return ts > max.value ? { value: ts, raw: message.ts } : max;
+    },
+    { value: priorTs, raw: priorLastSlackTs },
+  );
+
+  return {
+    envelopes: newMessages.map(({ message }) =>
+      toEnvelope(channelId, message, teamDomain),
+    ),
+    nextLastSlackTs: maxSeen.raw,
+    nextHistoryCursor,
+    hasMore,
+  };
+}

package/corpus/templates/factory/ssr-entry.ts

@@ -0,0 +1,15 @@
+/**
+ * SSR entry point for Nitro.
+ * Wraps React Router's request handler so Nitro can use it as a service.
+ */
+import { createRequestHandler } from "react-router";
+
+const handler = createRequestHandler(
+  () => import("virtual:react-router/server-build"),
+);
+
+export default {
+  async fetch(request: Request) {
+    return handler(request);
+  },
+};

package/corpus/templates/factory/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "@agent-native/core/tsconfig.base.json",
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "rootDirs": [".", "./.react-router/types"],
+    "paths": {
+      "*": ["./*"],
+      "@/*": ["./app/*"],
+      "@shared/*": ["./shared/*"]
+    }
+  },
+  "include": [
+    "app/**/*",
+    "server/**/*",
+    "shared/**/*",
+    "vite.config.ts",
+    "react-router.config.ts",
+    ".react-router/types/**/*",
+    ".generated/**/*"
+  ]
+}

package/corpus/templates/factory/vite.config.ts

@@ -0,0 +1,19 @@
+import { agentNative } from "@agent-native/core/vite";
+import { reactRouter } from "@react-router/dev/vite";
+import { defineConfig } from "vite";
+
+const reactRouterPlugins = reactRouter as unknown as () => any[];
+const agentNativePlugins = agentNative as unknown as (
+  options?: Parameters<typeof agentNative>[0],
+) => any[];
+
+export default defineConfig({
+  plugins: [
+    ...reactRouterPlugins(),
+    ...agentNativePlugins({
+      // shiki only runs in AssistantChat's useEffect — keep it out of the
+      // CF Pages Functions bundle (25 MiB limit).
+      ssrStubs: ["shiki"],
+    }),
+  ],
+});

package/corpus/templates/forms/app/components/layout/Sidebar.tsx

@@ -180,6 +180,14 @@ export function Sidebar() {
     navigateWithAgentChatViewTransition(navigate, "/ask");
   }
 
+  function handleBrandClick() {
+    if (isMobile) {
+      toggleLogoView();
+      return;
+    }
+    setCollapsed((value) => !value);
+  }
+
   const newFormButton = (
     <PopoverTrigger asChild>
       <button className="forms-sidebar-nav-item flex min-h-[44px] w-full cursor-pointer items-center gap-2.5 rounded-lg px-3 py-2 text-sm text-muted-foreground active:scale-[0.96] transition-[background-color,box-shadow,color,transform] hover:bg-accent/50 hover:text-foreground">
@@ -250,6 +258,37 @@ export function Sidebar() {
   const sidebarContent = effectiveCollapsed ? (
     <div className="agent-layout-left-drawer flex h-screen w-12 min-w-0 shrink-0 flex-col items-center overflow-hidden border-e border-border bg-sidebar py-2 transition-[width] duration-200 ease-out">
       <TooltipProvider delayDuration={0}>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              type="button"
+              onClick={handleBrandClick}
+              aria-label={t("sidebar.expandSidebar")}
+              className="flex size-8 shrink-0 items-center justify-center rounded-lg outline-none transition-[background-color,box-shadow,transform] hover:bg-accent/50 focus-visible:ring-2 focus-visible:ring-ring"
+              data-sidebar-brand-toggle
+            >
+              <img
+                src={appPath("/agent-native-icon-light.svg")}
+                alt=""
+                aria-hidden="true"
+                width={28}
+                height={16}
+                className="block h-4 w-7 shrink-0 object-contain object-center dark:hidden"
+              />
+              <img
+                src={appPath("/agent-native-icon-dark.svg")}
+                alt=""
+                aria-hidden="true"
+                width={28}
+                height={16}
+                className="hidden h-4 w-7 shrink-0 object-contain object-center dark:block"
+              />
+            </button>
+          </TooltipTrigger>
+          <TooltipContent side="right">
+            {t("sidebar.expandSidebar")}
+          </TooltipContent>
+        </Tooltip>
         <nav className="mt-1 flex min-h-0 flex-1 flex-col items-center gap-1 overflow-y-auto">
           <Tooltip>
             <TooltipTrigger asChild>
@@ -356,27 +395,38 @@ export function Sidebar() {
             <TooltipTrigger asChild>
               <button
                 type="button"
-                aria-label={t("sidebar.openAskFullScreen")}
+                aria-label={
+                  isMobile
+                    ? t("sidebar.openAskFullScreen")
+                    : t("sidebar.collapseSidebar")
+                }
                 className="flex min-h-10 min-w-0 items-center gap-2 rounded-lg px-2 text-base font-semibold tracking-tight text-muted-foreground/80 active:scale-[0.96] transition-[color,transform] hover:text-foreground/80 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-                onClick={toggleLogoView}
+                onClick={handleBrandClick}
+                data-sidebar-brand-toggle
               >
                 <img
                   src={appPath("/agent-native-icon-light.svg")}
                   alt=""
                   aria-hidden="true"
-                  className="block h-4 w-auto shrink-0 dark:hidden"
+                  width={28}
+                  height={16}
+                  className="block h-4 w-7 shrink-0 object-contain object-center dark:hidden"
                 />
                 <img
                   src={appPath("/agent-native-icon-dark.svg")}
                   alt=""
                   aria-hidden="true"
-                  className="hidden h-4 w-auto shrink-0 dark:block"
+                  width={28}
+                  height={16}
+                  className="hidden h-4 w-7 shrink-0 object-contain object-center dark:block"
                 />
                 <span className="truncate">{t("navigation.brand")}</span>
               </button>
             </TooltipTrigger>
             <TooltipContent side="right">
-              {t("sidebar.openAskFullScreen")}
+              {isMobile
+                ? t("sidebar.openAskFullScreen")
+                : t("sidebar.collapseSidebar")}
             </TooltipContent>
           </Tooltip>
         </TooltipProvider>

package/corpus/templates/forms/changelog/2026-07-31-the-agent-native-logo-stays-visible-when-the-sidebar-is-coll.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-31
+---
+
+The Agent Native logo stays visible when the sidebar is collapsed and toggles the sidebar when clicked.