@agent-native/core 0.176.1 → 0.176.2-nightly-20260831184159

package/corpus/templates/factory/app/components/factory/SlackMrkdwn.tsx

@@ -0,0 +1,100 @@
+import { safeHttpUrl } from "../../lib/safe-http-url";
+import {
+  parseSlackMrkdwn,
+  type SlackMrkdwnNode,
+  type SlackMrkdwnOptions,
+} from "./slack-mrkdwn";
+
+export function SlackMrkdwn({
+  text,
+  inline = false,
+  mentionLabels,
+  builderSlackUserId,
+}: {
+  text: string;
+  inline?: boolean;
+  mentionLabels?: Record<string, string>;
+  builderSlackUserId?: string | null;
+}) {
+  const options: SlackMrkdwnOptions = { mentionLabels, builderSlackUserId };
+  const nodes = parseSlackMrkdwn(text, options);
+  const className = inline
+    ? "whitespace-nowrap text-inherit"
+    : "whitespace-pre-wrap break-words text-sm leading-6";
+  const Tag = inline ? "span" : "div";
+  return (
+    <Tag className={className}>
+      {nodes.map((node, index) => (
+        <SlackMrkdwnPart
+          key={`${node.type}-${index}`}
+          node={node}
+          inline={inline}
+        />
+      ))}
+    </Tag>
+  );
+}
+
+function SlackMrkdwnPart({
+  node,
+  inline,
+}: {
+  node: SlackMrkdwnNode;
+  inline: boolean;
+}) {
+  switch (node.type) {
+    case "text":
+      return node.value;
+    case "emoji":
+      return (
+        <span aria-label={node.shortcode} role="img">
+          {node.value}
+        </span>
+      );
+    case "code":
+      return (
+        <code className="rounded bg-muted px-1 py-0.5 font-mono text-[0.85em]">
+          {node.value}
+        </code>
+      );
+    case "codeblock":
+      if (inline) {
+        return (
+          <code className="rounded bg-muted px-1 py-0.5 font-mono text-[0.85em]">
+            {node.value}
+          </code>
+        );
+      }
+      return (
+        <pre className="my-2 overflow-x-auto rounded-md bg-muted p-3 font-mono text-xs leading-5">
+          {node.value}
+        </pre>
+      );
+    case "bold":
+      return <strong className="font-semibold">{node.value}</strong>;
+    case "italic":
+      return <em>{node.value}</em>;
+    case "strike":
+      return <s className="text-muted-foreground">{node.value}</s>;
+    case "link": {
+      const href = safeHttpUrl(node.href);
+      if (!href) return node.label;
+      return (
+        <a
+          href={href}
+          target="_blank"
+          rel="noreferrer"
+          className="text-primary underline-offset-2 hover:underline"
+        >
+          {node.label}
+        </a>
+      );
+    }
+    case "mention":
+      return (
+        <span className="rounded bg-primary/10 px-1 font-medium text-primary">
+          {node.value}
+        </span>
+      );
+  }
+}

package/corpus/templates/factory/app/components/factory/audit-filters.ts

@@ -0,0 +1,30 @@
+import {
+  INBOX_RANGES,
+  type InboxRange,
+  parseInboxRange,
+  updatedAfterForRange,
+} from "@/components/factory/inbox-filters";
+
+export const AUDIT_RANGES = INBOX_RANGES;
+export type AuditRange = InboxRange;
+
+export function parseAuditRange(value: string | null): AuditRange | "" {
+  return parseInboxRange(value);
+}
+
+export function startedAfterForAuditRange(
+  range: AuditRange | "",
+): string | undefined {
+  return updatedAfterForRange(range);
+}
+
+export function writeAuditFilterParam(
+  params: URLSearchParams,
+  key: "automation" | "range",
+  value: string,
+): URLSearchParams {
+  const next = new URLSearchParams(params);
+  if (!value) next.delete(key);
+  else next.set(key, value);
+  return next;
+}

package/corpus/templates/factory/app/components/factory/factory-automation-form.ts

@@ -0,0 +1,120 @@
+export type AutomationSource = "slack" | "github" | "sentry";
+export type AutomationAuthorFilter = "none" | "include" | "exclude";
+export type AutomationAuthorMode = "include" | "exclude";
+export type AutomationScheduleMode = "interval" | "daily";
+export type AutomationTemplateId =
+  | "blank"
+  | "slack-feedback"
+  | "github-issues"
+  | "pr-governance"
+  | "pr-babysit"
+  | "sentry-errors";
+
+export const INTERVAL_MINUTES = [5, 10, 15, 30, 60] as const;
+
+export type FactoryAutomationFormState = {
+  displayName: string;
+  source: AutomationSource | null;
+  template: AutomationTemplateId;
+  slackWorkspace: "primary" | "secondary";
+  slackChannelId: string;
+  slackChannelName: string;
+  repository: string;
+  sentryOrgSlug: string;
+  sentryProjectSlug: string;
+  sentryEnvironment: string;
+  authorFilter: AutomationAuthorFilter;
+  authorIds: string[];
+  scheduleMode: AutomationScheduleMode;
+  intervalMinutes: (typeof INTERVAL_MINUTES)[number];
+  dailyTime: string;
+  timezone: string;
+  inboxLimit: number;
+  workLimit: number;
+  prompt: string;
+  enabled: boolean;
+};
+
+export function defaultWorkLimit(source: AutomationSource | null): number {
+  return source === "slack" ? 5 : 3;
+}
+
+export function browserTimezone(): string {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+
+export function emptyAutomationForm(
+  source: AutomationSource | null = null,
+): FactoryAutomationFormState {
+  return {
+    displayName: "",
+    source,
+    template: "blank",
+    slackWorkspace: "primary",
+    slackChannelId: "",
+    slackChannelName: "",
+    repository: "",
+    sentryOrgSlug: "",
+    sentryProjectSlug: "",
+    sentryEnvironment: "",
+    authorFilter: "none",
+    authorIds: [],
+    scheduleMode: "interval",
+    intervalMinutes: 5,
+    dailyTime: "09:00",
+    timezone: browserTimezone(),
+    inboxLimit: 25,
+    workLimit: defaultWorkLimit(source),
+    prompt: "",
+    enabled: false,
+  };
+}
+
+export function formAuthorFilter(
+  mode: AutomationAuthorMode | null | undefined,
+  ids: readonly string[] | undefined,
+): AutomationAuthorFilter {
+  const authorIds = ids ?? [];
+  if (mode === "include" && authorIds.length > 0) return "include";
+  if (mode === "exclude" && authorIds.length > 0) return "exclude";
+  return "none";
+}
+
+export function persistAuthorFilter(
+  filter: AutomationAuthorFilter,
+  ids: readonly string[],
+): { authorMode: AutomationAuthorMode; authorIds: string[] } {
+  if (filter === "include") {
+    return { authorMode: "include", authorIds: [...ids] };
+  }
+  if (filter === "exclude") {
+    return { authorMode: "exclude", authorIds: [...ids] };
+  }
+  return { authorMode: "exclude", authorIds: [] };
+}
+
+export function parseDailyTime(value: string): {
+  dailyHour: number;
+  dailyMinute: number;
+} {
+  const [hour = "9", minute = "0"] = value.split(":");
+  return {
+    dailyHour: Math.min(23, Math.max(0, Number(hour) || 0)),
+    dailyMinute: Math.min(59, Math.max(0, Number(minute) || 0)),
+  };
+}
+
+export function formatDailyTime(hour: number, minute: number): string {
+  return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+}
+
+export function timezoneOptions(): string[] {
+  const supportedValuesOf = (
+    Intl as typeof Intl & {
+      supportedValuesOf?: (key: "timeZone") => string[];
+    }
+  ).supportedValuesOf;
+  const supported = supportedValuesOf ? supportedValuesOf("timeZone") : [];
+  const detected = browserTimezone();
+  return [...new Set([detected, ...supported])];
+}

package/corpus/templates/factory/app/components/factory/inbox-filters.ts

@@ -0,0 +1,84 @@
+export const INBOX_STATUSES = [
+  "received",
+  "context_fetching",
+  "evidence_ready",
+  "classified",
+  "shadow_decided",
+  "needs_manual",
+  "failed",
+  "reconciliation_required",
+  "automation_started",
+  "pr_observed",
+  "auto_approved",
+  "merged",
+] as const;
+
+export const INBOX_RISKS = [
+  "unknown",
+  "low",
+  "medium",
+  "high",
+  "critical",
+] as const;
+
+export const INBOX_SOURCES = [
+  "slack",
+  "github",
+  "github_issue",
+  "sentry",
+] as const;
+
+export const INBOX_RANGES = ["today", "7d"] as const;
+
+export type InboxStatus = (typeof INBOX_STATUSES)[number];
+export type InboxRisk = (typeof INBOX_RISKS)[number];
+export type InboxSource = (typeof INBOX_SOURCES)[number];
+export type InboxRange = (typeof INBOX_RANGES)[number];
+
+export function parseInboxStatus(value: string | null): InboxStatus | "" {
+  return INBOX_STATUSES.includes(value as InboxStatus)
+    ? (value as InboxStatus)
+    : "";
+}
+
+export function parseInboxRisk(value: string | null): InboxRisk | "" {
+  return INBOX_RISKS.includes(value as InboxRisk) ? (value as InboxRisk) : "";
+}
+
+export function parseInboxSource(value: string | null): InboxSource | "" {
+  return INBOX_SOURCES.includes(value as InboxSource)
+    ? (value as InboxSource)
+    : "";
+}
+
+export function parseInboxRange(value: string | null): InboxRange | "" {
+  return INBOX_RANGES.includes(value as InboxRange)
+    ? (value as InboxRange)
+    : "";
+}
+
+export function updatedAfterForRange(
+  range: InboxRange | "",
+): string | undefined {
+  if (!range) return undefined;
+  // Local midnight so the bound is stable across renders. `now - 7d` would
+  // change every millisecond and retrigger list-triage-items via the query key.
+  const now = new Date();
+  const daysAgo = range === "today" ? 0 : 7;
+  return new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate() - daysAgo,
+  ).toISOString();
+}
+
+export function writeInboxFilterParam(
+  params: URLSearchParams,
+  key: "status" | "risk" | "range" | "source",
+  value: string,
+): URLSearchParams {
+  const next = new URLSearchParams(params);
+  if (!value) next.delete(key);
+  else next.set(key, value);
+  return next;
+}

package/corpus/templates/factory/app/components/factory/inbox-source-url.ts

@@ -0,0 +1,23 @@
+import { safeHttpUrl } from "@/lib/safe-http-url";
+
+export function slackThreadUrl(channelId: string, threadTs: string): string {
+  const compactTs = threadTs.replace(".", "");
+  return `https://slack.com/archives/${encodeURIComponent(channelId)}/p${compactTs}?thread_ts=${encodeURIComponent(threadTs)}`;
+}
+
+export function resolveInboxSourceUrl({
+  sourceUrl,
+  channelId,
+  threadTs,
+}: {
+  sourceUrl?: string | null;
+  channelId?: string | null;
+  threadTs?: string | null;
+}): string | null {
+  const stored = safeHttpUrl(sourceUrl);
+  if (stored) return stored;
+  const channel = channelId?.trim();
+  const ts = threadTs?.trim();
+  if (!channel || !ts) return null;
+  return safeHttpUrl(slackThreadUrl(channel, ts));
+}

package/corpus/templates/factory/app/components/factory/slack-emoji.ts

@@ -0,0 +1,165 @@
+/** Standard Slack/Unicode shortcodes. Unknown names stay as `:name:`. */
+const SHORTCODES: Record<string, string> = {
+  "+1": "👍",
+  "-1": "👎",
+  100: "💯",
+  angry: "😠",
+  blush: "😊",
+  boom: "💥",
+  clap: "👏",
+  confused: "😕",
+  cry: "😢",
+  disappointed: "😞",
+  dizzy_face: "😵",
+  eyes: "👀",
+  fire: "🔥",
+  grin: "😁",
+  grinning: "😀",
+  heart: "❤️",
+  heart_eyes: "😍",
+  hug: "🤗",
+  hushed: "😯",
+  joy: "😂",
+  laugh: "😆",
+  laughing: "😆",
+  slightly_smiling_face: "🙂",
+  smile: "😄",
+  smiley: "😃",
+  smirk: "😏",
+  sob: "😭",
+  stuck_out_tongue: "😛",
+  sunglasses: "😎",
+  sweat_smile: "😅",
+  tada: "🎉",
+  thinking_face: "🤔",
+  thumbsdown: "👎",
+  thumbsup: "👍",
+  wave: "👋",
+  wink: "😉",
+  worried: "😟",
+  x: "❌",
+  white_check_mark: "✅",
+  heavy_check_mark: "✔️",
+  warning: "⚠️",
+  question: "❓",
+  exclamation: "❗",
+  star: "⭐",
+  sparkles: "✨",
+  zap: "⚡",
+  rocket: "🚀",
+  snail: "🐌",
+  bug: "🐛",
+  hammer: "🔨",
+  wrench: "🔧",
+  memo: "📝",
+  pencil: "✏️",
+  paperclip: "📎",
+  link: "🔗",
+  lock: "🔒",
+  unlock: "🔓",
+  key: "🔑",
+  mag: "🔍",
+  bulb: "💡",
+  bell: "🔔",
+  hourglass: "⌛",
+  watch: "⌚",
+  alarm_clock: "⏰",
+  calendar: "📅",
+  chart_with_upwards_trend: "📈",
+  chart_with_downwards_trend: "📉",
+  computer: "💻",
+  phone: "☎️",
+  email: "📧",
+  envelope: "✉️",
+  mailbox: "📫",
+  package: "📦",
+  file_folder: "📁",
+  page_facing_up: "📄",
+  newspaper: "📰",
+  books: "📚",
+  book: "📖",
+  camera: "📷",
+  movie_camera: "🎥",
+  art: "🎨",
+  musical_note: "🎵",
+  coffee: "☕",
+  pizza: "🍕",
+  beer: "🍺",
+  cake: "🍰",
+  cookie: "🍪",
+  apple: "🍎",
+  dog: "🐶",
+  cat: "🐱",
+  monkey: "🐵",
+  pig: "🐷",
+  sun: "☀️",
+  moon: "🌙",
+  cloud: "☁️",
+  snowflake: "❄️",
+  umbrella: "☔",
+  rainbow: "🌈",
+  earth_americas: "🌎",
+  praying: "🙏",
+  pray: "🙏",
+  point_up: "☝️",
+  point_down: "👇",
+  point_left: "👈",
+  point_right: "👉",
+  ok_hand: "👌",
+  v: "✌️",
+  fist: "✊",
+  raised_hands: "🙌",
+  muscle: "💪",
+  facepalm: "🤦",
+  shrug: "🤷",
+  handshake: "🤝",
+  crossed_fingers: "🤞",
+  the_horns: "🤘",
+  collision: "💥",
+  sweat: "😓",
+  sleepy: "😪",
+  sleeping: "😴",
+  zzz: "💤",
+  mask: "😷",
+  sneezing_face: "🤧",
+  nerd_face: "🤓",
+  robot_face: "🤖",
+  ghost: "👻",
+  skull: "💀",
+  poop: "💩",
+  hankey: "💩",
+  see_no_evil: "🙈",
+  hear_no_evil: "🙉",
+  speak_no_evil: "🙊",
+  thankyou: "🙏",
+  yes: "✅",
+  no: "❌",
+  ship: "🚢",
+  checkered_flag: "🏁",
+  trophy: "🏆",
+  medal: "🏅",
+  dart: "🎯",
+  pushpin: "📌",
+  round_pushpin: "📍",
+  triangular_flag_on_post: "🚩",
+  speech_balloon: "💬",
+  thought_balloon: "💭",
+  loudspeaker: "📢",
+  mega: "📣",
+  no_entry: "⛔",
+  no_entry_sign: "🚫",
+  information_source: "ℹ️",
+  arrow_right: "➡️",
+  arrow_left: "⬅️",
+  arrow_up: "⬆️",
+  arrow_down: "⬇️",
+  recycle: "♻️",
+  heavy_plus_sign: "➕",
+  heavy_minus_sign: "➖",
+};
+
+export function slackEmojiFor(shortcode: string): string | null {
+  const key = shortcode.trim().toLowerCase().replace(/^:|:$/g, "");
+  if (!key) return null;
+  return SHORTCODES[key] ?? null;
+}

package/corpus/templates/factory/app/components/factory/slack-mrkdwn.ts

@@ -0,0 +1,128 @@
+import { safeHttpUrl } from "../../lib/safe-http-url";
+import { slackEmojiFor } from "./slack-emoji";
+
+export type SlackMrkdwnNode =
+  | { type: "text"; value: string }
+  | { type: "code"; value: string }
+  | { type: "codeblock"; value: string }
+  | { type: "bold"; value: string }
+  | { type: "italic"; value: string }
+  | { type: "strike"; value: string }
+  | { type: "link"; href: string; label: string }
+  | { type: "mention"; id: string; value: string }
+  | { type: "emoji"; value: string; shortcode: string };
+
+export type SlackMrkdwnOptions = {
+  mentionLabels?: Record<string, string>;
+  builderSlackUserId?: string | null;
+};
+
+const FENCE_RE = /```(?:[\w-]*\n)?([\s\S]*?)```/;
+const INLINE_RE =
+  /`([^`]+)`|<((?:https?:\/\/)[^|>]+)(?:\|([^>]+))?>|:([a-z0-9_+-]+):|<@([UW][A-Z0-9]+)(?:\|([^>]+))?>|\*([^*\n]+)\*|_([^_\n]+)_|~([^~\n]+)~/i;
+
+export const BUILDER_SLACK_MENTION_LABEL = "@Builder.io";
+
+export function parseSlackMrkdwn(
+  input: string,
+  options: SlackMrkdwnOptions = {},
+): SlackMrkdwnNode[] {
+  const nodes: SlackMrkdwnNode[] = [];
+  let remaining = input;
+  while (remaining.length > 0) {
+    const fence = remaining.match(FENCE_RE);
+    if (fence && fence.index !== undefined && fence.index >= 0) {
+      if (fence.index > 0) {
+        nodes.push(...parseInline(remaining.slice(0, fence.index), options));
+      }
+      nodes.push({
+        type: "codeblock",
+        value: fence[1]!.replace(/^\n/, "").replace(/\n$/, ""),
+      });
+      remaining = remaining.slice(fence.index + fence[0].length);
+      continue;
+    }
+    nodes.push(...parseInline(remaining, options));
+    break;
+  }
+  return nodes;
+}
+
+export function resolveSlackMentionLabel(
+  userId: string,
+  pipeLabel: string | undefined,
+  options: SlackMrkdwnOptions = {},
+): string {
+  const id = userId.trim();
+  const fromMap = lookupMentionLabel(id, options.mentionLabels);
+  if (fromMap) return formatMentionName(fromMap);
+  const builderId = options.builderSlackUserId?.trim();
+  if (builderId && id.toUpperCase() === builderId.toUpperCase()) {
+    return BUILDER_SLACK_MENTION_LABEL;
+  }
+  if (pipeLabel?.trim()) return formatMentionName(pipeLabel.trim());
+  return `@${id}`;
+}
+
+function parseInline(
+  input: string,
+  options: SlackMrkdwnOptions,
+): SlackMrkdwnNode[] {
+  const nodes: SlackMrkdwnNode[] = [];
+  let remaining = input;
+  while (remaining.length > 0) {
+    const match = remaining.match(INLINE_RE);
+    if (!match || match.index === undefined) {
+      if (remaining) nodes.push({ type: "text", value: remaining });
+      break;
+    }
+    if (match.index > 0) {
+      nodes.push({ type: "text", value: remaining.slice(0, match.index) });
+    }
+    if (match[1] !== undefined) {
+      nodes.push({ type: "code", value: match[1] });
+    } else if (match[2] !== undefined) {
+      const href = safeHttpUrl(match[2]);
+      if (href) {
+        nodes.push({
+          type: "link",
+          href,
+          label: match[3] || href,
+        });
+      } else {
+        nodes.push({ type: "text", value: match[0] });
+      }
+    } else if (match[4] !== undefined) {
+      const shortcode = match[4];
+      const emoji = slackEmojiFor(shortcode);
+      if (emoji) nodes.push({ type: "emoji", value: emoji, shortcode });
+      else nodes.push({ type: "text", value: `:${shortcode}:` });
+    } else if (match[5] !== undefined) {
+      nodes.push({
+        type: "mention",
+        id: match[5],
+        value: resolveSlackMentionLabel(match[5], match[6], options),
+      });
+    } else if (match[7] !== undefined) {
+      nodes.push({ type: "bold", value: match[7] });
+    } else if (match[8] !== undefined) {
+      nodes.push({ type: "italic", value: match[8] });
+    } else if (match[9] !== undefined) {
+      nodes.push({ type: "strike", value: match[9] });
+    }
+    remaining = remaining.slice(match.index + match[0].length);
+  }
+  return nodes;
+}
+
+function lookupMentionLabel(
+  userId: string,
+  labels: Record<string, string> | undefined,
+): string | undefined {
+  if (!labels) return undefined;
+  return labels[userId] ?? labels[userId.toUpperCase()];
+}
+
+function formatMentionName(name: string): string {
+  return name.startsWith("@") ? name : `@${name}`;
+}

package/corpus/templates/factory/app/components/layout/Header.tsx

@@ -10,7 +10,7 @@ import { useLocation } from "react-router";
 import { APP_TITLE } from "@/lib/app-config";
 
 const pageTitleKeys: Record<string, string> = {
-  "/": "navigation.chat",
+  "/home": "navigation.chat",
   "/chat": "navigation.chat",
   "/agents": "navigation.agents",
   "/observability": "navigation.observability",