Merge pull request #222 from pajoma/fix/221-attachement-typo

fix(model): rename JournalPageType.attachement → attachment (#221)

Author: pajoma

docs/plans/2026-05-18-199-infer-type-context-object.md

@@ -0,0 +1,99 @@
+# Plan: Decouple inferType from Raw Positional Arguments (#199)
+
+## Reference spec
+[docs/specs/2026-05-18-199-infer-type-context-object.md](../specs/2026-05-18-199-infer-type-context-object.md)
+
+## Approach
+
+Introduce `InferTypeContext` in `src/journal/paths.ts` (colocated with `inferType` — approved in spec review). Change the function signature from `(entry, extension: string)` to `(entry, ctx: InferTypeContext)`. Update both call sites in `scan-entries.ts`. No logic changes — pure structural refactor.
+
+Trade-off: keeping the interface in `paths.ts` rather than `src/model/interfaces.ts` maximises local cohesion at the cost of discoverability. Correct per YAGNI until a second consumer appears.
+
+**Amendment (post-review):** Unit tests must be written against existing behavior before touching the signature, to lock down the contract empirically. All future fields in `InferTypeContext` must be optional (`?:`) — required fields would reintroduce shotgun surgery on every addition. The `|` literal in the existing regex (`/^[\d|\-|_]+$/`) is a pre-existing quirk (pipes illegal in Windows filenames, unused on Unix); it is documented in the test but not fixed in this PR.
+
+## Steps
+
+### 0 — Write unit tests for current `inferType` behavior (`src/test/suite/infer-type.test.ts`)
+
+`inferType` has no VS Code dependencies — safe to run inside Extension Host suite without special plumbing. Lock down all three classification branches before touching the signature:
+
+- attachment: extension mismatch → `JournalPageType.attachment`
+- entry: `extension` matches AND name matches `/^[\d|\-|_]+$/` → `JournalPageType.entry`
+- note: `extension` matches AND name is alphanumeric → `JournalPageType.note`
+
+Include a test that confirms the current (pre-fix) behavior of `2026|05|18.md` → `entry`, so the regex fix in Step 0b is verifiable.
+
+### 0b — Fix regex in `inferType` (`src/journal/paths.ts`)
+
+Separate commit. Change `/^[\d|\-|_]+$/gm` → `/^[\d\-_]+$/`:
+
+- Remove `|` literal from character class (was unintentionally included; pipe is valid on macOS/Linux)
+- Remove `gm` flags (unnecessary for a single filename string match)
+
+No classification semantics change for real-world filenames. Update the test from Step 0 to reflect corrected behavior: `2026|05|18.md` → `JournalPageType.note` after fix.
+
+### 1 — Add `InferTypeContext` and update `inferType` (`src/journal/paths.ts`)
+
+Define the interface immediately above the function:
+
+```typescript
+export interface InferTypeContext {
+    extension: string;
+    // all future fields must be optional (?: ) to prevent shotgun surgery
+}
+```
+
+Change signature:
+
+```typescript
+export function inferType(entry: Path.ParsedPath, ctx: InferTypeContext): J.Model.JournalPageType
+```
+
+Replace `extension` references inside the body with `ctx.extension`.
+
+### 2 — Update call sites (`src/features/entries/scan-entries.ts`)
+
+Two occurrences (lines 68 and 140 at time of writing):
+
+```typescript
+// before
+entry.type = J.Journal.inferType(Path.parse(entry.path), this.config.getFileExtension());
+// after
+entry.type = J.Journal.inferType(Path.parse(entry.path), { extension: this.config.getFileExtension() });
+```
+
+### 3 — Verify compile
+
+```bash
+npm run compile          # esbuild — extension bundle
+npm run compile-tests    # tsc — catches type errors in tests
+```
+
+### 4 — Run tests
+
+```bash
+npm test
+```
+
+All existing tests plus the new unit tests must pass.
+
+## Test scenarios
+
+- **Compile clean:** `npm run compile` and `npm run compile-tests` both exit 0, no TS errors
+- **Regression — attachment:** file with non-matching extension → `JournalPageType.attachment`
+- **Regression — entry:** matching extension + digits/dashes/underscores name → `JournalPageType.entry`
+- **Regression — note:** matching extension + alphanumeric name → `JournalPageType.note`
+- **Regex fix verified:** `2026|05|18.md` → `JournalPageType.note` after Step 0b (pipe no longer in character class)
+- **Extensibility proof:** adding `weeklyFilePattern?: string` to `InferTypeContext` requires touching only `paths.ts`
+
+## Dependencies
+
+None. Self-contained structural change; no other open PR touches `inferType` or its call sites.
+
+## Risk
+
+Low. Pure signature refactor — no logic change, no new code paths. Covered entirely by the existing test suite plus compile checks.
+
+## Rollback
+
+`git revert <commit>` — single commit, no data or config side effects.

docs/plans/2026-05-18-221-fix-attachement-typo.md

@@ -0,0 +1,65 @@
+---
+issue: 221
+slug: fix-attachement-typo
+date: 2026-05-18
+status: plan
+spec: docs/specs/2026-05-18-221-fix-attachement-typo.md
+---
+
+# Plan: Fix `attachement` typo — enum, method, and all consumers
+
+## Approach
+
+Single-commit rename across all affected files. Pure text substitution — no logic changes, no behaviour change. TypeScript compiler enforces completeness: any missed reference fails to compile. One commit keeps `git bisect` attribution clean.
+
+## Steps
+
+1. **Rename enum member** in `src/model/config.ts:4`  
+   `attachement` → `attachment`  
+   Foundation; compiler immediately flags all unresolved consumers.
+
+2. **Fix enum consumers** in `src/journal/paths.ts`, `src/vscode/dialogues.ts`  
+   `JournalPageType.attachement` → `JournalPageType.attachment` at all 5 sites.
+
+3. **Rename method + fix log strings** in `src/features/sync/sync-note-links.ts`  
+   Method signature line 21, log strings lines 22/36/41: `injectAttachementLinks` → `injectAttachmentLinks`.
+
+4. **Fix call site** in `src/vscode/startup.ts:101`  
+   `injectAttachementLinks` → `injectAttachmentLinks`.
+
+5. **Fix comments** in `src/features/entries/scan-entries.ts:57,92`  
+   Inline comment spelling only — no logic change.
+
+6. **Fix plan prose** in `docs/plans/2026-05-18-199-infer-type-context-object.md:20,83`  
+   Prevents copy-paste regression in future tasks.
+
+7. **Verify** — `tsc --noEmit` must pass; `grep -rn "attachement" src/` must return zero hits.
+
+8. **Commit + PR** — single commit, PR description links issue, spec, and plan.
+
+## Test Scenarios
+
+| Scenario | Type | Coverage |
+|----------|------|----------|
+| Compilation succeeds with zero TS errors | compile-time | Proves all enum and method references resolved |
+| `grep -rn "attachement" src/` returns zero hits | static analysis | Proves no remaining typo in source |
+| Existing unit tests pass unchanged | unit | Proves no behavioural regression (tests in active worktrees will assert `attachment` after rebase) |
+
+No new tests needed — this is a pure rename with no logic change.
+
+## Dependencies
+
+None. Self-contained rename; no other PRs must land first.
+
+## Risk
+
+- **Worktrees diverge temporarily** — worktrees `feat+199`, `feat+209`, `feat+210`, `feat+211` each reference `attachement`. They must rebase on develop after this lands. Low risk: compiler will surface conflicts immediately on rebase.
+- **Missed occurrence** — mitigated by grep verification step before commit.
+
+## Rollback
+
+`git revert <commit>` — pure rename reverts cleanly with zero side-effects.
+
+## Reference Spec
+
+[docs/specs/2026-05-18-221-fix-attachement-typo.md](../specs/2026-05-18-221-fix-attachement-typo.md)

docs/specs/2026-05-18-199-infer-type-context-object.md

@@ -0,0 +1,63 @@
+# Spec: Decouple inferType from Raw Positional Arguments (#199)
+
+## Goal
+
+Change `inferType` in `src/journal/paths.ts` to accept a context object instead of positional raw-value arguments, so future parameter additions don't require shotgun surgery across call sites.
+
+## Why Now
+
+A prior change (adding `weeklyFilePatternRaw`) forced updates to every call site of `inferType` — two in `scan-entries.ts` and the function itself in `paths.ts`. The function is a stable utility but its positional signature makes it rigid: each new classification criterion forces a signature change and cascading edits. A context object breaks that coupling.
+
+## In Scope
+
+- Introduce `InferTypeContext` interface in `src/journal/paths.ts` (or `src/model/interfaces.ts` if it becomes a shared type — see open questions)
+- Change `inferType` signature from `(entry: Path.ParsedPath, extension: string)` to `(entry: Path.ParsedPath, ctx: InferTypeContext)`
+- Update both call sites in `src/features/entries/scan-entries.ts` to pass `{ extension: this.config.getFileExtension() }`
+- Update `src/journal/index.ts` re-export if the interface is defined there
+
+## Out of Scope
+
+- Adding new classification logic (e.g. weekly-note detection via pattern) — that is a follow-up
+- Changing `JournalPageType` enum members
+- Any changes to `getWeekFromURIAndConfig` or `getDateFromURIAndConfig`
+
+## Acceptance Criteria
+
+- `inferType` signature takes `(entry: Path.ParsedPath, ctx: InferTypeContext)` where `InferTypeContext` has at minimum `{ extension: string }`
+- Both call sites in `scan-entries.ts` compile and pass `ctx` as an object literal
+- `npm run compile` and `npm run compile-tests` succeed (no type errors)
+- `npm test` passes (all existing tests green)
+- Adding a future field to `InferTypeContext` requires touching only `paths.ts` and the struct definition — not the call sites (verified by design)
+
+## Entities / Contracts
+
+```typescript
+// src/journal/paths.ts (or src/model/interfaces.ts)
+export interface InferTypeContext {
+    extension: string;
+    // future fields: weeklyFilePattern?: string, etc.
+}
+
+// updated signature
+export function inferType(entry: Path.ParsedPath, ctx: InferTypeContext): J.Model.JournalPageType
+```
+
+Call site (no change to call-site logic):
+```typescript
+// scan-entries.ts — both occurrences
+entry.type = J.Journal.inferType(Path.parse(entry.path), { extension: this.config.getFileExtension() });
+```
+
+## Constraints
+
+- `InferTypeContext` must have zero `vscode` imports — `paths.ts` is domain code
+- Keep interface definition in `src/journal/paths.ts` unless a second consumer in a different module also needs it; move to `src/model/interfaces.ts` only when that second consumer appears (YAGNI)
+
+## Open Questions
+
+- Should `InferTypeContext` live in `src/journal/paths.ts` or `src/model/interfaces.ts`? Recommend `paths.ts` until a second consumer exists.
+- Is there a planned follow-up to add weekly detection inside `inferType`? If so, the `weeklyFilePattern?: string` field should be stubbed in the interface now to validate the design.
+
+## Related Issues
+
+- Part of the ongoing domain-layer decoupling work (cf. #209, #212)

docs/specs/2026-05-18-221-fix-attachement-typo.md

@@ -0,0 +1,58 @@
+---
+issue: 221
+slug: fix-attachement-typo
+date: 2026-05-18
+status: spec
+---
+
+# Spec: Fix `attachement` typo — enum, method, and all consumers
+
+## Goal
+
+Eliminate every occurrence of the misspelled token `attachement` across enum member, method name, log strings, comments, and documentation prose.
+
+## Why Now
+
+Identified during review of #199/#220. The typo spans the core domain model enum AND a public method (`injectAttachementLinks`). Fixing now — before more consumers land — minimises blast radius. All current sites are known and enumerable.
+
+## In Scope
+
+Rename in main-branch source files only (worktrees are ephemeral and will rebase on develop):
+
+| File | Lines | Change |
+|------|-------|--------|
+| `src/model/config.ts` | 4 | Enum member: `attachement` → `attachment` |
+| `src/journal/paths.ts` | 179 | Return value + inline comment |
+| `src/features/entries/scan-entries.ts` | 57, 92 | Comments only |
+| `src/vscode/dialogues.ts` | 129, 130, 460 | Three enum references |
+| `src/features/sync/sync-note-links.ts` | 21, 22, 36, 41 | Method rename + log strings: `injectAttachementLinks` → `injectAttachmentLinks` |
+| `src/vscode/startup.ts` | 101 | Call site: `injectAttachementLinks` → `injectAttachmentLinks` |
+| `docs/plans/2026-05-18-199-infer-type-context-object.md` | 20, 83 | Plan prose mentions |
+
+Test files on active branches (updated by their branch on rebase):
+- `feat+199-infer-type-context-object`: `src/test/suite/infer-type.test.ts:10,12,15,17`
+
+## Out of Scope
+
+- Other worktrees — they rebase or merge develop after this lands
+- Runtime / serialised data (the enum is not persisted to disk or config files by value; used purely in-process)
+- No config schema changes required
+
+## Acceptance Criteria
+
+1. `grep -rn "attachement" src/` returns zero hits (excluding worktrees)
+2. TypeScript compilation succeeds (`npm run compile` or `tsc --noEmit`)
+3. All existing tests pass
+
+## Constraints
+
+- Enum member rename is a pure rename — no behavioural change
+- Must stay on a single commit for clean `git bisect` attribution
+
+## Open Questions
+
+None.
+
+## Related
+
+- Identified during: #199, #220

src/features/entries/scan-entries.ts

@@ -54,7 +54,7 @@ export class ScanEntries {
         }
 
         // go into base directory, find all files changed within the last X days (see config)
-        // for each file, check if it is an entry, a note or an attachement
+        // for each file, check if it is an entry, a note or an attachment
         for (const directory of directories) {
             try {
                 await this.fs.stat(directory.path);
@@ -89,7 +89,7 @@ export class ScanEntries {
     public async getPreviouslyAccessedFiles(thresholdInMs: number, callback: Function, picker: any, type: J.Model.JournalPageType, directories: Set<J.Model.ScopeDirectory>): Promise<void> {
 
         // go into base directory, find all files changed within the last 40 days
-        // for each file, check if it is an entry, a note or an attachement
+        // for each file, check if it is an entry, a note or an attachment
 
 
         this.logger.trace("Entering getPreviouslyAccessedFiles() in actions/reader.ts and number of directories to scan: ", directories.size);

src/features/sync/sync-note-links.ts

@@ -18,8 +18,8 @@ export class SyncNoteLinks {
     *
     * @param doc
     */
-    public async injectAttachementLinks(doc: vscode.TextDocument, date: Date): Promise<vscode.TextDocument> {
-        this.ctrl.logger.trace("Entering injectAttachementLinks() in features/sync-note-links for date: ", date);
+    public async injectAttachmentLinks(doc: vscode.TextDocument, date: Date): Promise<vscode.TextDocument> {
+        this.ctrl.logger.trace("Entering injectAttachmentLinks() in features/sync-note-links for date: ", date);
 
         try {
             await this.ctrl.ui.saveDocument(doc);
@@ -33,12 +33,12 @@ export class SyncNoteLinks {
             const promises: Promise<J.Model.InlineString>[] = foundFiles
                 .filter(file => J.Util.isNullOrUndefined(referencedFiles.find(match => match.fsPath === file.fsPath)))
                 .map(file => {
-                    this.ctrl.logger.debug("injectAttachementLinks() - File link not present in entry: ", file);
+                    this.ctrl.logger.debug("injectAttachmentLinks() - File link not present in entry: ", file);
                     return this.buildReference(doc, file);
                 });
 
             const inlineStrings = await Promise.all(promises);
-            this.ctrl.logger.trace("injectAttachementLinks() - Number of references to synchronize: ", inlineStrings.length);
+            this.ctrl.logger.trace("injectAttachmentLinks() - Number of references to synchronize: ", inlineStrings.length);
 
             if (inlineStrings.length > 0) {
                 this.ctrl.inject.injectInlineString(inlineStrings[0], ...inlineStrings.splice(1))

src/journal/paths.ts

@@ -176,7 +176,7 @@ export interface InferTypeContext {
 export function inferType(entry: Path.ParsedPath, ctx: InferTypeContext): J.Model.JournalPageType {
 
     if (!entry.ext.endsWith(ctx.extension)) {
-        return J.Model.JournalPageType.attachement;
+        return J.Model.JournalPageType.attachment;
     } else if (entry.name.match(/^[\d\-_]+$/)) {
         return J.Model.JournalPageType.entry;
     } else {

src/model/config.ts

@@ -1,7 +1,7 @@
 export enum JournalPageType {
     note,
     entry,
-    attachement
+    attachment
 }
 
 export interface ScopedTemplate {

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

@@ -7,14 +7,14 @@ suite('inferType — classification', () => {
     const ctx: InferTypeContext = { extension: '.md' };
 
     suite('attachment', () => {
-        test('extension mismatch → attachement', () => {
+        test('extension mismatch → attachment', () => {
             const entry = Path.parse('/base/2026/05/2026-05-18.txt');
-            assert.strictEqual(inferType(entry, ctx), JournalPageType.attachement);
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.attachment);
         });
 
-        test('no extension → attachement', () => {
+        test('no extension → attachment', () => {
             const entry = Path.parse('/base/2026/05/2026-05-18');
-            assert.strictEqual(inferType(entry, ctx), JournalPageType.attachement);
+            assert.strictEqual(inferType(entry, ctx), JournalPageType.attachment);
         });
     });
 

src/vscode/dialogues.ts

@@ -126,8 +126,8 @@ export class Dialogues {
                         this.pickItem(JournalPageType.note).then(selected => {
                             resolve(selected);
                         });
-                    } else if (isNotNullOrUndefined(selected.pickItem) && selected.pickItem === JournalPageType.attachement) {
-                        this.pickItem(JournalPageType.attachement).then(selected => {
+                    } else if (isNotNullOrUndefined(selected.pickItem) && selected.pickItem === JournalPageType.attachment) {
+                        this.pickItem(JournalPageType.attachment).then(selected => {
                             resolve(selected);
                         });
                     } else {
@@ -457,7 +457,7 @@ function addItemToPickList(entries: FileEntry[], input: TimedQuickPick, type: Jo
                 else { displayName = `$(circle-large-filled) ${displayName}`; break; }
             }
             case JournalPageType.entry: displayName = `$(clock) ${displayName}`; break;
-            case JournalPageType.attachement: displayName = `$(package) ${displayName}`; break;
+            case JournalPageType.attachment: displayName = `$(package) ${displayName}`; break;
         }