@jant/core 0.6.14 → 0.6.15

package/src/node/__tests__/cli-snapshot-meta.test.ts

@@ -4,6 +4,9 @@ import {
   assertSnapshotMeta,
   buildSnapshotMeta,
   getSnapshotDialect,
+  SNAPSHOT_VERSION,
+  upgradeSnapshotSql,
+  upgradeV1SnapshotSql,
 } from "../../../bin/lib/site-snapshot.js";
 
 const SITE = { id: "sit_test", key: "default" };
@@ -11,6 +14,7 @@ const SITE = { id: "sit_test", key: "default" };
 describe("buildSnapshotMeta", () => {
   it("includes the dialect when provided", () => {
     const meta = buildSnapshotMeta(SITE, { dialect: "pg" });
+    expect(meta.version).toBe(2);
     expect(meta.dialect).toBe("pg");
     expect(meta.site).toEqual({ id: "sit_test", key: "default" });
   });
@@ -38,6 +42,26 @@ describe("assertSnapshotMeta", () => {
     expect(() => assertSnapshotMeta(buildSnapshotMeta(SITE))).not.toThrow();
   });
 
+  it("accepts v1 snapshots for import compatibility", () => {
+    expect(() =>
+      assertSnapshotMeta({
+        format: "jant-site-snapshot",
+        version: 1,
+        site: SITE,
+      }),
+    ).not.toThrow();
+  });
+
+  it("rejects unknown snapshot versions", () => {
+    expect(() =>
+      assertSnapshotMeta({
+        format: "jant-site-snapshot",
+        version: SNAPSHOT_VERSION + 1,
+        site: SITE,
+      }),
+    ).toThrow(/Unsupported snapshot version/);
+  });
+
   it("rejects an unknown dialect at read time", () => {
     expect(() =>
       assertSnapshotMeta({
@@ -50,6 +74,82 @@ describe("assertSnapshotMeta", () => {
   });
 });
 
+describe("upgradeV1SnapshotSql", () => {
+  it("unions per-post Collection rows into Thread rows without losing metadata", () => {
+    const sql = `
+      INSERT INTO "collection" ("id", "site_id") VALUES('col_a', 'sit_test');
+      INSERT INTO "collection" ("id", "site_id") VALUES('col_b', 'sit_test');
+      INSERT INTO "post" ("id", "site_id", "thread_id") VALUES('pst_root', 'sit_test', 'pst_root');
+      INSERT INTO "post" ("id", "site_id", "thread_id") VALUES('pst_reply', 'sit_test', 'pst_root');
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_root', 'col_a', 10, 5, 40);
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_reply', 'col_a', 30, 2, 20);
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_reply', 'col_b', 15, 9, NULL);
+    `;
+
+    const upgraded = upgradeV1SnapshotSql(sql);
+    expect(upgraded).not.toContain('INSERT INTO "post_collection"');
+    expect(upgraded).toContain(
+      'INSERT INTO "thread_collection" ("site_id", "thread_id", "collection_id", "created_at", "position", "pinned_at") VALUES(\'sit_test\', \'pst_root\', \'col_a\', 30, 2, 40)',
+    );
+    expect(upgraded).toContain(
+      'INSERT INTO "thread_collection" ("site_id", "thread_id", "collection_id", "created_at", "position", "pinned_at") VALUES(\'sit_test\', \'pst_root\', \'col_b\', 15, 9, NULL)',
+    );
+  });
+
+  it("preserves comment-like lines inside multiline post content", () => {
+    const body = ["before", "-- must survive", "---", "after"].join("\n");
+    const sql = `
+      -- export metadata must be ignored as a real SQL comment
+      INSERT INTO "collection" ("id", "site_id") VALUES('col_a', 'sit_test');
+      INSERT INTO "post" ("id", "site_id", "thread_id", "body") VALUES('pst_root', 'sit_test', 'pst_root', '${body}');
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_root', 'col_a', 10, 0, NULL);
+    `;
+
+    const upgraded = upgradeV1SnapshotSql(sql);
+    expect(upgraded).toContain(`'${body}'`);
+    expect(upgraded).not.toContain("export metadata must be ignored");
+  });
+
+  it("fails a dangling v1 membership during preflight conversion", () => {
+    const sql = `
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_missing', 'col_a', 10, 0, NULL);
+    `;
+    expect(() => upgradeV1SnapshotSql(sql)).toThrow(
+      /references missing post pst_missing.*target content was not changed/,
+    );
+  });
+
+  it("fails a v1 membership whose Collection is missing", () => {
+    const sql = `
+      INSERT INTO "post" ("id", "site_id", "thread_id") VALUES('pst_root', 'sit_test', 'pst_root');
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_root', 'col_missing', 10, 0, NULL);
+    `;
+
+    expect(() => upgradeV1SnapshotSql(sql)).toThrow(
+      /references missing Collection col_missing.*target content was not changed/,
+    );
+  });
+
+  it("fails a v1 membership whose thread_id points at a reply", () => {
+    const sql = `
+      INSERT INTO "collection" ("id", "site_id") VALUES('col_a', 'sit_test');
+      INSERT INTO "post" ("id", "site_id", "thread_id") VALUES('pst_member', 'sit_test', 'pst_reply');
+      INSERT INTO "post" ("id", "site_id", "thread_id") VALUES('pst_reply', 'sit_test', 'pst_root');
+      INSERT INTO "post_collection" ("site_id", "post_id", "collection_id", "created_at", "position", "pinned_at") VALUES('sit_test', 'pst_member', 'col_a', 10, 0, NULL);
+    `;
+
+    expect(() => upgradeV1SnapshotSql(sql)).toThrow(
+      /references invalid Thread root pst_reply.*target content was not changed/,
+    );
+  });
+
+  it("leaves v2 SQL unchanged", () => {
+    const sql =
+      'INSERT INTO "thread_collection" ("site_id") VALUES(\'sit_test\');';
+    expect(upgradeSnapshotSql(sql, 2)).toBe(sql);
+  });
+});
+
 describe("getSnapshotDialect", () => {
   it("returns the dialect when valid", () => {
     expect(getSnapshotDialect({ dialect: "pg" })).toBe("pg");

package/src/node/index.ts

@@ -14,6 +14,7 @@ export { buildThemeStyle } from "../lib/theme.js";
 export { BUILTIN_COLOR_THEMES } from "../ui/color-themes.js";
 export {
   BUILTIN_FONT_THEMES,
-  getCjkSerifCssVariables,
+  getCjkFontCssVariables,
   getFontThemeCssVariables,
+  resolveCjkFontProfile,
 } from "../ui/font-themes.js";

package/src/preset.css

@@ -237,9 +237,19 @@ html {
     padding-left: 1.4em;
   }
 
+  :where(ol ol) {
+    list-style-type: lower-alpha;
+    margin-top: 0.4em;
+    margin-bottom: 0.4em;
+  }
+
+  :where(ol ol ol) {
+    list-style-type: lower-roman;
+  }
+
   :where(li, dt) {
-    margin-top: 0.65em;
-    margin-bottom: 0.65em;
+    margin-top: 0.5em;
+    margin-bottom: 0.5em;
   }
 
   /* Normalize li > p so list spacing is controlled by li alone,
@@ -252,6 +262,10 @@ html {
     margin-bottom: 0;
   }
 
+  :where(li > p:has(+ ol)) {
+    margin-bottom: 0;
+  }
+
   :where(code, pre code) {
     font-size: var(--type-code);
     line-height: 1.42;

package/src/routes/__tests__/compose.test.ts

@@ -351,4 +351,55 @@ describe("Compose Routes", () => {
       expect(data.error).toBeDefined();
     });
   });
+
+  describe("POST /compose/thread", () => {
+    it("keeps the existing thread activity unchanged for a quiet multi-post reply", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/compose", composeRoutes);
+
+      const root = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "Existing root",
+        publishedAt: 1000,
+      });
+
+      const res = await app.request("/compose/thread", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+        },
+        body: JSON.stringify({
+          posts: [
+            {
+              format: "note",
+              bodyMarkdown: "Quiet reply one",
+              status: "published",
+              replyToId: root.id,
+              quietReply: true,
+              publishedAt: 9000,
+            },
+            {
+              format: "note",
+              bodyMarkdown: "Quiet reply two",
+              status: "published",
+            },
+          ],
+        }),
+      });
+
+      expect(res.status).toBe(200);
+      expect(await res.json()).toMatchObject({ status: "published" });
+
+      const thread = await services.posts.getThread(root.id);
+      expect(thread.map((post) => post.bodyText)).toEqual([
+        "Existing root",
+        "Quiet reply one",
+        "Quiet reply two",
+      ]);
+      expect((await services.posts.getById(root.id))?.lastActivityAt).toBe(
+        1000,
+      );
+    });
+  });
 });

package/src/routes/__tests__/site-skill.test.ts

@@ -0,0 +1,112 @@
+import { Hono } from "hono";
+import { describe, expect, it } from "vitest";
+import { withConfig } from "../../middleware/config.js";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../types/app-context.js";
+import { siteSkillRoutes } from "../site-skill.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+function createSiteSkillTestApp(
+  env: Partial<Bindings> = {},
+  pathPrefix: string | null = null,
+) {
+  const app = new Hono<Env>();
+
+  app.use("*", async (c, next) => {
+    c.env = env as Bindings;
+    c.set("publicRequestUrl", c.req.url);
+    c.set(
+      "currentSiteDomain",
+      pathPrefix === null
+        ? null
+        : ({ pathPrefix } as AppVariables["currentSiteDomain"]),
+    );
+    c.set("services", {
+      settings: {
+        getAll: async () => ({}),
+      },
+    } as AppVariables["services"]);
+    await next();
+  });
+  app.use("*", withConfig());
+  app.route("/", siteSkillRoutes);
+
+  return app;
+}
+
+describe("GET /skill.md", () => {
+  it("binds the guide to the request origin when SITE_ORIGIN is absent", async () => {
+    const app = createSiteSkillTestApp();
+
+    const response = await app.request("https://owen.jant.blog/skill.md");
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("Content-Type")).toBe(
+      "text/markdown; charset=utf-8",
+    );
+    expect(response.headers.get("Cache-Control")).toBe(
+      "public, max-age=300, s-maxage=3600",
+    );
+    expect(response.headers.get("X-Robots-Tag")).toBe("noindex");
+
+    const markdown = await response.text();
+    expect(markdown).toContain("name: jant-site");
+    expect(markdown).toContain("# Jant Site Skill");
+    expect(markdown).toContain(
+      "This site-scoped copy is bound to <https://owen.jant.blog>",
+    );
+    expect(markdown).toContain(
+      'curl -X POST "https://owen.jant.blog/api/upload"',
+    );
+    expect(markdown).toContain(
+      'curl -X POST "https://owen.jant.blog/api/collections"',
+    );
+    expect(markdown).toContain(
+      "Sign in to Jant at `https://owen.jant.blog/signin`",
+    );
+    expect(markdown).not.toContain("$JANT_SITE");
+    expect(markdown).not.toContain("<site>");
+    expect(markdown).not.toContain("export JANT_SITE=");
+    expect(markdown).toContain("## Common Content Operations");
+    expect(markdown).toContain("## Import Content from Another Platform");
+    expect(markdown).not.toContain("## If You Need to Start Over");
+    expect(markdown).toContain('"url": "https://example.com/post"');
+    expect(markdown).toContain("https://jant.me/docs/API.md");
+  });
+
+  it("uses the configured canonical URL and path prefix in single-site mode", async () => {
+    const app = createSiteSkillTestApp({
+      SITE_ORIGIN: "https://example.com",
+      SITE_PATH_PREFIX: "/blog/",
+    });
+
+    const response = await app.request("https://preview.example/skill.md");
+    const markdown = await response.text();
+
+    expect(markdown).toContain(
+      "This site-scoped copy is bound to <https://example.com/blog>",
+    );
+    expect(markdown).toContain(
+      'curl -X POST "https://example.com/blog/api/upload"',
+    );
+    expect(markdown).not.toContain("https://preview.example");
+  });
+
+  it("includes a resolved domain path prefix in host-based mode", async () => {
+    const app = createSiteSkillTestApp(
+      { SITE_RESOLUTION_MODE: "host-based" },
+      "/notes",
+    );
+
+    const response = await app.request("https://owen.example/skill.md");
+    const markdown = await response.text();
+
+    expect(markdown).toContain(
+      "This site-scoped copy is bound to <https://owen.example/notes>",
+    );
+    expect(markdown).toContain(
+      'curl -X POST "https://owen.example/notes/api/collections"',
+    );
+  });
+});

package/src/routes/api/__tests__/collections.test.ts

@@ -18,7 +18,7 @@ describe("Collections API Routes", () => {
       expect(body.directoryItems).toEqual([]);
     });
 
-    it("returns collections with post counts and directory items", async () => {
+    it("returns collections with Thread counts and directory items", async () => {
       const { app, services } = createTestApp();
       app.route("/api/collections", collectionsApiRoutes);
 
@@ -30,14 +30,14 @@ describe("Collections API Routes", () => {
         format: "note",
         bodyMarkdown: "tech post",
       });
-      await services.collections.addPost(col.id, post.id);
+      await services.collections.addThread(col.id, post.id);
 
       const res = await app.request("/api/collections");
       const body = await res.json();
 
       expect(body.collections).toHaveLength(1);
       expect(body.collections[0].slug).toBe("tech");
-      expect(body.collections[0].postCount).toBe(1);
+      expect(body.collections[0].threadCount).toBe(1);
       expect(body.collections[0].recentActivityAt).toBe(post.lastActivityAt);
 
       expect(body.directoryItems).toHaveLength(1);
@@ -460,8 +460,8 @@ describe("Collections API Routes", () => {
     });
   });
 
-  describe("POST /api/collections/:id/posts", () => {
-    it("adds a post to a collection", async () => {
+  describe("POST /api/collections/:id/threads", () => {
+    it("adds a thread to a collection", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/api/collections", collectionsApiRoutes);
 
@@ -474,16 +474,46 @@ describe("Collections API Routes", () => {
         bodyMarkdown: "test",
       });
 
-      const res = await app.request(`/api/collections/${col.id}/posts`, {
+      const res = await app.request(`/api/collections/${col.id}/threads`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ postId: post.id }),
+        body: JSON.stringify({ threadId: post.id }),
       });
 
       expect(res.status).toBe(201);
 
-      const postIds = await services.collections.getPostIds(col.id);
-      expect(postIds).toContain(post.id);
+      const threadIds = await services.collections.getThreadIds(col.id);
+      expect(threadIds).toContain(post.id);
+    });
+
+    it("normalizes a child post ID to the thread root", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      const root = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const child = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "child",
+        replyToId: root.id,
+      });
+
+      const res = await app.request(`/api/collections/${col.id}/threads`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ threadId: child.id }),
+      });
+
+      expect(res.status).toBe(201);
+      expect(await services.collections.getThreadIds(col.id)).toEqual([
+        root.id,
+      ]);
     });
 
     it("returns 404 for non-existent collection", async () => {
@@ -496,10 +526,10 @@ describe("Collections API Routes", () => {
         bodyMarkdown: "test",
       });
 
-      const res = await app.request(`/api/collections/${missingId}/posts`, {
+      const res = await app.request(`/api/collections/${missingId}/threads`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ postId: post.id }),
+        body: JSON.stringify({ threadId: post.id }),
       });
 
       expect(res.status).toBe(404);
@@ -514,11 +544,11 @@ describe("Collections API Routes", () => {
         title: "Tech",
       });
 
-      const res = await app.request(`/api/collections/${col.id}/posts`, {
+      const res = await app.request(`/api/collections/${col.id}/threads`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          postId: "00000000-0000-0000-0000-000000000001",
+          threadId: "00000000-0000-0000-0000-000000000001",
         }),
       });
 
@@ -526,8 +556,8 @@ describe("Collections API Routes", () => {
     });
   });
 
-  describe("DELETE /api/collections/:id/posts/:postId", () => {
-    it("removes a post from a collection", async () => {
+  describe("DELETE /api/collections/:id/threads/:threadId", () => {
+    it("removes a thread from a collection", async () => {
       const { app, services } = createTestApp({ authenticated: true });
       app.route("/api/collections", collectionsApiRoutes);
 
@@ -540,17 +570,59 @@ describe("Collections API Routes", () => {
         bodyMarkdown: "test",
       });
 
-      await services.collections.addPost(col.id, post.id);
+      await services.collections.addThread(col.id, post.id);
 
       const res = await app.request(
-        `/api/collections/${col.id}/posts/${post.id}`,
+        `/api/collections/${col.id}/threads/${post.id}`,
         { method: "DELETE" },
       );
 
       expect(res.status).toBe(200);
 
-      const postIds = await services.collections.getPostIds(col.id);
-      expect(postIds).not.toContain(post.id);
+      const threadIds = await services.collections.getThreadIds(col.id);
+      expect(threadIds).not.toContain(post.id);
+    });
+  });
+
+  describe("PUT/DELETE /api/collections/:id/threads/:threadId/pin", () => {
+    it("pins and unpins the whole thread when given a child post ID", async () => {
+      const { app, services } = createTestApp({ authenticated: true });
+      app.route("/api/collections", collectionsApiRoutes);
+
+      const col = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      const root = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "root",
+      });
+      const child = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "child",
+        replyToId: root.id,
+      });
+      await services.collections.addThread(col.id, root.id);
+
+      const pinRes = await app.request(
+        `/api/collections/${col.id}/threads/${child.id}/pin`,
+        { method: "PUT" },
+      );
+
+      expect(pinRes.status).toBe(200);
+      expect(await services.collections.getPinnedThreadIds([col.id])).toEqual(
+        new Set([root.id]),
+      );
+
+      const unpinRes = await app.request(
+        `/api/collections/${col.id}/threads/${child.id}/pin`,
+        { method: "DELETE" },
+      );
+
+      expect(unpinRes.status).toBe(200);
+      expect(await services.collections.getPinnedThreadIds([col.id])).toEqual(
+        new Set(),
+      );
     });
   });
 });

package/src/routes/api/__tests__/mcp.test.ts

@@ -144,11 +144,75 @@ describe("MCP API Routes", () => {
     );
 
     expect(toolNames).toContain("jant_posts_list");
-    expect(toolNames).toContain("jant_collections_add_post");
+    expect(toolNames).toContain("jant_collections_add_thread");
+    expect(toolNames).toContain("jant_collections_remove_thread");
     expect(toolNames).toContain("jant_settings_update");
     expect(toolNames).toContain("jant_search_posts");
   });
 
+  it("manages collection membership at the thread root", async () => {
+    const { app, services } = createTestApp({ authenticated: true });
+    app.route("/api/mcp", mcpApiRoutes);
+
+    const collection = await services.collections.create({
+      slug: "notes",
+      title: "Notes",
+    });
+    const root = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Root",
+    });
+    const child = await services.posts.create({
+      format: "note",
+      bodyMarkdown: "Child",
+      replyToId: root.id,
+    });
+
+    const addRes = await postMcp(
+      app,
+      {
+        jsonrpc: "2.0",
+        id: 21,
+        method: "tools/call",
+        params: {
+          name: "jant_collections_add_thread",
+          arguments: {
+            collectionId: collection.id,
+            threadId: child.id,
+          },
+        },
+      },
+      { "MCP-Protocol-Version": "2025-06-18" },
+    );
+
+    expect(addRes.status).toBe(200);
+    expect((await addRes.json()).result.isError).toBe(false);
+    expect(await services.collections.getThreadIds(collection.id)).toEqual([
+      root.id,
+    ]);
+
+    const removeRes = await postMcp(
+      app,
+      {
+        jsonrpc: "2.0",
+        id: 22,
+        method: "tools/call",
+        params: {
+          name: "jant_collections_remove_thread",
+          arguments: {
+            collectionId: collection.id,
+            threadId: child.id,
+          },
+        },
+      },
+      { "MCP-Protocol-Version": "2025-06-18" },
+    );
+
+    expect(removeRes.status).toBe(200);
+    expect((await removeRes.json()).result.isError).toBe(false);
+    expect(await services.collections.getThreadIds(collection.id)).toEqual([]);
+  });
+
   it("creates posts through tools/call", async () => {
     const { app, services } = createTestApp({ authenticated: true });
     app.route("/api/mcp", mcpApiRoutes);