Merge pull request #220 from pajoma/worktree-feat+199-infer-type-context-object

refactor(paths): decouple inferType from raw positional args (#199)

Author: pajoma

src/features/entries/scan-entries.ts

@@ -65,7 +65,7 @@ export class ScanEntries {
 
             await this.walkDir(directory.path, thresholdInMs, (entries: J.Model.FileEntry[]) => {
                 entries.forEach(entry => {
-                    entry.type = J.Journal.inferType(Path.parse(entry.path), this.config.getFileExtension());
+                    entry.type = J.Journal.inferType(Path.parse(entry.path), { extension: this.config.getFileExtension() });
                     entry.scope = directory.scope;
                     this.cache.set(entry.path, entry);
                 });
@@ -137,7 +137,7 @@ export class ScanEntries {
 
         await this.walkDir(directory.path, thresholdInMs, (entries: J.Model.FileEntry[]) => {
             entries.forEach(fe => {
-                fe.type = J.Journal.inferType(Path.parse(fe.path), this.config.getFileExtension());
+                fe.type = J.Journal.inferType(Path.parse(fe.path), { extension: this.config.getFileExtension() });
                 fe.scope = directory.scope;
                 if (!this.cache.has(fe.path)) {
                     this.cache.set(fe.path, fe);

src/journal/paths.ts

@@ -168,25 +168,20 @@ export async function checkIfFileIsAccessible(path: string): Promise<void> {
 }
 
 
-/**
- * Tries to infer the file type from the path by matching against the configured patterns
- * @param entry - path to entry
- * @param ext - configured standard extension 
- */
-export function inferType(entry: Path.ParsedPath, extension: string): J.Model.JournalPageType {
-
-    if (!entry.ext.endsWith(extension)) {
-        return J.Model.JournalPageType.attachement; // any attachement
-    } else
-
-        // this is getting out of hand if we need to infer it by scanning the patterns from the settings.
-        // We keep it simple: if the filename contains only digits and special chars, we assume it 
-        // is a journal entry. Everything else is a journal note. 
-        if (entry.name.match(/^[\d|\-|_]+$/gm)) {
-            return J.Model.JournalPageType.entry; // any entry
-        } else {
-            return J.Model.JournalPageType.note; // anything else is a note
-        }
+/** Context passed to inferType. All future fields must be optional (?:) to prevent shotgun surgery. */
+export interface InferTypeContext {
+    extension: string;
+}
+
+export function inferType(entry: Path.ParsedPath, ctx: InferTypeContext): J.Model.JournalPageType {
+
+    if (!entry.ext.endsWith(ctx.extension)) {
+        return J.Model.JournalPageType.attachement;
+    } else if (entry.name.match(/^[\d\-_]+$/)) {
+        return J.Model.JournalPageType.entry;
+    } else {
+        return J.Model.JournalPageType.note;
+    }
 
 
 }

src/test/suite/infer-type.test.ts

@@ -0,0 +1,55 @@
+import * as assert from 'assert';
+import * as Path from 'path';
+import { inferType, InferTypeContext } from '../../journal/paths';
+import { JournalPageType } from '../../model/config';
+
+suite('inferType — classification', () => {
+    const ctx: InferTypeContext = { extension: '.md' };
+
+    suite('attachment', () => {
+        test('extension mismatch → attachement', () => {
+            const entry = Path.parse('/base/2026/05/2026-05-18.txt');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.attachement);
+        });
+
+        test('no extension → attachement', () => {
+            const entry = Path.parse('/base/2026/05/2026-05-18');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.attachement);
+        });
+    });
+
+    suite('entry', () => {
+        test('digits-only name → entry', () => {
+            const entry = Path.parse('/base/2026/05/20260518.md');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.entry);
+        });
+
+        test('digits with hyphens → entry', () => {
+            const entry = Path.parse('/base/2026/05/2026-05-18.md');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.entry);
+        });
+
+        test('digits with underscores → entry', () => {
+            const entry = Path.parse('/base/2026/05/2026_05_18.md');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.entry);
+        });
+
+        test('pipe-separated name → note (pipe not a separator)', () => {
+            // Pipe was previously a literal in the character class; now correctly excluded.
+            const entry = Path.parse('/base/2026/05/2026|05|18.md');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.note);
+        });
+    });
+
+    suite('note', () => {
+        test('alphanumeric name → note', () => {
+            const entry = Path.parse('/base/2026/05/my-note.md');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.note);
+        });
+
+        test('name with letters and digits → note', () => {
+            const entry = Path.parse('/base/2026/05/meeting2026.md');
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.note);
+        });
+    });
+});