@agent-native/core-corpus 0.212.1 → 0.214.0

package/corpus/templates/content/app/components/editor/database/github-availability.ts

@@ -0,0 +1,147 @@
+import type { ContentDatabaseSource } from "@shared/api";
+import { GITHUB_SOURCE_TYPE, githubFolderName } from "@shared/github-source";
+
+import { githubRelativeTime } from "./github-source-text";
+import { dbText } from "./text";
+
+/** The collection the Sources panel is about, as GitHub linking needs it. */
+export interface GitHubCollectionPlace {
+  databaseId: string;
+  documentId: string;
+  /** Where a new collection beside this one goes. */
+  spaceId?: string;
+  parentId: string | null;
+  systemRole: string | null;
+  pageCount: number;
+  canEdit: boolean;
+}
+
+export type GitHubBlockedReason =
+  | "files"
+  | "system"
+  | "editors-only"
+  | "other-source"
+  | "has-pages";
+
+/** Whether this collection can take a GitHub folder, and if not, why. */
+export type GitHubAvailability =
+  | { kind: "linked"; source: ContentDatabaseSource }
+  | { kind: "available" }
+  | { kind: "connect" }
+  | {
+      kind: "blocked";
+      reason: GitHubBlockedReason;
+      /** The other app the collection's pages come from. */
+      sourceName?: string;
+    };
+
+/** The app a source's pages come from, as people call it. */
+export function sourceAppName(source: ContentDatabaseSource): string {
+  if (source.sourceType === "builder-cms") return "Builder";
+  if (source.sourceType === "notion-database") return "Notion";
+  return source.sourceName;
+}
+
+/**
+ * Checks the collection before the GitHub connection, so nobody is sent
+ * through GitHub's sign-in for a collection that could never link. The server
+ * checks again when linking, for changes made in between.
+ */
+export function githubAvailability(
+  place: GitHubCollectionPlace,
+  sources: ContentDatabaseSource[],
+  connected: boolean | null | undefined,
+): GitHubAvailability {
+  const linked = sources.find(
+    (source) => source.sourceType === GITHUB_SOURCE_TYPE,
+  );
+  if (linked) return { kind: "linked", source: linked };
+  if (place.systemRole === "files") return { kind: "blocked", reason: "files" };
+  if (place.systemRole) return { kind: "blocked", reason: "system" };
+  if (!place.canEdit) return { kind: "blocked", reason: "editors-only" };
+  const other = sources[0];
+  if (other) {
+    return {
+      kind: "blocked",
+      reason: "other-source",
+      sourceName: sourceAppName(other),
+    };
+  }
+  if (place.pageCount > 0) return { kind: "blocked", reason: "has-pages" };
+  // An unknown connection is left to the dialog, which asks again.
+  return connected === false ? { kind: "connect" } : { kind: "available" };
+}
+
+/** Whether a blocked collection can point to a new one instead. */
+export function githubOffersNewCollection(
+  availability: GitHubAvailability,
+  place: GitHubCollectionPlace,
+): boolean {
+  return (
+    availability.kind === "blocked" &&
+    availability.reason !== "editors-only" &&
+    !!place.spaceId
+  );
+}
+
+/** The line under "GitHub" in Sources, always visible. */
+export function githubRowDescription(
+  availability: GitHubAvailability,
+  now = Date.now(),
+): string {
+  switch (availability.kind) {
+    case "linked": {
+      const status = availability.source.metadata.github;
+      const folder = status
+        ? githubFolderName(status)
+        : availability.source.sourceName;
+      return status?.syncedAt
+        ? dbText("githubRowLinked", {
+            folder,
+            time: githubRelativeTime(status.syncedAt, now),
+          })
+        : dbText("githubRowLinkedNotUpdated", { folder });
+    }
+    case "available":
+      return dbText("githubRowAvailable");
+    case "connect":
+      return dbText("githubRowConnectFirst");
+    case "blocked":
+      switch (availability.reason) {
+        case "files":
+          return dbText("githubRowFiles");
+        case "system":
+          return dbText("githubRowSystem");
+        case "editors-only":
+          return dbText("githubRowEditorsOnly");
+        case "other-source":
+          return dbText("githubRowOtherSource", {
+            source: availability.sourceName ?? "",
+          });
+        case "has-pages":
+          return dbText("githubRowEmptyOnly");
+      }
+  }
+}
+
+/** The full reason a blocked collection can't take a folder. */
+export function githubBlockedExplanation(
+  reason: GitHubBlockedReason,
+  place: GitHubCollectionPlace,
+  sourceName?: string,
+): string {
+  switch (reason) {
+    case "files":
+      return dbText("githubExplainFiles");
+    case "system":
+      return dbText("githubExplainSystem");
+    case "editors-only":
+      return dbText("githubExplainEditorsOnly");
+    case "other-source":
+      return dbText("githubExplainOtherSource", { source: sourceName ?? "" });
+    case "has-pages":
+      return place.pageCount === 1
+        ? dbText("githubExplainHasPagesOne")
+        : dbText("githubExplainHasPages", { count: place.pageCount });
+  }
+}

package/corpus/templates/content/app/components/editor/database/github-source-text.ts

@@ -0,0 +1,280 @@
+import { actionErrorMessage } from "@agent-native/core/client/hooks";
+import {
+  GITHUB_SOURCE_MAX_FILES,
+  parseGitHubFolderUrl,
+  type GitHubLinkBlockedReason,
+  type GitHubSourceProblemCode,
+  type GitHubSourceSkipReason,
+} from "@shared/github-source";
+
+import { dbText, type DatabaseMessageKey } from "./text";
+
+const PROBLEM_KEYS: Record<GitHubSourceProblemCode, DatabaseMessageKey> = {
+  connection: "githubProblemConnection",
+  forbidden: "githubProblemForbidden",
+  repository_not_found: "githubProblemRepositoryNotFound",
+  branch_not_found: "githubProblemBranchNotFound",
+  folder_not_found: "githubProblemFolderNotFound",
+  rate_limited: "githubProblemPaused",
+  too_large: "githubProblemTooLarge",
+  unavailable: "githubProblemPaused",
+  sync_failed: "githubProblemPaused",
+  storage_unavailable: "githubProblemStorageUnavailable",
+};
+
+const SKIP_KEYS: Record<GitHubSourceSkipReason, DatabaseMessageKey> = {
+  mdx: "githubSkipMdx",
+  "too-large": "githubSkipTooLarge",
+  "not-text": "githubSkipNotText",
+};
+
+const BLOCKED_KEYS: Record<GitHubLinkBlockedReason, DatabaseMessageKey> = {
+  "collection-has-rows": "githubLinkBlockedHasRows",
+  "already-linked": "githubLinkBlockedLinked",
+  "system-collection": "githubLinkBlockedSystem",
+};
+
+/** Where a linked folder lives, for problem text that names it. */
+export interface GitHubProblemPlace {
+  branch?: string;
+  path?: string;
+}
+
+/** A linked folder's problem, as the status line and update toasts say it. */
+export function githubProblemText(
+  code: GitHubSourceProblemCode,
+  place: GitHubProblemPlace = {},
+): string {
+  return dbText(PROBLEM_KEYS[code] ?? "githubProblemPaused", {
+    branch: place.branch ?? "",
+    folder: lastSegment(place.path ?? ""),
+    max: GITHUB_SOURCE_MAX_FILES.toLocaleString(pageLocale()),
+  });
+}
+
+/** Problems that mean nothing comes in until someone acts. */
+export function githubProblemStopsUpdates(
+  code: GitHubSourceProblemCode,
+): boolean {
+  return (
+    code === "connection" ||
+    code === "forbidden" ||
+    code === "repository_not_found" ||
+    code === "branch_not_found" ||
+    code === "folder_not_found" ||
+    code === "too_large"
+  );
+}
+
+/**
+ * The problem a `GITHUB_<CODE>` action error stands for, so the dialog can say
+ * it in the reader's language. Null for any other error.
+ */
+export function githubProblemFromErrorCode(
+  errorCode: unknown,
+): GitHubSourceProblemCode | null {
+  if (typeof errorCode !== "string" || !errorCode.startsWith("GITHUB_")) {
+    return null;
+  }
+  const code = errorCode.slice("GITHUB_".length).toLowerCase();
+  return code in PROBLEM_KEYS ? (code as GitHubSourceProblemCode) : null;
+}
+
+/** Whether an action error means GitHub needs connecting first. */
+export function githubErrorNeedsConnection(error: unknown): boolean {
+  const code = (error as { errorCode?: unknown } | null)?.errorCode;
+  // A missing or ungranted connection comes from the shared provider runtime
+  // as `connection_required`; a rejected one, from GitHub.
+  return (
+    code === "connection_required" ||
+    githubProblemFromErrorCode(code) === "connection"
+  );
+}
+
+/** The collection-level reason a link was refused, from its action error. */
+export function githubBlockedFromErrorCode(
+  errorCode: unknown,
+): GitHubLinkBlockedReason | null {
+  if (errorCode === "COLLECTION_NOT_EMPTY") return "collection-has-rows";
+  if (errorCode === "SOURCE_ALREADY_LINKED") return "already-linked";
+  if (errorCode === "COLLECTION_NOT_LINKABLE") return "system-collection";
+  return null;
+}
+
+/**
+ * A link-time error in plain words, naming what the person typed: a typo in
+ * the link reads as a typo, not as something that went missing.
+ */
+export function githubLinkErrorText(error: unknown, url: string): string {
+  const errorCode = (error as { errorCode?: unknown } | null)?.errorCode;
+  const blocked = githubBlockedFromErrorCode(errorCode);
+  if (blocked) return githubBlockedText(blocked);
+  const problem = githubProblemFromErrorCode(errorCode);
+  if (!problem) {
+    return (
+      actionErrorMessage(error) ??
+      (error instanceof Error ? error.message : dbText("githubLinkUnavailable"))
+    );
+  }
+  const parsed = parseGitHubFolderUrl(url);
+  const repo = parsed.ok ? parsed.repo : "";
+  const [branch = "", ...folder] = parsed.ok ? parsed.refPath : [];
+  switch (problem) {
+    case "repository_not_found":
+      return dbText("githubLinkRepositoryNotFound", { repo });
+    case "forbidden":
+      return dbText("githubLinkForbidden", { repo });
+    case "branch_not_found":
+      return dbText("githubLinkBranchNotFound", { branch, repo });
+    case "folder_not_found":
+      return dbText("githubLinkFolderNotFound", {
+        folder: folder.join("/"),
+        repo,
+      });
+    case "too_large":
+      return dbText("githubLinkTooLarge", {
+        max: GITHUB_SOURCE_MAX_FILES.toLocaleString(pageLocale()),
+      });
+    default:
+      return dbText("githubLinkUnavailable");
+  }
+}
+
+/** What's wrong with a link before anything is sent, if anything. */
+export function githubUrlProblem(
+  url: string,
+): { text: string; folderUrl: string | null; folder: string | null } | null {
+  const parsed = parseGitHubFolderUrl(url);
+  if (parsed.ok) return null;
+  if (parsed.reason !== "file") {
+    return {
+      text: dbText("githubLinkInvalidUrl"),
+      folderUrl: null,
+      folder: null,
+    };
+  }
+  const folder = fileLinkFolder(url);
+  return {
+    text: dbText("githubLinkFileUrl"),
+    folderUrl: folder?.url ?? null,
+    folder: folder?.name ?? null,
+  };
+}
+
+/**
+ * The folder a file link points into: `…/blob/main/docs/faq.md` becomes
+ * `…/tree/main/docs`, named "docs", or the repository at its root.
+ */
+export function fileLinkFolder(
+  url: string,
+): { url: string; name: string } | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(
+      /^[a-z][a-z0-9+.-]*:\/\//i.test(url) ? url : `https://${url}`,
+    );
+    // coercion-ok: a link that isn't a URL has no folder to offer; the caller shows the invalid-link text.
+  } catch {
+    return null;
+  }
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  const [owner, repo, kind, ...rest] = segments;
+  if (!owner || !repo || kind !== "blob" || rest.length < 2) return null;
+  const folderSegments = rest.slice(0, -1);
+  const folderUrl = `https://github.com/${owner}/${repo}/tree/${folderSegments.join("/")}`;
+  // The first segment is the branch, so a file at the root names the repository.
+  const name =
+    folderSegments.length > 1
+      ? decodeURIComponent(folderSegments[folderSegments.length - 1]!)
+      : decodeURIComponent(repo);
+  return parseGitHubFolderUrl(folderUrl).ok ? { url: folderUrl, name } : null;
+}
+
+export function githubSkipReasonText(reason: GitHubSourceSkipReason): string {
+  return dbText(SKIP_KEYS[reason] ?? "githubSkipNotText");
+}
+
+export function githubBlockedText(reason: GitHubLinkBlockedReason): string {
+  return dbText(BLOCKED_KEYS[reason] ?? "githubLinkBlockedLinked");
+}
+
+/** The seven-character commit name GitHub shows. */
+export function shortCommit(sha: string): string {
+  return sha.slice(0, 7);
+}
+
+function lastSegment(path: string): string {
+  const trimmed = path.replace(/\/+$/, "");
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+
+/** The page's language, for numbers, dates and lists. */
+export function pageLocale(): string {
+  return typeof document === "undefined" || !document.documentElement.lang
+    ? "en-US"
+    : document.documentElement.lang;
+}
+
+// Not in the TypeScript lib this app targets, though every supported
+// browser has it.
+const ListFormat = (
+  Intl as typeof Intl & {
+    ListFormat?: new (
+      locale: string,
+      options: { style: "long"; type: "conjunction" },
+    ) => { format(items: string[]): string };
+  }
+).ListFormat;
+
+/** "API reference, FAQ and Getting started", in the page's language. */
+export function githubList(items: string[]): string {
+  if (!ListFormat) return items.join(", ");
+  return new ListFormat(pageLocale(), {
+    style: "long",
+    type: "conjunction",
+  }).format(items);
+}
+
+const RELATIVE_UNITS: Array<[Intl.RelativeTimeFormatUnit, number]> = [
+  ["year", 365 * 24 * 60 * 60],
+  ["month", 30 * 24 * 60 * 60],
+  ["week", 7 * 24 * 60 * 60],
+  ["day", 24 * 60 * 60],
+  ["hour", 60 * 60],
+  ["minute", 60],
+];
+
+/** "2 minutes ago", "just now" and the like, in the page's language. */
+export function githubRelativeTime(iso: string, now = Date.now()): string {
+  const at = Date.parse(iso);
+  if (!Number.isFinite(at)) return "";
+  const format = new Intl.RelativeTimeFormat(pageLocale(), {
+    numeric: "auto",
+  });
+  const seconds = Math.round((at - now) / 1000);
+  for (const [unit, size] of RELATIVE_UNITS) {
+    if (Math.abs(seconds) >= size) {
+      return format.format(Math.round(seconds / size), unit);
+    }
+  }
+  return dbText("githubJustNow");
+}
+
+/** A frontmatter example the way a writer reads it: "Yes", "Sep 15, 2026". */
+export function githubExampleText(type: string, example: string): string {
+  if (type === "checkbox") {
+    if (example === "true") return dbText("githubYes");
+    if (example === "false") return dbText("githubNo");
+  }
+  if (type === "date") {
+    const at = Date.parse(example);
+    if (Number.isFinite(at)) {
+      return new Intl.DateTimeFormat(pageLocale(), {
+        dateStyle: "medium",
+        // Frontmatter dates are calendar days, so they mustn't shift by zone.
+        timeZone: /^\d{4}-\d{2}-\d{2}$/.test(example) ? "UTC" : undefined,
+      }).format(at);
+    }
+  }
+  return example;
+}

package/corpus/templates/content/app/components/editor/database/navigation-state.ts

@@ -172,6 +172,7 @@ export function databaseNavigationState({
     | "rowDensity"
     | "openPagesIn"
     | "formQuestions"
+    | "itemLayout"
   >;
   searchQuery?: string;
   sorts?: DatabaseSort[];
@@ -286,6 +287,8 @@ export function databaseNavigationState({
         : undefined,
     databaseFormQuestions:
       activeView.type === "form" ? activeView.formQuestions : undefined,
+    databaseItemLayout:
+      activeView.type === "list" ? (activeView.itemLayout ?? null) : undefined,
     databaseVisibleItemCount: visibleItemCount,
     databaseTotalItemCount: totalItemCount,
     databaseVisibleItems: databaseVisibleItemSummaries(

package/corpus/templates/content/app/components/editor/database/settings.tsx

@@ -2066,7 +2066,7 @@ function SourceDetailsFieldPicker({
                   className={cn(
                     "flex size-4 shrink-0 items-center justify-center rounded border",
                     selected.has(field.id)
-                      ? "border-[#2383e2] bg-[#2383e2] text-white"
+                      ? "border-database-blue bg-database-blue text-database-blue-foreground"
                       : "border-muted-foreground/40 text-transparent",
                   )}
                 >
@@ -2644,7 +2644,7 @@ function DatabaseSettingsSwitch({
       <span
         className={cn(
           "relative h-5 w-9 rounded-full transition-colors",
-          checked ? "bg-[#2383e2]" : "bg-muted-foreground/25",
+          checked ? "bg-database-blue" : "bg-muted-foreground/25",
         )}
       >
         <span
@@ -2683,7 +2683,7 @@ function DatabaseSettingsLayoutPanel({
             className={cn(
               "flex h-16 flex-col items-center justify-center gap-1 rounded-md border text-xs font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
               activeView.type === type
-                ? "border-[#2383e2] bg-[#2383e2]/5 text-[#2383e2]"
+                ? "border-database-blue bg-database-blue/5 text-database-blue"
                 : "border-border text-muted-foreground hover:bg-muted hover:text-foreground",
             )}
             onClick={() => onViewTypeChange(type)}

package/corpus/templates/content/app/components/editor/database/view-config.ts

@@ -3,6 +3,7 @@ import type {
   ContentDatabaseViewConfig,
   ContentDatabaseViewType,
 } from "@shared/api";
+import { contentDatabaseItemLayoutField } from "@shared/database-item-layout";
 
 import {
   type DatabaseColumnCalculation,
@@ -60,6 +61,7 @@ export function createDatabaseView(
     rowDensity: normalizeClientDatabaseRowDensity(values.rowDensity),
     openPagesIn: normalizeClientDatabaseOpenPagesIn(values.openPagesIn),
     formQuestions: normalizeClientDatabaseFormQuestions(values.formQuestions),
+    ...contentDatabaseItemLayoutField(values.itemLayout),
   };
 }
 
@@ -219,6 +221,7 @@ export function duplicateDatabaseView(
       rowDensity: view.rowDensity,
       openPagesIn: view.openPagesIn,
       formQuestions: view.formQuestions,
+      itemLayout: view.itemLayout,
     },
     view.type,
   );
@@ -360,6 +363,7 @@ function normalizeClientDatabaseView(
       rowDensity: normalizeClientDatabaseRowDensity(value.rowDensity),
       openPagesIn: normalizeClientDatabaseOpenPagesIn(value.openPagesIn),
       formQuestions: normalizeClientDatabaseFormQuestions(value.formQuestions),
+      itemLayout: value.itemLayout,
     },
     type,
   );

package/corpus/templates/content/app/components/layout/Layout.tsx

@@ -26,6 +26,7 @@ import {
 import { useLocation, useNavigation } from "react-router";
 import { toast } from "sonner";
 
+import { GitHubLinkDialogHost } from "@/components/editor/database/GitHubLinkDialog";
 import { DocumentEditor } from "@/components/editor/DocumentEditor";
 import { DocumentEditorSkeleton } from "@/components/editor/DocumentEditorSkeleton";
 import { DocumentSidebar } from "@/components/sidebar/DocumentSidebar";
@@ -497,6 +498,7 @@ export function Layout({ children }: LayoutProps) {
           </>
         )}
       </div>
+      <GitHubLinkDialogHost />
     </HeaderActionsProvider>
   );
 }

package/corpus/templates/content/app/global.css

@@ -70,10 +70,20 @@
   --block-bg-purple: #ad46ff19;
   --block-bg-pink: #f6339a19;
   --block-bg-red: #fb2c3619;
+
+  /* Active filter and sort chips in collection views. */
+  --database-chip: #2383e2;
+  --database-chip-foreground: #0f5ea8;
 }
 
 @theme {
   --color-sidebar-muted: hsl(var(--sidebar-muted));
+  /* Checked, selected, and focused controls in collection views, the same in
+     light and dark mode. */
+  --color-database-blue: #2383e2;
+  --color-database-blue-foreground: #fff;
+  --color-database-chip: var(--database-chip);
+  --color-database-chip-foreground: var(--database-chip-foreground);
   /* Comment cards: resting in the margin, floating as a popover, and the
      lifted state for the hovered, focused, or selected thread. */
   --shadow-comment-card:
@@ -143,6 +153,9 @@
   --block-bg-purple: #ad46ff26;
   --block-bg-pink: #f6339a26;
   --block-bg-red: #fb2c3626;
+
+  --database-chip: #529cca;
+  --database-chip-foreground: #8ec7ff;
 }
 
 @layer base {

package/corpus/templates/content/app/hooks/content-action-refresh.ts

@@ -30,12 +30,14 @@ const DOCUMENT_MUTATIONS = new Set([
   "delete-document",
   "delete-document-property",
   "delete-content-database",
+  "disconnect-content-database-source",
   "execute-content-trash-purge",
   "permanently-delete-document",
   "duplicate-document-property",
   "edit-document",
   "execute-builder-source-batch",
   "execute-builder-source-execution",
+  "create-github-collection",
   "import-content-source",
   "link-github-folder",
   "migrate-content-database-rows",
@@ -72,12 +74,14 @@ const DATABASE_RESULT_MUTATIONS = new Set([
   "delete-content-database",
   "delete-document",
   "delete-document-property",
+  "disconnect-content-database-source",
   "duplicate-database-item",
   "duplicate-database-items",
   "duplicate-document-property",
   "edit-document",
   "execute-builder-source-batch",
   "execute-builder-source-execution",
+  "create-github-collection",
   "import-content-source",
   "link-github-folder",
   "migrate-content-database-rows",
@@ -103,6 +107,7 @@ const DATABASE_PRESENTATION_MUTATIONS = new Set([
 ]);
 
 const DATABASE_LIFECYCLE_MUTATIONS = new Set([
+  "create-github-collection",
   "delete-content-database",
   "execute-content-trash-purge",
   "permanently-delete-document",
@@ -115,6 +120,7 @@ const DATABASE_LIFECYCLE_MUTATIONS = new Set([
 
 const DOCUMENT_DISCOVERY_MUTATIONS = new Set([
   "create-document",
+  "create-github-collection",
   "import-content",
   "link-github-folder",
   "refresh-content-database-source",

package/corpus/templates/content/app/hooks/use-content-database.ts

@@ -1837,7 +1837,9 @@ export function useRefreshContentDatabaseSource(documentId: string) {
     RefreshContentDatabaseSourceRequest
   >("refresh-content-database-source", {
     skipActionQueryInvalidation: true,
-    onSuccess: () => {
+    // A GitHub refresh that fails stores the problem on the source first, so
+    // the status line rereads after a failure too.
+    onSettled: () => {
       invalidateContentDatabaseSourceRefreshQueries(queryClient, documentId);
     },
   });