@cueloop/integration-obsidian 0.1.0-alpha.4 → 0.1.0-alpha.41

package/package.json

@@ -1,28 +1,33 @@
 {
   "name": "@cueloop/integration-obsidian",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.41",
+  "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.4",
-    "@cueloop/schema": "0.1.0-alpha.4"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "dependencies": {
+    "@cueloop/extension-api": "0.1.0-alpha.41",
+    "@cueloop/schema": "0.1.0-alpha.41"
+  },
   "engines": {
     "bun": ">=1.3.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/mmurakaru/cueloop.git",
-    "directory": "packages/integrations/obsidian"
   }
 }

package/src/detect.test.ts

@@ -15,6 +15,7 @@ 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");
@@ -28,6 +29,8 @@ describe("detectVaults", () => {
         },
       }),
     );
+
+    // Assert
     expect(detectVaults(configPath)).toEqual([alive]);
   });
 
@@ -44,7 +47,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

@@ -14,9 +14,17 @@ 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. */
@@ -26,8 +34,8 @@ export function detectVaults(configPath: string = obsidianConfigPath()): string[
       vaults?: Record<string, { path?: string }>;
     };
     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

@@ -20,7 +20,13 @@ 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() },
     status: "resolved",
@@ -44,8 +50,13 @@ 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");
@@ -57,40 +68,73 @@ describe("exportSession", () => {
   });
 
   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 +142,21 @@ 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);
   });

package/src/export.ts

@@ -43,7 +43,11 @@ export interface ExportResult {
   error?: string;
 }
 
-export function exportSession(session: ReviewSession, config: ObsidianConfig, now: Date = new Date()): ExportResult {
+export function exportSession(
+  session: ReviewSession,
+  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}` };

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,11 +38,15 @@ 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");
   });
 });
@@ -54,10 +61,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

@@ -31,8 +31,13 @@ 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))