@cueloop/integration-obsidian 0.1.0-alpha.3 → 0.1.0-alpha.30

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@cueloop/integration-obsidian",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.30",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.3",
-    "@cueloop/schema": "0.1.0-alpha.3"
+    "@cueloop/extension-api": "0.1.0-alpha.30",
+    "@cueloop/schema": "0.1.0-alpha.30"
   },
   "publishConfig": {
     "access": "public"
@@ -24,5 +24,10 @@
     "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,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/detect.ts

@@ -26,8 +26,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

@@ -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"));
   });
 });

package/src/filename.ts

@@ -32,7 +32,7 @@ export function titleFrom(content: string, fallback?: string): string {
  * 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");
+  const pad = (value: number) => String(value).padStart(2, "0");
   const name = format
     .replaceAll("{YYYY}", String(date.getFullYear()))
     .replaceAll("{MM}", pad(date.getMonth() + 1))