@cueloop/integration-obsidian 0.1.0-alpha.8 → 0.1.0-alpha.80

package/package.json

@@ -1,33 +1,34 @@
 {
   "name": "@cueloop/integration-obsidian",
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0-alpha.80",
+  "description": "Export reviewed cueloop plans into an Obsidian vault",
+  "homepage": "https://github.com/mmurakaru/cueloop#readme",
+  "bugs": {
+    "url": "https://github.com/mmurakaru/cueloop/issues"
+  },
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mmurakaru/cueloop.git",
+    "directory": "packages/integrations/obsidian"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
-  "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.8",
-    "@cueloop/schema": "0.1.0-alpha.8"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "dependencies": {
+    "@cueloop/extension-api": "0.1.0-alpha.80",
+    "@cueloop/schema": "0.1.0-alpha.80",
+    "valibot": "^1.4.2"
+  },
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/integrations/obsidian"
-  },
-  "homepage": "https://github.com/mmurakaru/cueloop#readme",
-  "bugs": {
-    "url": "https://github.com/mmurakaru/cueloop/issues"
-  },
-  "description": "Export reviewed cueloop plans into an Obsidian vault"
-}
+  }
+}

package/src/detect.test.ts

@@ -15,10 +15,13 @@ afterEach(() => {
 
 describe("detectVaults", () => {
   test("returns registered vault paths that exist on disk", () => {
+    // Arrange
     const alive = join(dir, "notes");
+
     mkdirSync(alive);
     const gone = join(dir, "deleted-vault");
     const configPath = join(dir, "obsidian.json");
+
     writeFileSync(
       configPath,
       JSON.stringify({
@@ -28,15 +31,19 @@ describe("detectVaults", () => {
         },
       }),
     );
+
+    // Assert
     expect(detectVaults(configPath)).toEqual([alive]);
   });
 
   test("missing or malformed config yields no vaults", () => {
     expect(detectVaults(join(dir, "nope.json"))).toEqual([]);
     const broken = join(dir, "broken.json");
+
     writeFileSync(broken, "not json");
     expect(detectVaults(broken)).toEqual([]);
     const empty = join(dir, "empty.json");
+
     writeFileSync(empty, "{}");
     expect(detectVaults(empty)).toEqual([]);
   });
@@ -44,7 +51,9 @@ describe("detectVaults", () => {
 
 describe("obsidianConfigPath", () => {
   test("resolves per platform", () => {
-    expect(obsidianConfigPath("darwin")).toContain(join("Library", "Application Support", "obsidian", "obsidian.json"));
+    expect(obsidianConfigPath("darwin")).toContain(
+      join("Library", "Application Support", "obsidian", "obsidian.json"),
+    );
     expect(obsidianConfigPath("linux")).toContain(join("obsidian", "obsidian.json"));
     expect(obsidianConfigPath("win32")).toContain(join("obsidian", "obsidian.json"));
   });

package/src/detect.ts

@@ -7,6 +7,11 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import * as v from "valibot";
+
+const ObsidianRegistrySchema = v.object({
+  vaults: v.optional(v.record(v.string(), v.object({ path: v.optional(v.string()) }))),
+});
 
 /** Platform-specific location of Obsidian's own obsidian.json. */
 export function obsidianConfigPath(platform: NodeJS.Platform = process.platform): string {
@@ -14,20 +19,28 @@ export function obsidianConfigPath(platform: NodeJS.Platform = process.platform)
     return join(homedir(), "Library", "Application Support", "obsidian", "obsidian.json");
   }
   if (platform === "win32") {
-    return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "obsidian", "obsidian.json");
+    return join(
+      process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"),
+      "obsidian",
+      "obsidian.json",
+    );
   }
-  return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "obsidian", "obsidian.json");
+
+  return join(
+    process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+    "obsidian",
+    "obsidian.json",
+  );
 }
 
 /** Vault paths registered with Obsidian that exist on disk. */
 export function detectVaults(configPath: string = obsidianConfigPath()): string[] {
   try {
-    const raw = JSON.parse(readFileSync(configPath, "utf8")) as {
-      vaults?: Record<string, { path?: string }>;
-    };
+    const raw = v.parse(ObsidianRegistrySchema, JSON.parse(readFileSync(configPath, "utf8")));
+
     return Object.values(raw.vaults ?? {})
-      .map((v) => v.path)
-      .filter((p): p is string => typeof p === "string" && existsSync(p));
+      .map((vault) => vault.path)
+      .filter((path): path is string => typeof path === "string" && existsSync(path));
   } catch {
     // no Obsidian install, or an unreadable registry: no vaults
     return [];

package/src/export.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 import { Registry } from "@cueloop/extension-api";
 import { OBSIDIAN_DEFAULTS, exportSession, shouldExport, type ObsidianConfig } from "./export";
 import { createObsidianExtension } from "./extension";
@@ -10,7 +10,7 @@ import { frontmatter } from "./frontmatter";
 
 const NOW = new Date("2026-08-07T12:34:56.000Z");
 
-function resolvedSession(overrides: Partial<ReviewSession> = {}): ReviewSession {
+function resolvedSession(overrides: Partial<Thread> = {}): Thread {
   return {
     schemaVersion: "1",
     id: "s_test1",
@@ -20,9 +20,21 @@ function resolvedSession(overrides: Partial<ReviewSession> = {}): ReviewSession
       content: "# Migration Plan\n\nMove the store.\n",
       meta: { title: "Migration Plan" },
     },
-    revisions: [{ revision: 1, content: "# Migration Plan\n\nMove the store.\n", submittedAt: NOW.toISOString() }],
+    revisions: [
+      {
+        revision: 1,
+        content: "# Migration Plan\n\nMove the store.\n",
+        submittedAt: NOW.toISOString(),
+      },
+    ],
     annotations: [],
-    verdict: { kind: "approve", summary: "ship it", feedback: "", resolvedAt: NOW.toISOString() },
+    message: {
+      id: "msg_1",
+      outcome: "approved",
+      summary: "ship it",
+      body: "",
+      sentAt: NOW.toISOString(),
+    },
     status: "resolved",
     createdAt: NOW.toISOString(),
     ...overrides,
@@ -44,53 +56,94 @@ function config(overrides: Partial<ObsidianConfig> = {}): ObsidianConfig {
 
 describe("exportSession", () => {
   test("writes the final plan with frontmatter into vault/folder", () => {
+    // Arrange
     const session = resolvedSession();
+
+    // Act
     const result = exportSession(session, config(), NOW);
+
+    // Assert
     expect(result.success).toBe(true);
     expect(result.path).toBe(join(vault, "cueloop", "2026-08-07 - Migration Plan.md"));
     const written = readFileSync(result.path!, "utf8");
+
     expect(written).toBe(`${frontmatter(session, NOW)}\n\n# Migration Plan\n\nMove the store.\n`);
     expect(written).toContain("created: 2026-08-07T12:34:56.000Z");
     expect(written).toContain("source: cueloop");
     expect(written).toContain("session: s_test1");
-    expect(written).toContain("verdict: approve");
+    expect(written).toContain("message: approved");
   });
 
   test("the working copy wins over the submitted content", () => {
-    const session = resolvedSession({ workingCopy: "# Migration Plan\n\nMove the store carefully.\n" });
+    // Arrange
+    const session = resolvedSession({
+      workingCopy: "# Migration Plan\n\nMove the store carefully.\n",
+    });
+
+    // Act
     const result = exportSession(session, config(), NOW);
+
+    // Assert
     expect(readFileSync(result.path!, "utf8")).toContain("Move the store carefully.");
   });
 
   test("never overwrites: collisions get counting suffixes", () => {
+    // Arrange
     const session = resolvedSession();
+
+    // Act
     const first = exportSession(session, config(), NOW);
     const second = exportSession(session, config(), NOW);
     const third = exportSession(session, config(), NOW);
+
+    // Assert
     expect(second.path).toBe(join(vault, "cueloop", "2026-08-07 - Migration Plan 2.md"));
     expect(third.path).toBe(join(vault, "cueloop", "2026-08-07 - Migration Plan 3.md"));
     expect(existsSync(first.path!)).toBe(true);
   });
 
   test("no vault configured and none detected fails without writing", () => {
+    // Arrange
     const emptyConfigPath = join(vault, "obsidian.json");
-    const result = exportSession(resolvedSession(), config({ vault: undefined, obsidianConfigPath: emptyConfigPath }), NOW);
+
+    // Act
+    const result = exportSession(
+      resolvedSession(),
+      config({ vault: undefined, obsidianConfigPath: emptyConfigPath }),
+      NOW,
+    );
+
+    // Assert
     expect(result.success).toBe(false);
     expect(result.error).toContain("no Obsidian vault");
   });
 
   test("a configured vault path that does not exist fails", () => {
+    // Act
     const result = exportSession(resolvedSession(), config({ vault: join(vault, "missing") }), NOW);
+
+    // Assert
     expect(result.success).toBe(false);
     expect(result.error).toContain("vault not found");
   });
 
   test("falls back to the first auto-detected vault", () => {
+    // Arrange
     const detected = join(vault, "detected-vault");
+
     mkdirSync(detected);
     const obsidianJson = join(vault, "obsidian.json");
+
     writeFileSync(obsidianJson, JSON.stringify({ vaults: { v1: { path: detected } } }));
-    const result = exportSession(resolvedSession(), config({ vault: undefined, obsidianConfigPath: obsidianJson }), NOW);
+
+    // Act
+    const result = exportSession(
+      resolvedSession(),
+      config({ vault: undefined, obsidianConfigPath: obsidianJson }),
+      NOW,
+    );
+
+    // Assert
     expect(result.success).toBe(true);
     expect(result.path).toBe(join(detected, "cueloop", "2026-08-07 - Migration Plan.md"));
   });
@@ -98,12 +151,22 @@ describe("exportSession", () => {
 
 describe("obsidian extension", () => {
   test("registers the exporter through the extension API and exports a resolved session", async () => {
+    // Arrange
     const registry = new Registry();
+
+    // Act
     const record = await registry.load("obsidian", createObsidianExtension(config()));
+
+    // Assert
     expect(record.errors).toEqual([]);
     const exporter = record.exporters.get("obsidian");
+
     expect(exporter).toBeDefined();
+
+    // Act
     const result = await exporter!(resolvedSession());
+
+    // Assert
     expect(result.success).toBe(true);
     expect(existsSync(result.path!)).toBe(true);
   });
@@ -111,19 +174,17 @@ describe("obsidian extension", () => {
 
 describe("shouldExport", () => {
   test("approve exports only approvals", () => {
-    expect(shouldExport("approve", "approve")).toBe(true);
-    expect(shouldExport("approve", "request_changes")).toBe(false);
-    expect(shouldExport("approve", "comment")).toBe(false);
+    expect(shouldExport("approved", "approved")).toBe(true);
+    expect(shouldExport("approved", "changes_requested")).toBe(false);
   });
 
-  test("resolve exports any verdict", () => {
-    expect(shouldExport("resolve", "approve")).toBe(true);
-    expect(shouldExport("resolve", "request_changes")).toBe(true);
-    expect(shouldExport("resolve", "comment")).toBe(true);
+  test("message exports any outcome", () => {
+    expect(shouldExport("message", "approved")).toBe(true);
+    expect(shouldExport("message", "changes_requested")).toBe(true);
   });
 
   test("manual never auto-exports", () => {
-    expect(shouldExport("manual", "approve")).toBe(false);
-    expect(shouldExport("manual", "request_changes")).toBe(false);
+    expect(shouldExport("manual", "approved")).toBe(false);
+    expect(shouldExport("manual", "changes_requested")).toBe(false);
   });
 });

package/src/export.ts

@@ -6,12 +6,12 @@
 
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import type { ReviewSession, VerdictKind } from "@cueloop/schema";
+import type { Thread, MessageOutcome } from "@cueloop/schema";
 import { detectVaults } from "./detect";
 import { formatFilename, titleFrom, uniquePath, type Separator } from "./filename";
 import { frontmatter } from "./frontmatter";
 
-export type ExportOn = "approve" | "resolve" | "manual";
+export type ExportOn = "approved" | "message" | "manual";
 
 export interface ObsidianConfig {
   /** Vault path; when unset, the first auto-detected vault is used. */
@@ -31,10 +31,11 @@ export const OBSIDIAN_DEFAULTS: ObsidianConfig = {
   exportOn: "manual",
 };
 
-/** approve exports only approvals; resolve exports any verdict; manual never auto-exports. */
-export function shouldExport(exportOn: ExportOn, verdict: VerdictKind): boolean {
-  if (exportOn === "approve") return verdict === "approve";
-  return exportOn === "resolve";
+/** approved exports only approvals; message exports any Message; manual never auto-exports. */
+export function shouldExport(exportOn: ExportOn, message: MessageOutcome): boolean {
+  if (exportOn === "approved") return message === "approved";
+
+  return exportOn === "message";
 }
 
 export interface ExportResult {
@@ -43,17 +44,25 @@ export interface ExportResult {
   error?: string;
 }
 
-export function exportSession(session: ReviewSession, config: ObsidianConfig, now: Date = new Date()): ExportResult {
+export function exportSession(
+  session: Thread,
+  config: ObsidianConfig,
+  now: Date = new Date(),
+): ExportResult {
   const vault = config.vault ?? detectVaults(config.obsidianConfigPath)[0];
+
   if (!vault) return { success: false, error: "no Obsidian vault configured or detected" };
   if (!existsSync(vault)) return { success: false, error: `vault not found: ${vault}` };
 
   const content = session.workingCopy ?? session.artifact.content;
   const title = titleFrom(content, session.artifact.meta.title);
   const dir = join(vault, config.folder);
+
   mkdirSync(dir, { recursive: true });
   const base = formatFilename(config.filenameFormat, title, now, config.separator);
   const path = uniquePath(dir, base);
+
   writeFileSync(path, `${frontmatter(session, now)}\n\n${content}`);
+
   return { success: true, path };
 }

package/src/filename.test.ts

@@ -23,7 +23,10 @@ describe("titleFrom", () => {
   });
 
   test("caps the title at 50 characters", () => {
+    // Arrange
     const long = "# " + "word ".repeat(20);
+
+    // Assert
     expect(titleFrom(long).length).toBeLessThanOrEqual(50);
     expect(titleFrom(long).endsWith(" ")).toBe(false);
   });
@@ -35,17 +38,22 @@ describe("titleFrom", () => {
 
 describe("formatFilename", () => {
   test("renders date tokens and the title with the space separator", () => {
-    expect(formatFilename("{YYYY}-{MM}-{DD} - {title}", "My Plan", DATE, "space")).toBe("2026-08-07 - My Plan");
+    expect(formatFilename("{YYYY}-{MM}-{DD} - {title}", "My Plan", DATE, "space")).toBe(
+      "2026-08-07 - My Plan",
+    );
   });
 
   test("dash and underscore separators replace whitespace runs", () => {
-    expect(formatFilename("{YYYY}-{MM}-{DD} - {title}", "My Plan", DATE, "dash")).toBe("2026-08-07---My-Plan");
+    expect(formatFilename("{YYYY}-{MM}-{DD} - {title}", "My Plan", DATE, "dash")).toBe(
+      "2026-08-07---My-Plan",
+    );
     expect(formatFilename("{title}", "My Plan", DATE, "underscore")).toBe("My_Plan");
   });
 });
 
 describe("uniquePath", () => {
   let dir: string;
+
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), "cueloop-obsidian-name-"));
   });
@@ -54,10 +62,19 @@ describe("uniquePath", () => {
   });
 
   test("appends counting suffixes instead of overwriting", () => {
+    // Assert
     expect(uniquePath(dir, "plan")).toBe(join(dir, "plan.md"));
+
+    // Act
     writeFileSync(join(dir, "plan.md"), "");
+
+    // Assert
     expect(uniquePath(dir, "plan")).toBe(join(dir, "plan 2.md"));
+
+    // Act
     writeFileSync(join(dir, "plan 2.md"), "");
+
+    // Assert
     expect(uniquePath(dir, "plan")).toBe(join(dir, "plan 3.md"));
   });
 });

package/src/filename.ts

@@ -18,12 +18,14 @@ const FORBIDDEN = /[<>:"/\\|?*(){}[\]#~`]/g;
 export function sanitizeTitle(raw: string): string {
   const clean = raw.replace(FORBIDDEN, "").replace(/\s+/g, " ").trim();
   const capped = clean.slice(0, 50).trim();
+
   return capped || "untitled";
 }
 
 /** Title = first H1 of the content, else the fallback, sanitized. */
 export function titleFrom(content: string, fallback?: string): string {
   const h1 = content.match(/^#[ \t]+(.+)$/m)?.[1];
+
   return sanitizeTitle(h1 ?? fallback ?? "untitled");
 }
 
@@ -31,21 +33,29 @@ export function titleFrom(content: string, fallback?: string): string {
  * Render the filename pattern ({YYYY}, {MM}, {DD}, {title}); each whitespace
  * run in the result becomes the configured separator.
  */
-export function formatFilename(format: string, title: string, date: Date, separator: Separator = "space"): string {
-  const pad = (n: number) => String(n).padStart(2, "0");
+export function formatFilename(
+  format: string,
+  title: string,
+  date: Date,
+  separator: Separator = "space",
+): string {
+  const pad = (value: number) => String(value).padStart(2, "0");
   const name = format
     .replaceAll("{YYYY}", String(date.getFullYear()))
     .replaceAll("{MM}", pad(date.getMonth() + 1))
     .replaceAll("{DD}", pad(date.getDate()))
     .replaceAll("{title}", title);
+
   return name.replace(/\s+/g, SEPARATOR_CHAR[separator]);
 }
 
 /** First free path for base.md in dir: base.md, base 2.md, base 3.md, ... */
 export function uniquePath(dir: string, base: string): string {
   let candidate = join(dir, `${base}.md`);
+
   for (let n = 2; existsSync(candidate); n++) {
     candidate = join(dir, `${base} ${n}.md`);
   }
+
   return candidate;
 }

package/src/frontmatter.ts

@@ -1,14 +1,14 @@
 /** Frontmatter for exported notes: provenance the vault can query. */
 
-import type { ReviewSession } from "@cueloop/schema";
+import type { Thread } from "@cueloop/schema";
 
-export function frontmatter(session: ReviewSession, created: Date): string {
+export function frontmatter(session: Thread, created: Date): string {
   return [
     "---",
     `created: ${created.toISOString()}`,
     "source: cueloop",
     `session: ${session.id}`,
-    `verdict: ${session.verdict?.kind ?? "pending"}`,
+    `message: ${session.message?.outcome ?? "pending"}`,
     "---",
   ].join("\n");
 }