refactor(navigation): robust traversal logic and CI stability (#200)

- Fix getDateFromURI regression by using direct string prefix removal
  for base path stripping, avoiding collisions with timestamps.
- Add explicit 'date' property to Input model to eliminate brittle
  relative-offset math in navigation commands.
- Preserve active scope in Reader.loadEntryForInput.
- Standardize default weekly file pattern to 'week_${week}.${ext}'.
- Harden test mocks and integration suites for CI reliability.

Closes #200

Author: pajoma

src/actions/navigation.ts

@@ -211,6 +211,7 @@ export async function getAdjacentWeekInput(
         [direction === 'previous' ? 'subtract' : 'add'](1, 'week');
     const input = new Input();
     input.week = adj.week();
+    input.scope = weekInfo.scope;
     return input;
 }
 

src/actions/reader.ts

@@ -39,10 +39,10 @@ export class Reader {
     public async loadEntryForInput(input: J.Model.Input): Promise<vscode.TextDocument> {
 
         if (input.hasOffset()) {
-            return this.loadEntryForDay(input.generateDate());
+            return this.loadEntryForDay(input.generateDate(), input.scope);
         }
         if (input.hasWeek()) {
-            return this.loadEntryForWeek(input.week);
+            return this.loadEntryForWeek(input.week, input.scope);
         }
         throw Error("Neither offset nor week are defined in input, we abort.");
 
@@ -53,12 +53,12 @@ export class Reader {
      * Loads the weekly page for the given week number (of the year)
      * @param week the week of the current year
      */
-    public async loadEntryForWeek(week: Number): Promise<vscode.TextDocument> {
+    public async loadEntryForWeek(week: Number, scope?: string): Promise<vscode.TextDocument> {
         this.ctrl.logger.trace("Entering loadEntryForWeek() in actions/reader.ts for week " + week);
 
         const [pathname, filename] = await Promise.all([
-            this.ctrl.config.getWeekPathPattern(week),
-            this.ctrl.config.getWeekFilePattern(week),
+            this.ctrl.config.getWeekPathPattern(week, scope),
+            this.ctrl.config.getWeekFilePattern(week, scope),
         ]);
         const path = J.Util.resolvePath(pathname.value!, filename.value!);
 
@@ -78,15 +78,15 @@ export class Reader {
      * @returns {Promise<vscode.TextDocument>} the document
      * @memberof Reader
      */
-    public async loadEntryForDay(date: Date): Promise<vscode.TextDocument> {
+    public async loadEntryForDay(date: Date, scope?: string): Promise<vscode.TextDocument> {
         if (J.Util.isNullOrUndefined(date) || date!.toString().includes("Invalid")) {
             throw new Error("Invalid date");
         }
         this.ctrl.logger.trace("Entering loadEntryforDate() in actions/reader.ts for date " + date.toISOString());
 
         const [pathname, filename] = await Promise.all([
-            this.ctrl.config.getResolvedEntryPath(date),
-            this.ctrl.config.getEntryFilePattern(date),
+            this.ctrl.config.getResolvedEntryPath(date, scope),
+            this.ctrl.config.getEntryFilePattern(date, scope),
         ]);
         const path = J.Util.resolvePath(pathname.value!, filename.value!);
 

src/ext/conf.ts

@@ -62,7 +62,7 @@ const defaultPatternDefinition: PatternDefinition =
     },
     weeks: {
         path: "${base}/${year}",
-        file: "w${week}.${ext}"
+        file: "week_${week}.${ext}"
     },
     weeklyNotes: {
         path: "${base}/${year}/w${week}",

src/model/input.ts

@@ -30,6 +30,7 @@ export class Input {
     private _text: string = ""; 
     private _scope: string = ""; 
     private _week: number; 
+    private _date: Date | undefined;
 
     private _tags: string[] = []; 
 
@@ -77,6 +78,13 @@ export class Input {
 		return this._scope;
 	}
 
+    /**
+     * Getter date
+     */
+    public get date(): Date | undefined {
+        return this._date;
+    }
+
     /**
      * Setter offset
      * @param {number } value
@@ -113,6 +121,13 @@ export class Input {
 		this._scope = value;
     }
 
+    /**
+     * Setter date
+     */
+    public set date(value: Date | undefined) {
+        this._date = value;
+    }
+
     /**
      * Return the week of year
      */
@@ -138,7 +153,7 @@ export class Input {
     }
 
     public hasOffset(): boolean {
-        return !isNaN(this.offset) && this._week === -1;  
+        return (this.date !== undefined) || (!isNaN(this.offset) && this._week === -1);  
     }
 
     public hasTask(): boolean {
@@ -151,6 +166,9 @@ export class Input {
 	}
 
     public generateDate(): Date {
+        if (this.date) {
+            return this.date;
+        }
         let date = new Date();
         date.setDate(date.getDate() + this.offset);
         return date; 

src/provider/commands/open-next-entry.ts

@@ -37,7 +37,8 @@ export class OpenNextEntryCommand extends AbstractLoadEntryForDateCommand {
             return;
         }
         const input = new J.Model.Input();
-        input.offset = daysBetween(new Date(), target);
+        input.date = target;
+        input.scope = anchor.scope;
         await this.execute(input);
     }
 }

src/provider/commands/open-previous-entry.ts

@@ -37,7 +37,8 @@ export class OpenPreviousEntryCommand extends AbstractLoadEntryForDateCommand {
             return;
         }
         const input = new J.Model.Input();
-        input.offset = daysBetween(new Date(), target);
+        input.date = target;
+        input.scope = anchor.scope;
         await this.execute(input);
     }
 }

src/test/suite/command-test-helpers.ts

@@ -30,7 +30,17 @@ export function createMockCtrl(overrides: Partial<MockCtrl> = {}): MockCtrl {
             getTimeStringTemplate: async () => ({ value: '12:34' } as J.Model.ScopedTemplate),
             getTaskInlineTemplate: async () => ({ value: '- [ ] ${input}' } as J.Model.InlineTemplate),
             getBasePath: () => '/tmp/journal-tests',
-            getBasePathForLocalOpen: () => '/tmp/journal-tests'
+            getBasePathForLocalOpen: () => '/tmp/journal-tests',
+            getFileExtension: () => 'md',
+            getScopes: () => ['default'],
+            getWeeksPathPatternRaw: () => '${base}/${year}',
+            getWeeksFilePatternRaw: () => 'week_${week}.${ext}',
+            getWeeklySyncConfig: () => ({ enabled: true, anchor: '## Daily Entries', template: '- [${weekday}](${link})', sortOrder: 'ascending' }),
+            getResolvedEntryPath: async () => ({ value: '/tmp/journal-tests/2026/05' }),
+            getEntryFilePattern: async () => ({ value: '17.md' }),
+            getResolvedEntryPathForLocalOpen: async () => ({ value: '/tmp/journal-tests/2026/05' }),
+            getWeekFilePattern: async () => ({ value: 'week_20.md' }),
+            getWeekPathPatternForLocalOpen: async () => ({ value: '/tmp/journal-tests/2026' })
         },
         parser: {
             parseInput: async (input: string) => {

src/test/suite/commands-entry.test.ts

@@ -170,6 +170,7 @@ suite('Command suites - entry commands', () => {
                     getBasePathForLocalOpen: () => 'C:\\Users\\patrick.maue\\Git\\journal',
                     getResolvedEntryPath: async (_date: Date) => ({ value: 'C:\\Users\\patrick.maue\\Git\\journal\\2026\\02' }),
                     getEntryFilePattern: async (_date: Date) => ({ value: '2026-02-17.md' }),
+                    getResolvedEntryPathForLocalOpen: async (_date: Date) => ({ value: 'C:\\Users\\patrick.maue\\Git\\journal\\2026\\02' }),
                     isWindowsStyleBaseConfigured: () => true
                 },
                 reader: {

src/test/suite/commands-prev-next.test.ts

@@ -397,7 +397,7 @@ suite('Issue #144 — Open Previous / Open Next navigation', () => {
         async function seedWeeklyFile(base: string, year: number, week: number): Promise<string> {
             const yearDir = vscode.Uri.file(path.join(base, String(year).padStart(4, '0')));
             await vscode.workspace.fs.createDirectory(yearDir);
-            const file = vscode.Uri.file(path.join(base, String(year).padStart(4, '0'), `w${week}.md`));
+            const file = vscode.Uri.file(path.join(base, String(year).padStart(4, '0'), `week_${week}.md`));
             await vscode.workspace.fs.writeFile(file, new TextEncoder().encode(`# Week ${week}\n`));
             return file.fsPath;
         }

src/util/paths.ts

@@ -52,35 +52,36 @@ export async function getDateFromURI(uri: string, pathTemplate: string, fileTemp
     if (fileTemplate.indexOf(".") > 0) { fileTemplate = fileTemplate.substring(0, fileTemplate.lastIndexOf(".")); }
     if (pathTemplate.startsWith("${base}/")) { pathTemplate = pathTemplate.substring("${base}/".length); }
 
-    // go through each element in path and assign it to a date part or skip it
-    let pathParts = uri.split("/");
-
-    // check if part is in base path (if yes, we ignore)
-    // for the rest: last part is file, everything else path pattern
-    let pathElements: string[] = [];
-    let trimmedPathString: string = "";
-    let trimmedFileString = "";
-
-    pathParts.forEach((element, index) => {
-        if (element.trim().length === 0) { return; }
-        else if (element.startsWith("file:")) { return; }
-        else if (basePath.search(element) >= 0) { return; }
-        else if (index + 1 === pathParts.length) { trimmedFileString = element.substr(0, element.lastIndexOf(".")); }
-        else {
-            pathElements.concat(element);
-            if (trimmedPathString.length > 1) { trimmedPathString += "/"; }
-            trimmedPathString += element;
-        }
-    });
+    // Normalize paths to use forward slashes and ensure absolute path for URI
+    const normalizedUri = uri.replace(/\\/g, '/');
+    const normalizedBase = basePath.replace(/\\/g, '/');
+
+    // Strip the base path prefix from the URI
+    let relativePath = normalizedUri;
+    if (normalizedUri.startsWith(normalizedBase)) {
+        relativePath = normalizedUri.substring(normalizedBase.length).replace(/^\/+/, '');
+    } else if (normalizedUri.includes('://')) {
+        // Handle URI schemes (file:///...)
+        try {
+            const uriObj = vscode.Uri.parse(normalizedUri);
+            const fsPath = uriObj.fsPath.replace(/\\/g, '/');
+            if (fsPath.startsWith(normalizedBase)) {
+                relativePath = fsPath.substring(normalizedBase.length).replace(/^\/+/, '');
+            }
+        } catch { /* fallback to path split */ }
+    }
 
+    const pathParts = relativePath.split('/');
+    const trimmedFileString = pathParts.length > 0 ? pathParts[pathParts.length - 1].split('.')[0] : "";
+    const trimmedPathString = pathParts.length > 1 ? pathParts.slice(0, -1).join('/') : "";
 
     const entryDateFormat = replaceDateTemplatesWithMomentsFormats(fileTemplate);
     const pathDateFormat = replaceDateTemplatesWithMomentsFormats(pathTemplate);
 
     let parsedDateFromFile = moment(trimmedFileString, entryDateFormat);
     let parsedDateFromPath = moment(trimmedPathString, pathDateFormat);
 
-    let result = moment();
+    let result = moment().startOf('day');
 
     // consolidate the two
     if (fileTemplate.indexOf("${year}") >= 0) { result = result.year(parsedDateFromFile.year()); }