@cueloop/integration-obsidian 0.1.0-alpha.21 → 0.1.0-alpha.22

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@cueloop/integration-obsidian",
-  "version": "0.1.0-alpha.21",
+  "version": "0.1.0-alpha.22",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.21",
-    "@cueloop/schema": "0.1.0-alpha.21"
+    "@cueloop/extension-api": "0.1.0-alpha.22",
+    "@cueloop/schema": "0.1.0-alpha.22"
   },
   "publishConfig": {
     "access": "public"

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]);
   });
 

package/src/export.test.ts

@@ -44,8 +44,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 +62,63 @@ describe("exportSession", () => {
   });
 
   test("the working copy wins over the submitted content", () => {
+    // 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");
+
+    // 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 } } }));
+
+    // 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 +126,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/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);
   });
@@ -54,10 +57,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"));
   });
 });