Merge pull request #203 from pajoma/refactor/200-week-nav-dedup

refactor(navigation): extract getAdjacentWeekInput — closes #200

Author: pajoma

src/actions/navigation.ts

@@ -21,7 +21,9 @@ import * as vscode from 'vscode';
 import * as Path from 'path';
 import { Ctrl } from '../util/controller';
 import { SCOPE_DEFAULT, ScopeDefinitionLite } from '../ext/conf';
-import { getDateFromURIAndConfig } from '../util/paths';
+import { getDateFromURIAndConfig, getWeekFromURIAndConfig } from '../util/paths';
+import { Input } from '../model';
+import moment = require("moment");
 
 /** Direction of entry navigation — step backward or forward relative to the anchor. */
 export type Direction = 'previous' | 'next';
@@ -189,6 +191,30 @@ async function readDirSafe(uri: vscode.Uri): Promise<[string, vscode.FileType][]
     }
 }
 
+/**
+ * When the active editor contains a weekly note, returns an `Input` with `week` set to the
+ * adjacent week number (direction `'next'` adds one week, `'previous'` subtracts one).
+ * Returns `undefined` when the editor is absent or the file is not a weekly note — callers
+ * should fall through to daily-entry navigation.
+ */
+export async function getAdjacentWeekInput(
+    editor: vscode.TextEditor | undefined,
+    ctrl: Ctrl,
+    direction: Direction,
+): Promise<Input | undefined> {
+    if (!editor) { return undefined; }
+    const weekInfo = await getWeekFromURIAndConfig(editor.document.uri, ctrl.config);
+    if (!weekInfo) { return undefined; }
+    const adj = moment()
+        .week(weekInfo.week)
+        .weekYear(weekInfo.year)
+        [direction === 'previous' ? 'subtract' : 'add'](1, 'week');
+    const input = new Input();
+    input.week = adj.week();
+    input.scope = weekInfo.scope;
+    return input;
+}
+
 function escapeRegex(s: string): string {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

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

@@ -12,7 +12,7 @@
 import * as vscode from 'vscode';
 import * as J from '../..';
 import { AbstractLoadEntryForDateCommand } from './show-entry-for-date';
-import { daysBetween, findAdjacentEntry, resolveAnchor, Mode } from '../../actions/navigation';
+import { daysBetween, findAdjacentEntry, getAdjacentWeekInput, resolveAnchor, Mode } from '../../actions/navigation';
 
 export class OpenNextEntryCommand extends AbstractLoadEntryForDateCommand {
     title: string = "Open the next journal entry";
@@ -25,15 +25,20 @@ export class OpenNextEntryCommand extends AbstractLoadEntryForDateCommand {
     }
 
     public async run(): Promise<void> {
+        const editor = vscode.window.activeTextEditor;
+        const weekInput = await getAdjacentWeekInput(editor, this.ctrl, 'next');
+        if (weekInput) { await this.execute(weekInput); return; }
+
         const mode: Mode = this.ctrl.config.getNavigationMode();
-        const anchor = await resolveAnchor(this.ctrl, vscode.window.activeTextEditor);
+        const anchor = await resolveAnchor(this.ctrl, editor);
         const target = await findAdjacentEntry(this.ctrl, anchor, 'next', mode);
         if (target === null) {
             await vscode.window.showInformationMessage(vscode.l10n.t("No later journal entry found."));
             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

@@ -12,7 +12,7 @@
 import * as vscode from 'vscode';
 import * as J from '../..';
 import { AbstractLoadEntryForDateCommand } from './show-entry-for-date';
-import { daysBetween, findAdjacentEntry, resolveAnchor, Mode } from '../../actions/navigation';
+import { daysBetween, findAdjacentEntry, getAdjacentWeekInput, resolveAnchor, Mode } from '../../actions/navigation';
 
 export class OpenPreviousEntryCommand extends AbstractLoadEntryForDateCommand {
     title: string = "Open the previous journal entry";
@@ -25,15 +25,20 @@ export class OpenPreviousEntryCommand extends AbstractLoadEntryForDateCommand {
     }
 
     public async run(): Promise<void> {
+        const editor = vscode.window.activeTextEditor;
+        const weekInput = await getAdjacentWeekInput(editor, this.ctrl, 'previous');
+        if (weekInput) { await this.execute(weekInput); return; }
+
         const mode: Mode = this.ctrl.config.getNavigationMode();
-        const anchor = await resolveAnchor(this.ctrl, vscode.window.activeTextEditor);
+        const anchor = await resolveAnchor(this.ctrl, editor);
         const target = await findAdjacentEntry(this.ctrl, anchor, 'previous', mode);
         if (target === null) {
             await vscode.window.showInformationMessage(vscode.l10n.t("No earlier journal entry found."));
             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

@@ -8,6 +8,7 @@ import {
     addDays,
     daysBetween,
     findAdjacentEntry,
+    getAdjacentWeekInput,
     resolveAnchor,
     stripTime,
 } from '../../actions/navigation';
@@ -29,7 +30,14 @@ async function seedEntry(base: string, year: number, month: number, day: number,
 async function buildCtrl(tmpBase: string): Promise<{ ctrl: J.Util.Ctrl; logger: TestLogger }> {
     const config = vscode.workspace.getConfiguration('journal');
     await config.update('base', tmpBase, vscode.ConfigurationTarget.Workspace);
-    const refreshed = vscode.workspace.getConfiguration('journal');
+    // On CI the config write is async; poll until the value is visible.
+    const deadline = Date.now() + 3000;
+    let refreshed: vscode.WorkspaceConfiguration;
+    do {
+        refreshed = vscode.workspace.getConfiguration('journal');
+        if (refreshed.get<string>('base') === tmpBase) { break; }
+        await new Promise<void>(r => setTimeout(r, 50));
+    } while (Date.now() < deadline);
     const ctrl = new J.Util.Ctrl(refreshed);
     const logger = new TestLogger(false);
     ctrl.logger = logger;
@@ -365,4 +373,65 @@ suite('Issue #144 — Open Previous / Open Next navigation', () => {
             assert.ok(prev === null || prev === undefined, `expected null at start of history, got ${prev}`);
         });
     });
+
+    suite('getAdjacentWeekInput (#200)', () => {
+        let originalBase: string | undefined;
+        let tmpBase: string;
+        let ctrl: J.Util.Ctrl;
+
+        setup(async () => {
+            const config = vscode.workspace.getConfiguration('journal');
+            originalBase = config.get<string>('base');
+            tmpBase = path.join(os.tmpdir(), `issue200-week-${Date.now()}`);
+            await vscode.workspace.fs.createDirectory(vscode.Uri.file(tmpBase));
+            ({ ctrl } = await buildCtrl(tmpBase));
+        });
+
+        teardown(async () => {
+            const config = vscode.workspace.getConfiguration('journal');
+            await config.update('base', originalBase, vscode.ConfigurationTarget.Workspace);
+            try { await vscode.workspace.fs.delete(vscode.Uri.file(tmpBase), { recursive: true }); } catch { /* ignore */ }
+            await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+        });
+
+        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'), `week_${week}.md`));
+            await vscode.workspace.fs.writeFile(file, new TextEncoder().encode(`# Week ${week}\n`));
+            return file.fsPath;
+        }
+
+        test('T1: editor=undefined returns undefined', async () => {
+            const result = await getAdjacentWeekInput(undefined, ctrl, 'next');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('T2: non-weekly day file returns undefined', async () => {
+            const dayPath = await seedEntry(tmpBase, 2026, 5, 16);
+            const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(dayPath));
+            const editor = await vscode.window.showTextDocument(doc);
+            const result = await getAdjacentWeekInput(editor, ctrl, 'next');
+            assert.strictEqual(result, undefined);
+        });
+
+        test('T3: weekly file + direction next → week+1', async () => {
+            const weeklyPath = await seedWeeklyFile(tmpBase, 2026, 20);
+            const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(weeklyPath));
+            const editor = await vscode.window.showTextDocument(doc);
+            const diag = `tmpBase=${tmpBase} base=${ctrl.config.getBasePath()} weeksPat=${ctrl.config.getWeeksFilePatternRaw()} uri=${editor.document.uri.fsPath}`;
+            const result = await getAdjacentWeekInput(editor, ctrl, 'next');
+            assert.ok(result, `expected an Input back [${diag}]`);
+            assert.strictEqual(result!.week, 21);
+        });
+
+        test('T4: weekly file + direction previous → week-1', async () => {
+            const weeklyPath = await seedWeeklyFile(tmpBase, 2026, 20);
+            const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(weeklyPath));
+            const editor = await vscode.window.showTextDocument(doc);
+            const result = await getAdjacentWeekInput(editor, ctrl, 'previous');
+            assert.ok(result, 'expected an Input back');
+            assert.strictEqual(result!.week, 19);
+        });
+    });
 });

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