Unify logging. Rename / merge edge cases

Author: gbro3n

TECHNICAL.md

@@ -1310,7 +1310,15 @@ Diagnostic logging is provided by `LogService` (`src/LogService.ts`), a pure Nod
 
 **Log format:** `[ISO timestamp] [LEVEL] tag: message`
 
-**Usage in services:** `LogService` is injected as an optional constructor parameter (defaulting to `NO_OP_LOGGER`) into `IndexService`, `IndexScanner`, `WikilinkDecorationManager`, and `WikilinkCompletionProvider`. The `extension.ts` module also uses the instance directly for lifecycle logging. A `NO_OP_LOGGER` singleton is used when logging is disabled, avoiding null checks throughout the codebase.
+**Usage in services:** `LogService` is injected as an optional constructor parameter (defaulting to `NO_OP_LOGGER`) into `IndexService`, `IndexScanner`, `WikilinkDecorationManager`, `WikilinkCompletionProvider`, and other logger-aware services. The `extension.ts` module also uses the instance directly for lifecycle logging. A `NO_OP_LOGGER` singleton is used when logging is disabled, avoiding null checks throughout the codebase.
+
+For modules that are not constructed with an injected logger (for example some inline-editor / Mermaid helpers), `LogService.ts` also exposes a shared active logger:
+
+- `setActiveLogger(logger)` — called by `extension.ts` when logging is configured
+- `getActiveLogger()` — returns the current active logger, or `NO_OP_LOGGER` when logging is off
+- `formatLogError(error)` — normalises unknown exceptions into a string for logger output
+
+This allows the extension to avoid naked `console.log/warn/error` calls while still keeping all diagnostic output behind the same logging gate.
 
 **Timer API:** `logService.time(tag, label)` returns a closure that, when called, logs the elapsed milliseconds at INFO level — used for performance instrumentation throughout the decoration and completion pipelines.
 
@@ -1647,6 +1655,21 @@ For explorer renames, the old broad `staleScan()` follow-up has been replaced wi
 
 `updateLinksInWorkspace()` no longer auto-saves affected open editors after applying workspace edits. Instead, both the in-editor and explorer rename flows now use `reindexWorkspaceUri(...)`: if an affected file is currently open, it is re-indexed from the live editor buffer via `indexFileContent(...)`; otherwise it falls back to `indexScanner.indexFile(...)`. `WikilinkRenameTracker` still re-indexes the initiating document from `document.getText()` when its URI is stable, and remaps any old source candidate URI to the post-rename or post-merge target before follow-up indexing. Combined with the direct-to-disk rewrite path for closed files, this avoids save conflicts on both open reference files and files that were previously closed, as well as attempts to reopen a source file that has just been renamed or deleted.
 
+### Filename-level wikilink refactors
+
+Rename propagation now also updates filenames that contain the renamed wikilink text itself, not just file contents. The shared planner in `WikilinkFilenameRefactorService.ts` scans indexed pages for filenames containing `[[oldPageName]]` and computes additional file operations such as:
+
+1. `Topic [[Plant]].md` -> `Topic [[Tree]].md`
+2. merge into an existing `Topic [[Tree]].md` when that target already exists
+
+The planner is reused by both `WikilinkRenameTracker.ts` and `WikilinkExplorerRenameRefactorService.ts`, so in-editor renames and explorer renames follow the same rules. It provides three guarantees:
+
+1. **Consistent rename/merge classification** - filename collisions become merges instead of failing midway.
+2. **Safe ordering** - chained filename renames are topologically ordered so a rename that frees a target path can run before a dependent rename that needs that path.
+3. **URI remapping for follow-up work** - candidate files selected for link rewrites or re-indexing are remapped through the filename operations so later content edits and index refreshes use the final file locations.
+
+This keeps filename refactors, content refactors, and index updates in sync even when nested wikilinks appear inside page filenames.
+
 ### Re-entrancy guard
 
 The `isProcessing` flag prevents document-change events fired by the rename operation itself (file renames, workspace edits) from being treated as new user edits. It is set to `true` before any rename work begins and cleared in the `finally` block.

vs-code-extension/src/BacklinkPanelProvider.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { IndexService, type BacklinkChainGroup, type BacklinkChainInstance, type PageRow } from './IndexService.js';
-import type { LogService } from './LogService.js';
+import { getActiveLogger, formatLogError, type LogService } from './LogService.js';
 import * as path from 'path';
 import { toNotesRelativePath } from './NotesRootService.js';
 
@@ -463,7 +463,7 @@ export class BacklinkPanelProvider implements vscode.Disposable {
                 vscode.TextEditorRevealType.InCenter,
             );
         } catch (err) {
-            console.warn('as-notes: failed to navigate to backlink:', err);
+            (this.logger ?? getActiveLogger()).warn('BacklinkPanel', `failed to navigate to backlink: ${formatLogError(err)}`);
         }
     }
 

vs-code-extension/src/IgnoreService.ts

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import ignore, { type Ignore } from 'ignore';
+import { formatLogError, getActiveLogger } from './LogService.js';
 
 /**
  * Reads and parses an `.asnotesignore` file (`.gitignore` syntax) and exposes
@@ -48,7 +49,7 @@ export class IgnoreService {
             const content = fs.readFileSync(this.ignoreFilePath, 'utf-8');
             instance.add(content);
         } catch (err) {
-            console.warn(`as-notes: could not read ${this.ignoreFilePath}:`, err);
+            getActiveLogger().warn('IgnoreService', `could not read ${this.ignoreFilePath}: ${formatLogError(err)}`);
         }
         return instance;
     }

vs-code-extension/src/IndexScanner.ts

@@ -2,7 +2,7 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import { IndexService, type ScanSummary } from './IndexService.js';
 import { IgnoreService } from './IgnoreService.js';
-import { LogService, NO_OP_LOGGER } from './LogService.js';
+import { LogService, NO_OP_LOGGER, formatLogError } from './LogService.js';
 import { toNotesRelativePath } from './NotesRootService.js';
 
 /**
@@ -108,7 +108,7 @@ export class IndexScanner {
                     this.logger.info('IndexScanner', `fullScan: progress ${filesIndexed}/${total} files`);
                 }
             } catch (err) {
-                console.warn(`as-notes: failed to index ${relativePath}:`, err);
+                this.logger.warn('IndexScanner', `failed to index ${relativePath}: ${formatLogError(err)}`);
             }
         }
 
@@ -186,7 +186,7 @@ export class IndexScanner {
                     summary.unchanged++;
                 }
             } catch (err) {
-                console.warn(`as-notes: failed to scan ${relativePath}:`, err);
+                this.logger.warn('IndexScanner', `failed to scan ${relativePath}: ${formatLogError(err)}`);
             }
 
             processed++;

vs-code-extension/src/LogService.ts

@@ -154,3 +154,17 @@ export class LogService {
  * Avoids null checks throughout the codebase — callers always have a LogService.
  */
 export const NO_OP_LOGGER = new LogService('', { enabled: false });
+
+let activeLogger: LogService = NO_OP_LOGGER;
+
+export function setActiveLogger(logger: LogService): void {
+    activeLogger = logger;
+}
+
+export function getActiveLogger(): LogService {
+    return activeLogger;
+}
+
+export function formatLogError(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}

vs-code-extension/src/TaskPanelProvider.ts

@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import { IndexService, type TaskViewItem } from './IndexService.js';
+import { formatLogError, getActiveLogger } from './LogService.js';
 import { toggleTodoLine } from './TodoToggleService.js';
 
 // ── Provider ───────────────────────────────────────────────────────────────
@@ -88,7 +89,7 @@ export class TaskPanelProvider implements vscode.WebviewViewProvider {
                     edit.replace(doc.uri, doc.lineAt(line).range, toggled);
                     return vscode.workspace.applyEdit(edit).then(() => doc.save());
                 }).then(undefined, err => {
-                    console.warn('as-notes: failed to toggle task from panel:', err);
+                    getActiveLogger().warn('TaskPanel', `failed to toggle task from panel: ${formatLogError(err)}`);
                 });
                 break;
             }

vs-code-extension/src/WikilinkExplorerRenameRefactorService.ts

@@ -10,6 +10,10 @@ import {
 import { toNotesRelativePath } from './NotesRootService.js';
 import { reindexWorkspaceUri, updateLinksInWorkspace } from './WikilinkRefactorService.js';
 import { withWikilinkRenameProgress } from './WikilinkRenameProgressService.js';
+import {
+    collectFilenameRefactorOperations,
+    remapUrisForFileOperations,
+} from './WikilinkFilenameRefactorService.js';
 
 interface ExplorerRenameFile {
     oldUri: vscode.Uri;
@@ -20,7 +24,7 @@ interface ExplorerRenameRefactorDeps {
     files: ExplorerRenameFile[];
     renameTrackerIsRenaming: boolean;
     wikilinkService: WikilinkService;
-    indexService: Pick<IndexService, 'findPagesByFilename' | 'removePage' | 'findPagesLinkingToPageNames' | 'indexFileContent'>;
+    indexService: Pick<IndexService, 'findPagesByFilename' | 'removePage' | 'findPagesLinkingToPageNames' | 'indexFileContent' | 'getAllPages'>;
     indexScanner: Pick<IndexScanner, 'staleScan' | 'indexFile'>;
     notesRootPath?: string;
     safeSaveToFile: () => boolean;
@@ -124,26 +128,72 @@ export async function handleExplorerRenameRefactors({
     const summary = linkRenames
         .map(r => `[[${r.oldPageName}]] → [[${r.newPageName}]]`)
         .join(', ');
+    const rootUri = notesRootPath
+        ? vscode.Uri.file(notesRootPath)
+        : vscode.workspace.workspaceFolders?.[0]?.uri;
+    const filenameRefactorPlan = rootUri && indexService.getAllPages
+        ? collectFilenameRefactorOperations(
+            linkRenames,
+            indexService.getAllPages(),
+            rootUri,
+            {
+                excludePaths: files.map(file => {
+                    const uri = file.newUri;
+                    return notesRootPath
+                        ? toNotesRelativePath(notesRootPath, uri.fsPath)
+                        : vscode.workspace.asRelativePath(uri, false);
+                }),
+            },
+        )
+        : { fileRenames: [], fileMerges: [] };
+    const extraFilenameChanges = filenameRefactorPlan.fileRenames.length + filenameRefactorPlan.fileMerges.length;
     const msg = linkRenames.length === 1
-        ? `Update all ${summary} references?`
-        : `Update references for ${linkRenames.length} renamed files? ${summary}`;
+        ? `Update all ${summary} references?${extraFilenameChanges > 0 ? ` Also update ${extraFilenameChanges} filename reference(s).` : ''}`
+        : `Update references for ${linkRenames.length} renamed files? ${summary}${extraFilenameChanges > 0 ? ` Also update ${extraFilenameChanges} filename reference(s).` : ''}`;
     const choice = await vscode.window.showInformationMessage(msg, 'Yes', 'No');
     if (choice !== 'Yes') { return; }
 
     await withWikilinkRenameProgress('AS Notes: Updating wikilink references', async (progress) => {
-        const rootUri = notesRootPath
-            ? vscode.Uri.file(notesRootPath)
-            : vscode.workspace.workspaceFolders?.[0]?.uri;
         const candidateUris = rootUri
             ? indexService.findPagesLinkingToPageNames(linkRenames.map(rename => rename.oldPageName))
                 .map(page => vscode.Uri.joinPath(rootUri, page.path))
             : [];
 
+        progress.report('Preparing rename operations');
+        for (const merge of filenameRefactorPlan.fileMerges) {
+            const sourceDoc = await vscode.workspace.openTextDocument(merge.oldUri);
+            const targetDoc = await vscode.workspace.openTextDocument(merge.newUri);
+
+            const mergedContent = new FrontMatterService().mergeDocuments(
+                targetDoc.getText(),
+                sourceDoc.getText(),
+            );
+
+            const edit = new vscode.WorkspaceEdit();
+            const fullRange = new vscode.Range(
+                targetDoc.lineAt(0).range.start,
+                targetDoc.lineAt(targetDoc.lineCount - 1).range.end,
+            );
+            edit.replace(merge.newUri, fullRange, mergedContent);
+            await vscode.workspace.applyEdit(edit);
+            await vscode.workspace.fs.delete(merge.oldUri);
+        }
+
+        for (const rename of filenameRefactorPlan.fileRenames) {
+            await vscode.workspace.fs.rename(rename.oldUri, rename.newUri, { overwrite: false });
+        }
+
+        const rewriteCandidateUris = remapUrisForFileOperations(
+            candidateUris,
+            filenameRefactorPlan.fileRenames,
+            filenameRefactorPlan.fileMerges,
+        );
+
         progress.report('Updating links across workspace');
         const affectedUris = await updateLinksInWorkspace(
             wikilinkService,
             linkRenames,
-            candidateUris.length > 0 ? { candidateUris } : undefined,
+            rewriteCandidateUris.length > 0 ? { candidateUris: rewriteCandidateUris } : undefined,
         );
 
         progress.report('Refreshing index');
@@ -156,6 +206,32 @@ export async function handleExplorerRenameRefactors({
                 });
             } catch { /* best effort */ }
         }
+        for (const merge of filenameRefactorPlan.fileMerges) {
+            const oldPath = notesRootPath
+                ? toNotesRelativePath(notesRootPath, merge.oldUri.fsPath)
+                : vscode.workspace.asRelativePath(merge.oldUri, false);
+            indexService.removePage(oldPath);
+            try {
+                await reindexWorkspaceUri(merge.newUri, {
+                    indexService,
+                    indexScanner,
+                    notesRootPath,
+                });
+            } catch { /* best effort */ }
+        }
+        for (const rename of filenameRefactorPlan.fileRenames) {
+            const oldPath = notesRootPath
+                ? toNotesRelativePath(notesRootPath, rename.oldUri.fsPath)
+                : vscode.workspace.asRelativePath(rename.oldUri, false);
+            indexService.removePage(oldPath);
+            try {
+                await reindexWorkspaceUri(rename.newUri, {
+                    indexService,
+                    indexScanner,
+                    notesRootPath,
+                });
+            } catch { /* best effort */ }
+        }
         if (safeSaveToFile()) {
             refreshProviders();
         }