Rename refactoring working with expensive full scan

Author: gbro3n

TECHNICAL.md

@@ -1088,7 +1088,7 @@ The `sortText` prefix ensures pages always appear before aliases in the list. Bo
 
 **Front matter suppression:** `isLineInsideFrontMatter()` checks whether the cursor is between the first two `---` lines. If so, no completions are returned — front matter aliases are plain strings, not wikilinks.
 
-All four pure functions — `findInnermostOpenBracket()`, `findMatchingCloseBracket()`, `isLineInsideFrontMatter()`, and `isPositionInsideCode()` — live in `CompletionUtils.ts` with no VS Code dependency, and are fully unit-tested.
+All five pure functions — `findInnermostOpenBracket()`, `findMatchingCloseBracket()`, `isLineInsideFrontMatter()`, `isPositionInsideCode()`, and `hasNewCompleteWikilink()` — live in `CompletionUtils.ts` with no VS Code dependency, and are fully unit-tested.
 
 **Code block detection:** `isPositionInsideCode(lines, lineIndex, charIndex)` scans lines 0 through `lineIndex` tracking fenced code block open/close state (supports both `` ` `` and `~` fences, respects fence length — a closing fence must use the same character and at least as many markers as the opener). If a fence is still open at `lineIndex`, the position is inside a code block. Separately checks inline code spans (`` ` ``) on the target line.
 
@@ -1097,7 +1097,7 @@ All four pure functions — `findInnermostOpenBracket()`, `findMatchingCloseBrac
 The provider maintains a cached array of `CompletionItem[]` objects. The cache is rebuilt **eagerly** whenever `refresh()` is called — there is no dirty flag or lazy rebuild.
 
 - **Eager rebuild:** `refresh()` calls `rebuildCache()` immediately, running three SQLite queries (`getAllPages`, `getAllAliases`, `getForwardReferencedPages`) and building lightweight plain data objects (not `CompletionItem` instances). This happens at index-update time (file save, create, delete, rename, periodic scan, rebuild), not at `[[` keystroke time.
-- **Not called on text-change debounce:** The 500 ms `onDidChangeTextDocument` debounce handler does **not** call `completionProvider.refresh()`. This eliminates three SQLite queries on every typing pause. Forward references appear in autocomplete after the next file save.
+- **Selective text-change refresh:** The 500 ms `onDidChangeTextDocument` debounce handler re-indexes the live buffer and calls `completionProvider.refresh()` **only when** `hasNewCompleteWikilink()` detects that the current document now contains at least one newly added complete wikilink compared to the page's last indexed links. This makes new forward references available without save while avoiding the refresh cost on ordinary typing edits.
 - **Warm on activation:** `enterFullMode()` calls `completionProvider.refresh()` immediately after construction (post stale-scan), so the cache is warm before the user types the first `[[`.
 - **Not called on editor switch:** The `onDidChangeActiveTextEditor` handler does **not** call `completionProvider.refresh()`. Completion data is global (all pages, aliases, forward refs) and is unaffected by which tab is focused. This avoids 3 SQLite queries on every tab switch.
 - **Hot path:** `provideCompletionItems()` never touches the database. It builds `CompletionItem` instances from lightweight cached data objects with the per-call replacement range and returns them inside a `CompletionList`.
@@ -1128,11 +1128,11 @@ The listener only fires on deletions (where `rangeLength > 0` and `text` is empt
 When the user types inside a wikilink, two things happen on every keystroke:
 
 1. `WikilinkRenameTracker.onDocumentChanged` — records `pendingEdit` (the outermost wikilink position the cursor is inside). This edit state is cleared and rename detection runs when the cursor exits the wikilink.
-2. The 500 ms `onDidChangeTextDocument` debounce in `extension.ts` — re-indexes the live buffer into the in-memory DB so that newly typed forward references appear in autocomplete immediately.
+2. The 500 ms `onDidChangeTextDocument` debounce in `extension.ts` — re-indexes the live buffer into the in-memory DB and selectively refreshes autocomplete when a newly added complete wikilink is detected.
 
 These two behaviours interact at the index: rename detection (`checkForRenames`) works by comparing the **current DB state** (the last-indexed link positions and names) against the live document. If the debounce fires and re-indexes the document before the cursor exits the wikilink, the DB is updated to reflect the edited name. When `checkForRenames` later runs after cursor exit, it compares the edited name in the DB against the same name in the live document — no difference is detected, and the rename dialog is never shown.
 
-**Guard:** The debounce callback in `extension.ts` checks `renameTracker.hasPendingEdit(doc.uri.toString())` before calling `indexFileContent`. If a pending edit is active for that document, the re-index is skipped for that tick. `WikilinkRenameTracker` exposes:
+**Guard:** The debounce callback in `extension.ts` checks `renameTracker.hasPendingEdit(doc.uri.toString())` before calling `indexFileContent` or refreshing completion. If a pending edit is active for that document, the re-index is skipped for that tick. `WikilinkRenameTracker` exposes:
 
 ```typescript
 hasPendingEdit(docKey: string): boolean
@@ -1594,6 +1594,16 @@ If `resolveAlias(oldPageName)` returns the same page whose filename is `oldPageN
 
 `updateLinksInWorkspace()` finds all `.md` and `.markdown` files, parses each for wikilinks, and creates a `WorkspaceEdit` that replaces every `[[oldPageName]]` with `[[newPageName]]`. After applying the edit, it saves modified files.
 
+**Notification progress:**
+
+Accepted in-editor rename operations are wrapped in `withWikilinkRenameProgress()` (`WikilinkRenameProgressService.ts`), which shows a non-cancellable VS Code notification while the slow path runs. The tracker reports three coarse phases:
+
+1. `Preparing rename operations`
+2. `Updating links across workspace`
+3. `Refreshing index`
+
+The progress notification is only shown after the user confirms the rename or merge. Declined or dismissed prompts remain a no-op aside from the existing decline re-index path.
+
 ### Post-rename index refresh
 
 After a rename operation completes, `refreshIndexAfterRename()` ensures the index is consistent before releasing control:
@@ -1618,6 +1628,12 @@ After the renamed file is indexed at its new path, AS Notes checks for filename
 
 This selection logic is isolated in `WikilinkExplorerMergeService.ts` so the ambiguity rules are unit-tested independently of the large `extension.ts` event handler.
 
+The user-confirmed refactor work that follows explorer renames is now extracted into `WikilinkExplorerRenameRefactorService.ts`. That helper applies the same notification UX as in-editor renames:
+
+1. Accepted merge operations show `AS Notes: Applying rename updates` while the merge, delete, and target re-index complete.
+2. Accepted workspace-wide reference updates show `AS Notes: Updating wikilink references` while link replacement and stale-scan refresh complete.
+3. Declined explorer prompts do not show progress notifications.
+
 ### 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/CompletionUtils.ts

@@ -1,8 +1,14 @@
+import type { IWikilinkService } from 'as-notes-common';
+
 /**
  * Pure utility functions for wikilink completion logic.
  * No VS Code dependencies — safe for unit testing.
  */
 
+interface IndexedLinkLike {
+    page_name: string;
+}
+
 /**
  * Find the column of the innermost unclosed `[[` in the text up to the cursor.
  * Returns -1 if no valid `[[` trigger is found.
@@ -147,3 +153,38 @@ export function isPositionInsideCode(lines: string[], lineIndex: number, charInd
 
     return false;
 }
+
+/**
+ * Determine whether the current document contains at least one newly added
+ * complete wikilink compared to the page's last indexed links.
+ *
+ * This uses page-name occurrence counts rather than positions so that plain
+ * text edits that shift existing links do not count as new links, while added
+ * duplicate links and nested links are still detected.
+ */
+export function hasNewCompleteWikilink(
+    lines: string[],
+    indexedLinks: IndexedLinkLike[],
+    wikilinkService: IWikilinkService,
+): boolean {
+    const indexedCounts = new Map<string, number>();
+    for (const link of indexedLinks) {
+        indexedCounts.set(link.page_name, (indexedCounts.get(link.page_name) ?? 0) + 1);
+    }
+
+    const currentCounts = new Map<string, number>();
+    for (const line of lines) {
+        const wikilinks = wikilinkService.extractWikilinks(line, false, false);
+        for (const wikilink of wikilinks) {
+            currentCounts.set(wikilink.pageName, (currentCounts.get(wikilink.pageName) ?? 0) + 1);
+        }
+    }
+
+    for (const [pageName, count] of currentCounts) {
+        if (count > (indexedCounts.get(pageName) ?? 0)) {
+            return true;
+        }
+    }
+
+    return false;
+}

vs-code-extension/src/WikilinkExplorerRenameRefactorService.ts

@@ -0,0 +1,142 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { FrontMatterService, WikilinkService } from 'as-notes-common';
+import type { IndexScanner } from './IndexScanner.js';
+import type { IndexService } from './IndexService.js';
+import {
+    getExistingExplorerMergeTargets,
+    pickUniqueExplorerMergeTarget,
+} from './WikilinkExplorerMergeService.js';
+import { toNotesRelativePath } from './NotesRootService.js';
+import { updateLinksInWorkspace } from './WikilinkRefactorService.js';
+import { withWikilinkRenameProgress } from './WikilinkRenameProgressService.js';
+
+interface ExplorerRenameFile {
+    oldUri: vscode.Uri;
+    newUri: vscode.Uri;
+}
+
+interface ExplorerRenameRefactorDeps {
+    files: ExplorerRenameFile[];
+    renameTrackerIsRenaming: boolean;
+    wikilinkService: WikilinkService;
+    indexService: Pick<IndexService, 'findPagesByFilename' | 'removePage'>;
+    indexScanner: Pick<IndexScanner, 'staleScan' | 'indexFile'>;
+    notesRootPath?: string;
+    safeSaveToFile: () => boolean;
+    refreshProviders: () => void;
+}
+
+function isMarkdownUri(uri: vscode.Uri): boolean {
+    const ext = path.extname(uri.fsPath).toLowerCase();
+    return ext === '.md' || ext === '.markdown';
+}
+
+export async function handleExplorerRenameRefactors({
+    files,
+    renameTrackerIsRenaming,
+    wikilinkService,
+    indexService,
+    indexScanner,
+    notesRootPath,
+    safeSaveToFile,
+    refreshProviders,
+}: ExplorerRenameRefactorDeps): Promise<void> {
+    if (renameTrackerIsRenaming) { return; }
+
+    const linkRenames: { oldPageName: string; newPageName: string }[] = [];
+
+    for (const { oldUri, newUri } of files) {
+        if (!isMarkdownUri(newUri)) { continue; }
+        const newFilename = path.basename(newUri.fsPath);
+        const pages = indexService.findPagesByFilename(newFilename);
+        if (pages.length < 2) { continue; }
+
+        const newPath = notesRootPath
+            ? toNotesRelativePath(notesRootPath, newUri.fsPath)
+            : vscode.workspace.asRelativePath(newUri, false);
+        const existingTargets = getExistingExplorerMergeTargets(pages, newPath);
+        if (existingTargets.length === 0) { continue; }
+        if (existingTargets.length > 1) {
+            vscode.window.showWarningMessage(
+                `Merge skipped for "${newFilename}": multiple existing targets match this filename.`,
+            );
+            continue;
+        }
+
+        const existingPage = pickUniqueExplorerMergeTarget(pages, newPath);
+        if (!existingPage) { continue; }
+
+        const rootUri = notesRootPath
+            ? vscode.Uri.file(notesRootPath)
+            : vscode.workspace.workspaceFolders?.[0]?.uri;
+        if (!rootUri) { continue; }
+
+        const mergeChoice = await vscode.window.showInformationMessage(
+            `Merge "${newFilename}" into existing "${existingPage.path}"?`,
+            'Yes', 'No',
+        );
+        if (mergeChoice === 'Yes') {
+            await withWikilinkRenameProgress('AS Notes: Applying rename updates', async (progress) => {
+                progress.report('Merging renamed page');
+                const targetUri = vscode.Uri.joinPath(rootUri, existingPage.path);
+                const sourceDoc = await vscode.workspace.openTextDocument(newUri);
+                const targetDoc = await vscode.workspace.openTextDocument(targetUri);
+
+                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(targetUri, fullRange, mergedContent);
+                await vscode.workspace.applyEdit(edit);
+                await targetDoc.save();
+
+                progress.report('Refreshing index');
+                await vscode.workspace.fs.delete(newUri);
+                indexService.removePage(newPath);
+                try { await indexScanner.indexFile(targetUri); } catch { /* best effort */ }
+                safeSaveToFile();
+            });
+        }
+    }
+
+    for (const { oldUri, newUri } of files) {
+        if (isMarkdownUri(oldUri) && isMarkdownUri(newUri)) {
+            const oldExt = path.extname(oldUri.fsPath);
+            const newExt = path.extname(newUri.fsPath);
+            const oldPageName = path.basename(oldUri.fsPath, oldExt);
+            const newPageName = path.basename(newUri.fsPath, newExt);
+            if (oldPageName !== newPageName) {
+                linkRenames.push({ oldPageName, newPageName });
+            }
+        }
+    }
+
+    if (linkRenames.length === 0) { return; }
+
+    const summary = linkRenames
+        .map(r => `[[${r.oldPageName}]] → [[${r.newPageName}]]`)
+        .join(', ');
+    const msg = linkRenames.length === 1
+        ? `Update all ${summary} references?`
+        : `Update references for ${linkRenames.length} renamed files? ${summary}`;
+    const choice = await vscode.window.showInformationMessage(msg, 'Yes', 'No');
+    if (choice !== 'Yes') { return; }
+
+    await withWikilinkRenameProgress('AS Notes: Updating wikilink references', async (progress) => {
+        progress.report('Updating links across workspace');
+        await updateLinksInWorkspace(wikilinkService, linkRenames);
+
+        progress.report('Refreshing index');
+        try { await indexScanner.staleScan(); } catch { /* best effort */ }
+        if (safeSaveToFile()) {
+            refreshProviders();
+        }
+    });
+}

vs-code-extension/src/WikilinkRenameProgressService.ts

@@ -0,0 +1,23 @@
+import * as vscode from 'vscode';
+
+export interface RenameProgressReporter {
+    report(message: string): void;
+}
+
+export async function withWikilinkRenameProgress<T>(
+    title: string,
+    task: (progress: RenameProgressReporter) => Promise<T>,
+): Promise<T> {
+    return vscode.window.withProgress(
+        {
+            location: vscode.ProgressLocation.Notification,
+            title,
+            cancellable: false,
+        },
+        async (progress) => task({
+            report(message: string) {
+                progress.report({ message });
+            },
+        }),
+    );
+}

vs-code-extension/src/WikilinkRenameTracker.ts

@@ -7,6 +7,7 @@ import { sanitiseFileName } from './PathUtils.js';
 import { FrontMatterService } from 'as-notes-common';
 import { toNotesRelativePath } from './NotesRootService.js';
 import { updateLinksInWorkspace } from './WikilinkRefactorService.js';
+import { withWikilinkRenameProgress } from './WikilinkRenameProgressService.js';
 
 /**
  * Detected rename: a wikilink at the same position now has a different pageName.
@@ -465,35 +466,39 @@ export class WikilinkRenameTracker implements vscode.Disposable {
 
         this.isProcessing = true;
         try {
-            // Process file merges (target already exists — merge content)
-            for (const fm of fileMerges) {
-                await this.mergeFiles(fm.oldUri, fm.newUri);
-            }
+            await withWikilinkRenameProgress('AS Notes: Applying rename updates', async (progress) => {
+                progress.report('Preparing rename operations');
 
-            // Process direct file renames
-            for (const fr of fileRenames) {
-                await vscode.workspace.fs.rename(fr.oldUri, fr.newUri, { overwrite: false });
-            }
+                // Process file merges (target already exists — merge content)
+                for (const fm of fileMerges) {
+                    await this.mergeFiles(fm.oldUri, fm.newUri);
+                }
 
-            // Process alias renames — update front matter on canonical pages
-            for (const r of classifiedRenames) {
-                if (r.isAlias && r.canonicalPagePath) {
-                    await this.updateAliasFrontMatter(
-                        r.canonicalPagePath,
-                        r.oldPageName,
-                        r.newPageName,
-                    );
+                // Process direct file renames
+                for (const fr of fileRenames) {
+                    await vscode.workspace.fs.rename(fr.oldUri, fr.newUri, { overwrite: false });
                 }
-            }
 
-            // Update links across the workspace (outermost first)
-            await updateLinksInWorkspace(
-                this.wikilinkService,
-                renames.map(r => ({ oldPageName: r.oldPageName, newPageName: r.newPageName })),
-            );
+                // Process alias renames — update front matter on canonical pages
+                for (const r of classifiedRenames) {
+                    if (r.isAlias && r.canonicalPagePath) {
+                        await this.updateAliasFrontMatter(
+                            r.canonicalPagePath,
+                            r.oldPageName,
+                            r.newPageName,
+                        );
+                    }
+                }
+
+                progress.report('Updating links across workspace');
+                await updateLinksInWorkspace(
+                    this.wikilinkService,
+                    renames.map(r => ({ oldPageName: r.oldPageName, newPageName: r.newPageName })),
+                );
 
-            // Refresh the index
-            await this.refreshIndexAfterRename(document, classifiedRenames, fileRenames);
+                progress.report('Refreshing index');
+                await this.refreshIndexAfterRename(document, classifiedRenames, fileRenames);
+            });
         } catch (err) {
             const detail = err instanceof Error ? err.message : String(err);
             vscode.window.showErrorMessage(`Rename failed: ${detail}`);