@agent-native/core 0.88.0 → 0.90.1

package/corpus/templates/content/AGENTS.md

@@ -105,6 +105,7 @@ cd templates/content && pnpm action <name> [args]
 | `edit-document`                             | `--id <id> --edits <json>`                                                                                                                                     | Batch surgical text edits                                                                                                               |
 | `update-document`                           | `--id <id> [--title] [--content] [--icon]`                                                                                                                     | Full rewrite of document fields                                                                                                         |
 | `share-local-file-document`                 | `--id <local-file-document-id>`                                                                                                                                | Create or refresh a DB-backed shareable copy of a local file document                                                                   |
+| `remove-local-file-source`                  | `[--sourceRootPath <path>]`                                                                                                                                    | Unlink local-file sources from Content without deleting local Markdown/MDX files                                                        |
 | `list-local-component-files`                |                                                                                                                                                                | List registered local MDX component source files                                                                                        |
 | `write-local-component-file`                | `--workspaceId <id> --path <relative-component-path> --content <source>`                                                                                       | Create or update a file in a registered local `components/` folder                                                                      |
 | `create-content-database`                   | `[--documentId <id>] [--parentId <id>] [--title <text>]`                                                                                                       | Create a database page or convert an existing page into a database                                                                      |
@@ -216,12 +217,19 @@ Content has two file workflows:
   retargeting workflow is added.
 - **Builder source components:** Builder CMS database body hydration renders
   unsupported provider-native body blocks as `<SourceComponent ... />` markers.
-  Treat these as read-only preservation anchors, not editable local blocks.
-  Agents may edit surrounding prose, but must not delete, duplicate, move, or
-  rewrite `rawRef`, `rawHash`, or marker ids unless a dedicated provider
-  conversion workflow exists. Guarded Builder write-back refuses missing,
-  tampered, or structurally moved markers so source-native components are not
-  lost.
+  These markers include `mappingStatus` and `sourceEditState`: `mapped` /
+  `safe-to-edit` content has an explicit Markdown/NFM mapper, `preserved` /
+  `needs-review` content keeps a known Builder/source component intact for
+  review, and `unknown` / `preserved-only` content is an unmapped provider block
+  that must round-trip as-is. Treat source-component markers as read-only
+  preservation anchors, not editable local blocks. Agents may edit surrounding
+  prose, but must not delete, duplicate, move, or rewrite `rawRef`, `rawHash`,
+  mapping metadata, or marker ids unless a dedicated provider conversion
+  workflow exists. Guarded Builder write-back refuses missing, tampered, or
+  structurally moved markers so source-native components are not lost.
+  Readable bodies hydrated before source-component mapping may need a fresh
+  Builder body hydration pass before guarded push, because newly preserved
+  markers are intentionally treated as structure changes.
 - **Picked folders and components:** browser-picked folders can be the
   source of truth for `.md`/`.mdx` files, but the browser does not expose an
   absolute path that Vite can compile. Component previews from a picked
@@ -280,14 +288,14 @@ explicit sync action.
 
 ### Notion Integration
 
-| Action                  | Args                                    | Purpose                                   |
-| ----------------------- | --------------------------------------- | ----------------------------------------- |
-| `connect-notion-status` |                                         | Check Notion connection                   |
-| `link-notion-page`      | `--documentId <id> --notionPageId <id>` | Link doc to Notion page                   |
-| `list-notion-links`     |                                         | List linked documents                     |
-| `pull-notion-page`      | `--documentId <id>`                     | Pull content from Notion                  |
-| `push-notion-page`      | `--documentId <id>`                     | Push content to Notion                    |
-| `sync-notion-comments`  | `--documentId <id>`                     | Sync comments with Notion (bidirectional) |
+| Action                  | Args                                     | Purpose                                   |
+| ----------------------- | ---------------------------------------- | ----------------------------------------- |
+| `connect-notion-status` |                                          | Check Notion connection                   |
+| `link-notion-page`      | `--documentId <id> --pageId <id-or-url>` | Link doc to Notion page                   |
+| `list-notion-links`     |                                          | List linked documents                     |
+| `pull-notion-page`      | `--documentId <id>`                      | Pull content from Notion                  |
+| `push-notion-page`      | `--documentId <id>`                      | Push content to Notion                    |
+| `sync-notion-comments`  | `--documentId <id>`                      | Sync comments with Notion (bidirectional) |
 
 Use `provider-api-catalog`, `provider-api-docs`, and `provider-api-request`
 for Notion endpoints, filters, pagination modes, payload shapes, or API

package/corpus/templates/content/actions/_local-file-documents.ts

@@ -1,8 +1,11 @@
+import fs from "node:fs/promises";
+
 import {
   deleteLocalArtifactFile,
   ensureLocalArtifactRoot,
   getLocalArtifactApp,
   isAgentNativeLocalFileMode,
+  loadAgentNativeManifest,
   listLocalArtifactFiles,
   readLocalArtifactFile,
   writeLocalArtifactFile,
@@ -265,10 +268,96 @@ function cloneLocalDocument(document: Document): Document {
   };
 }
 
-function invalidateLocalFileDocumentsCache() {
+export function invalidateLocalFileDocumentsCache() {
   localFileDocumentsCache = null;
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeRootPath(rootPath: string) {
+  return rootPath.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+}
+
+export async function removeContentLocalFileRoots(
+  sourceRootPath?: string | null,
+) {
+  const app = await getLocalArtifactApp(localOptions());
+  if (app.mode !== "local-files") {
+    return { removed: 0, roots: [] as string[], manifestPath: null };
+  }
+
+  const loaded = await loadAgentNativeManifest({
+    ...localOptions(),
+    optional: false,
+  });
+  if (!loaded) {
+    throw new Error("No agent-native.json file is available to update.");
+  }
+
+  const raw = JSON.parse(await fs.readFile(loaded.path, "utf8")) as unknown;
+  const manifest = isRecord(raw) ? raw : {};
+  const apps = isRecord(manifest.apps) ? manifest.apps : {};
+  const existingContentApp = isRecord(apps[CONTENT_APP_ID])
+    ? apps[CONTENT_APP_ID]
+    : {};
+  const roots = Array.isArray(existingContentApp.roots)
+    ? existingContentApp.roots.filter(
+        (root): root is Record<string, unknown> =>
+          isRecord(root) && typeof root.path === "string",
+      )
+    : [];
+
+  if (roots.length === 0) {
+    throw new Error(
+      "Local file roots are not declared in agent-native.json for Content.",
+    );
+  }
+
+  const targetRootPath = sourceRootPath
+    ? normalizeRootPath(sourceRootPath)
+    : null;
+  const removedRoots = roots.filter((root) => {
+    if (!targetRootPath) return true;
+    return normalizeRootPath(root.path as string) === targetRootPath;
+  });
+
+  if (removedRoots.length === 0) {
+    throw new Error("No matching local file root was found.");
+  }
+
+  const nextRoots = roots.filter((root) => !removedRoots.includes(root));
+  const nextContentApp = {
+    ...existingContentApp,
+    mode: nextRoots.length > 0 ? "local-files" : "database",
+    roots: nextRoots,
+  };
+
+  await fs.writeFile(
+    loaded.path,
+    `${JSON.stringify(
+      {
+        ...manifest,
+        apps: {
+          ...apps,
+          [CONTENT_APP_ID]: nextContentApp,
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+  invalidateLocalFileDocumentsCache();
+
+  return {
+    removed: removedRoots.length,
+    roots: removedRoots.map((root) => root.path as string),
+    manifestPath: loaded.path,
+  };
+}
+
 export async function listLocalFileDocuments(): Promise<Document[]> {
   const scope = localFileDocumentsCacheScope();
   if (

package/corpus/templates/content/actions/_notion-action-utils.ts

@@ -12,11 +12,15 @@ export function getCurrentNotionOwner() {
 
 export async function getNotionDocumentOwner(documentId: string) {
   const userEmail = getCurrentNotionOwner();
-  await assertAccess("document", documentId, "editor", {
+  const access = await assertAccess("document", documentId, "editor", {
     userEmail,
     orgId: getRequestOrgId(),
   });
-  return userEmail;
+  const owner = access?.resource?.ownerEmail;
+  if (typeof owner !== "string" || owner.length === 0) {
+    throw new Error("Document not found");
+  }
+  return owner;
 }
 
 export function resolveDocumentId(args: { documentId?: string; id?: string }) {

package/corpus/templates/content/actions/delete-document.ts

@@ -58,6 +58,14 @@ export async function deleteDocumentRecursive(
         eq(schema.builderDocSidecars.ownerEmail, ownerEmail),
       ),
     );
+  await db
+    .delete(schema.documentComments)
+    .where(
+      and(
+        eq(schema.documentComments.documentId, id),
+        eq(schema.documentComments.ownerEmail, ownerEmail),
+      ),
+    );
   await db
     .delete(schema.documentShares)
     .where(eq(schema.documentShares.resourceId, id));

package/corpus/templates/content/actions/remove-local-file-source.ts

@@ -0,0 +1,100 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  invalidateLocalFileDocumentsCache,
+  isContentLocalFileMode,
+  removeContentLocalFileRoots,
+} from "./_local-file-documents.js";
+import { deleteDocumentRecursive } from "./delete-document.js";
+
+async function removeImportedLocalSourceDocuments(
+  sourceRootPath?: string | null,
+) {
+  const db = getDb();
+  const clauses = [
+    eq(schema.documents.sourceMode, "local-files"),
+    eq(schema.documents.sourceKind, "file"),
+  ];
+  if (sourceRootPath) {
+    clauses.push(eq(schema.documents.sourceRootPath, sourceRootPath));
+  }
+
+  const candidates = await db
+    .select({
+      id: schema.documents.id,
+      parentId: schema.documents.parentId,
+    })
+    .from(schema.documents)
+    .where(
+      and(...clauses, accessFilter(schema.documents, schema.documentShares)),
+    );
+  const candidateIds = new Set(candidates.map((document) => document.id));
+  const roots = candidates.filter(
+    (document) => !document.parentId || !candidateIds.has(document.parentId),
+  );
+  let deleted = 0;
+
+  for (const document of roots) {
+    const access = await assertAccess("document", document.id, "admin");
+    deleted += (
+      await deleteDocumentRecursive(
+        db,
+        document.id,
+        access.resource.ownerEmail as string,
+      )
+    ).length;
+  }
+
+  return { removed: deleted, roots: [] as string[], manifestPath: null };
+}
+
+export default defineAction({
+  description:
+    "Remove local-file sources from Content without deleting the files on disk. In local-file mode this unlinks configured Content roots from agent-native.json; in database mode this removes imported local-file document entries.",
+  schema: z.object({
+    sourceRootPath: z
+      .string()
+      .optional()
+      .nullable()
+      .describe(
+        "Optional source root path to remove. Omit to remove all local-file sources visible in Content.",
+      ),
+  }),
+  publicAgent: {
+    expose: true,
+    readOnly: false,
+    requiresAuth: true,
+    isConsequential: true,
+    title: "Remove local file source",
+    description:
+      "Unlink local-file entries from Content without deleting local Markdown or MDX files.",
+  },
+  run: async ({ sourceRootPath }) => {
+    const result = (await isContentLocalFileMode())
+      ? await removeContentLocalFileRoots(sourceRootPath)
+      : await removeImportedLocalSourceDocuments(sourceRootPath);
+
+    if (result.removed === 0 && result.roots.length === 0) {
+      throw new Error(
+        sourceRootPath
+          ? "No matching local file source was found."
+          : "No local file sources were found to remove.",
+      );
+    }
+
+    invalidateLocalFileDocumentsCache();
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      success: true,
+      deleted: result.removed,
+      removedRoots: result.roots,
+      manifestPath: result.manifestPath,
+    };
+  },
+});

package/corpus/templates/content/actions/sync-notion-comments.ts

@@ -3,11 +3,11 @@ import { and, eq, isNull } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { getCurrentOwnerEmail } from "../server/lib/documents.js";
+import { getNotionDocumentOwner } from "./_notion-action-utils.js";
 
 export default defineAction({
   description:
-    "Sync comments bidirectionally with Notion. Pulls new Notion comments and pushes local ones.",
+    "Sync comments bidirectionally with Notion. Pulls new Notion comments (preserving reply threading) and pushes local ones.",
   schema: z.object({
     documentId: z.string().optional().describe("Document ID (required)"),
   }),
@@ -23,7 +23,7 @@ export default defineAction({
       addNotionComment,
     } = await import("../server/lib/notion.js");
     const { getSyncLink } = await import("../server/lib/notion-sync.js");
-    const owner = getCurrentOwnerEmail();
+    const owner = await getNotionDocumentOwner(documentId);
 
     // Check if document is linked to Notion
     const syncLink = await getSyncLink(documentId, owner);
@@ -42,24 +42,78 @@ export default defineAction({
     const ownerEmail = owner;
 
     // Pull: Notion -> Local
+    //
+    // Notion groups a top-level comment and all of its replies under one
+    // `discussion_id` (a top-level comment's own id doubles as its
+    // discussion's id). To preserve that threading locally we:
+    //   1. Load the local comments already synced for this document so we
+    //      can map a Notion discussion_id to the local thread root that
+    //      already carries it (either as notionDiscussionId, if it was the
+    //      thread root, or as notionCommentId, since a thread root's own
+    //      Notion comment id equals its discussion_id).
+    //   2. Walk the pulled comments twice: once to land every top-level
+    //      comment (discussion_id === id) so replies always have a local
+    //      parent to attach to regardless of Notion's return order, then
+    //      once for replies.
     const notionComments = await listNotionComments(notionPageId, accessToken);
     let pulled = 0;
 
-    for (const nc of notionComments) {
+    const existingByNotionId = new Map<
+      string,
+      { id: string; threadId: string; parentId: string | null }
+    >();
+    const existingRows = await db
+      .select({
+        id: schema.documentComments.id,
+        threadId: schema.documentComments.threadId,
+        parentId: schema.documentComments.parentId,
+        notionCommentId: schema.documentComments.notionCommentId,
+      })
+      .from(schema.documentComments)
+      .where(
+        and(
+          eq(schema.documentComments.documentId, documentId),
+          eq(schema.documentComments.ownerEmail, ownerEmail),
+        ),
+      );
+    for (const row of existingRows) {
+      if (row.notionCommentId) {
+        existingByNotionId.set(row.notionCommentId, {
+          id: row.id,
+          threadId: row.threadId,
+          parentId: row.parentId,
+        });
+      }
+    }
+
+    // Maps a Notion discussion_id to the local thread's root comment (id +
+    // threadId), so a reply pulled before or after its root in Notion's
+    // response can still find where to attach.
+    const threadRootByDiscussionId = new Map<
+      string,
+      { id: string; threadId: string }
+    >();
+    for (const [notionCommentId, local] of existingByNotionId) {
+      if (local.parentId === null) {
+        // A thread root's own Notion comment id is its discussion's id.
+        threadRootByDiscussionId.set(notionCommentId, {
+          id: local.id,
+          threadId: local.threadId,
+        });
+      }
+    }
+
+    const topLevel = notionComments.filter(
+      (nc) => !nc.discussion_id || nc.discussion_id === nc.id,
+    );
+    const replies = notionComments.filter(
+      (nc) => nc.discussion_id && nc.discussion_id !== nc.id,
+    );
+
+    for (const nc of topLevel) {
       const text = nc.rich_text.map((r) => r.plain_text).join("");
       if (!text) continue;
-
-      const existing = await db
-        .select({ id: schema.documentComments.id })
-        .from(schema.documentComments)
-        .where(
-          and(
-            eq(schema.documentComments.notionCommentId, nc.id),
-            eq(schema.documentComments.ownerEmail, ownerEmail),
-          ),
-        )
-        .limit(1);
-      if (existing.length > 0) continue;
+      if (existingByNotionId.has(nc.id)) continue;
 
       const id = Math.random().toString(36).slice(2, 14);
       await db.insert(schema.documentComments).values({
@@ -72,15 +126,67 @@ export default defineAction({
         authorEmail: "notion@sync",
         authorName: "Notion",
         notionCommentId: nc.id,
+        notionDiscussionId: nc.discussion_id ?? nc.id,
+      });
+      pulled++;
+      threadRootByDiscussionId.set(nc.discussion_id ?? nc.id, {
+        id,
+        threadId: id,
+      });
+    }
+
+    for (const nc of replies) {
+      const text = nc.rich_text.map((r) => r.plain_text).join("");
+      if (!text) continue;
+      if (existingByNotionId.has(nc.id)) continue;
+
+      const root = threadRootByDiscussionId.get(nc.discussion_id!);
+      if (!root) {
+        // The thread root isn't (and couldn't be) synced locally — e.g. it
+        // lives outside this comment list or was filtered out above.
+        // Preserving the reply as an orphaned top-level comment beats
+        // dropping it, but it will re-attach correctly if the root
+        // shows up on a later sync.
+        const id = Math.random().toString(36).slice(2, 14);
+        await db.insert(schema.documentComments).values({
+          id,
+          ownerEmail,
+          documentId,
+          threadId: id,
+          parentId: null,
+          content: text,
+          authorEmail: "notion@sync",
+          authorName: "Notion",
+          notionCommentId: nc.id,
+          notionDiscussionId: nc.discussion_id ?? null,
+        });
+        pulled++;
+        continue;
+      }
+
+      const id = Math.random().toString(36).slice(2, 14);
+      await db.insert(schema.documentComments).values({
+        id,
+        ownerEmail,
+        documentId,
+        threadId: root.threadId,
+        parentId: root.id,
+        content: text,
+        authorEmail: "notion@sync",
+        authorName: "Notion",
+        notionCommentId: nc.id,
+        notionDiscussionId: nc.discussion_id ?? null,
       });
       pulled++;
     }
 
     // Push: Local -> Notion
-    const localComments = await db
+    const unsortedLocalComments = await db
       .select({
         id: schema.documentComments.id,
         content: schema.documentComments.content,
+        threadId: schema.documentComments.threadId,
+        parentId: schema.documentComments.parentId,
       })
       .from(schema.documentComments)
       .where(
@@ -91,24 +197,72 @@ export default defineAction({
           eq(schema.documentComments.resolved, 0),
         ),
       );
+    // Push thread roots before their replies so a brand-new thread (root +
+    // reply both unsynced in the same run) establishes a discussion_id
+    // before the reply needs it, regardless of the DB's natural row order.
+    const localComments = [
+      ...unsortedLocalComments.filter((c) => c.parentId === null),
+      ...unsortedLocalComments.filter((c) => c.parentId !== null),
+    ];
     let pushed = 0;
 
+    // Thread roots keyed by threadId, so a reply being pushed can look up
+    // its root's stored notion_discussion_id (or the discussion id just
+    // established by pushing that root in this same run).
+    const rootDiscussionIdByThreadId = new Map<string, string | null>();
+
     for (const lc of localComments) {
-      const notionId = await addNotionComment(
+      const isReply = lc.parentId !== null;
+      let discussionId: string | null = null;
+
+      if (isReply) {
+        if (rootDiscussionIdByThreadId.has(lc.threadId)) {
+          discussionId = rootDiscussionIdByThreadId.get(lc.threadId) ?? null;
+        } else {
+          const [root] = await db
+            .select({
+              notionDiscussionId: schema.documentComments.notionDiscussionId,
+            })
+            .from(schema.documentComments)
+            .where(
+              and(
+                eq(schema.documentComments.documentId, documentId),
+                eq(schema.documentComments.ownerEmail, ownerEmail),
+                eq(schema.documentComments.threadId, lc.threadId),
+                isNull(schema.documentComments.parentId),
+              ),
+            )
+            .limit(1);
+          discussionId = root?.notionDiscussionId ?? null;
+          rootDiscussionIdByThreadId.set(lc.threadId, discussionId);
+        }
+      }
+
+      const created = await addNotionComment(
         notionPageId,
         lc.content,
         accessToken,
+        discussionId,
       );
-      if (notionId) {
+      if (created) {
         await db
           .update(schema.documentComments)
-          .set({ notionCommentId: notionId })
+          .set({
+            notionCommentId: created.id,
+            notionDiscussionId: created.discussionId,
+          })
           .where(
             and(
               eq(schema.documentComments.id, lc.id),
               eq(schema.documentComments.ownerEmail, ownerEmail),
             ),
           );
+        // If this was a fresh top-level comment, remember its new discussion
+        // id so any of its replies pushed later in this same run thread
+        // correctly without a second DB round-trip.
+        if (!isReply) {
+          rootDiscussionIdByThreadId.set(lc.threadId, created.discussionId);
+        }
         pushed++;
       }
     }