Extended folder exclusions for index

Author: gbro3n

README.md

@@ -532,6 +532,7 @@ Update `version` in `package.json` and add an entry to `CHANGELOG.md`.
 **Step 2 - publish to the VS Code Marketplace**
 
 ```bash
+cd .\vs-code-extension\
 npm run build
 npx @vscode/vsce package
 npx @vscode/vsce login appsoftwareltd   # enter PAT token if auth expired
@@ -541,6 +542,7 @@ npx @vscode/vsce publish
 **Step 3 - tag and push**
 
 ```bash
+cd ..
 git add .
 git commit -m "Release v2.3.1"   # change version
 git tag v2.3.1                   # change version

TECHNICAL.md

@@ -257,6 +257,14 @@ reload(): void
 
 Patterns follow `.gitignore` syntax, parsed by the [`ignore`](https://www.npmjs.com/package/ignore) npm package — the standard implementation used by many tools. `IgnoreService` normalises backslash paths to forward slashes on Windows before passing them to `ignore`.
 
+In addition to user-owned `.asnotesignore` content, the extension builds a runtime ignore layer via `createConfiguredIgnoreService()` for mandatory exclusions derived from current configuration. These patterns are added after `.asnotesignore` is loaded so they remain non-optional even if a user adds negation rules.
+
+Mandatory runtime exclusions are:
+
+- `.asnotes/`
+- configured `templateFolder`
+- configured `assetPath`
+
 **`.asnotesignore` lifecycle:**
 
 - Created by `initWorkspace()` at the workspace root (same level as `.asnotes/`) if it does not already exist.
@@ -272,7 +280,7 @@ The create-if-missing logic is centralised in a private `ensureIgnoreFile(worksp
 | `rebuildIndex()` | At the start of every manual rebuild |
 | `startPeriodicScan()` setInterval callback | On every periodic scan tick |
 
-After `ensureIgnoreFile()` is called in `rebuildIndex()` and `startPeriodicScan()`, `ignoreService?.reload()` is called immediately so the in-memory patterns reflect any changes (including recreation after deletion) before the scan proceeds.
+After `ensureIgnoreFile()` is called in `rebuildIndex()` and `startPeriodicScan()`, `ignoreService?.reload()` is called immediately so the in-memory patterns reflect any changes (including recreation after deletion) before the scan proceeds. When `templateFolder` or `assetPath` changes, the extension recreates the configured ignore service and re-runs a stale scan so the mandatory runtime exclusions update immediately without rewriting `.asnotesignore`.
 
 **Integration with IndexScanner:**
 
@@ -2637,7 +2645,17 @@ In `extension.ts`, all index update triggers (`onDidSaveTextDocument`, `onDidCha
 
 A private `isEncryptedFileUri(uri)` helper centralises the `.enc.md` check within `extension.ts`.
 
-**2. `.asnotesignore` patterns (user exclusions)**
+**2. Runtime ignore exclusions**
+
+The index also excludes mandatory runtime directories built from extension configuration:
+
+- `.asnotes/`
+- configured `templateFolder`
+- configured `assetPath`
+
+These are enforced through `IgnoreService` rather than written into `.asnotesignore`, so settings changes take effect immediately and user ignore files remain user-owned.
+
+**3. `.asnotesignore` patterns (user exclusions)**
 
 See [IgnoreService and .asnotesignore](#ignoreservice-and-asnotesignore) in the Persistent index section.
 
@@ -2664,19 +2682,19 @@ AS Notes delegates file drop and paste to VS Code's **built-in** markdown editor
 
 ### Workspace configuration
 
-`applyAssetPathSettings()` in `src/ImageDropProvider.ts` reads `as-notes.assetPath` (default `assets/images`) and writes:
+`applyAssetPathSettings()` in `src/ImageDropProvider.ts` reads `as-notes.assetPath` (default `assets`) and writes:
 
 ```json
 "markdown.copyFiles.destination": {
-    "**/*.md": "assets/images/${fileName}"
+    "**/*.md": "assets/${fileName}"
 }
 ```
 
 to `.vscode/settings.json` at workspace scope. `${fileName}` is a built-in VS Code variable that resolves to the original filename of the dropped/pasted file.
 
 | Setting | Default | Description |
 |---|---|---|
-| `as-notes.assetPath` | `assets/images` | Workspace-relative folder where dropped/pasted files are saved |
+| `as-notes.assetPath` | `assets` | Workspace-relative folder where dropped/pasted files are saved |
 
 **Trigger points** (all in `extension.ts`):
 

vs-code-extension/README.md

@@ -292,7 +292,7 @@
                 },
                 "as-notes.assetPath": {
                     "type": "string",
-                    "default": "assets/images",
+                    "default": "assets",
                     "description": "Folder where dropped or pasted files are saved by VS Code's built-in markdown editor, relative to the AS Notes root directory. AS Notes configures the built-in markdown.copyFiles.destination setting to use this path."
                 },
                 "as-notes.createNotesInCurrentDirectory": {

vs-code-extension/package.json

@@ -2,6 +2,54 @@ import * as fs from 'fs';
 import ignore, { type Ignore } from 'ignore';
 import { formatLogError, getActiveLogger } from './LogService.js';
 
+export interface IgnoreServiceOptions {
+    /**
+     * Additional ignore patterns layered after `.asnotesignore` so they
+     * remain mandatory and cannot be un-ignored by user config.
+     */
+    readonly additionalPatterns?: readonly string[];
+}
+
+export interface RuntimeIgnoreConfig {
+    readonly templateFolder?: string;
+    readonly assetPath?: string;
+}
+
+function normaliseRelativeDirectoryPath(dir?: string): string {
+    return (dir ?? '').trim().replace(/^[/\\]+|[/\\]+$/g, '').replace(/\\/g, '/');
+}
+
+function toDirectoryPattern(dir?: string): string | undefined {
+    const normalised = normaliseRelativeDirectoryPath(dir);
+    return normalised ? `${normalised}/` : undefined;
+}
+
+/**
+ * Runtime exclusions that are part of AS Notes configuration/state rather
+ * than user-owned `.asnotesignore` content.
+ */
+export function buildMandatoryIgnorePatterns(config: RuntimeIgnoreConfig = {}): string[] {
+    const patterns = ['.asnotes/'];
+    const templatePattern = toDirectoryPattern(config.templateFolder);
+    if (templatePattern) {
+        patterns.push(templatePattern);
+    }
+    const assetPattern = toDirectoryPattern(config.assetPath);
+    if (assetPattern) {
+        patterns.push(assetPattern);
+    }
+    return Array.from(new Set(patterns));
+}
+
+export function createConfiguredIgnoreService(
+    ignoreFilePath: string,
+    config: RuntimeIgnoreConfig = {},
+): IgnoreService {
+    return new IgnoreService(ignoreFilePath, {
+        additionalPatterns: buildMandatoryIgnorePatterns(config),
+    });
+}
+
 /**
  * Reads and parses an `.asnotesignore` file (`.gitignore` syntax) and exposes
  * an `isIgnored()` check for use during index scanning.
@@ -10,11 +58,16 @@ import { formatLogError, getActiveLogger } from './LogService.js';
  */
 export class IgnoreService {
     private ig: Ignore;
+    private readonly additionalPatterns: readonly string[];
 
     /**
      * @param ignoreFilePath Absolute path to the `.asnotesignore` file.
      */
-    constructor(private readonly ignoreFilePath: string) {
+    constructor(
+        private readonly ignoreFilePath: string,
+        options: IgnoreServiceOptions = {},
+    ) {
+        this.additionalPatterns = options.additionalPatterns ?? [];
         this.ig = this.load();
     }
 
@@ -43,6 +96,9 @@ export class IgnoreService {
     private load(): Ignore {
         const instance = ignore();
         if (!fs.existsSync(this.ignoreFilePath)) {
+            if (this.additionalPatterns.length > 0) {
+                instance.add(this.additionalPatterns);
+            }
             return instance;
         }
         try {
@@ -51,6 +107,9 @@ export class IgnoreService {
         } catch (err) {
             getActiveLogger().warn('IgnoreService', `could not read ${this.ignoreFilePath}: ${formatLogError(err)}`);
         }
+        if (this.additionalPatterns.length > 0) {
+            instance.add(this.additionalPatterns);
+        }
         return instance;
     }
 }

vs-code-extension/src/IgnoreService.ts

@@ -22,7 +22,7 @@ import * as vscode from 'vscode';
  */
 export async function applyAssetPathSettings(): Promise<void> {
     const config = vscode.workspace.getConfiguration('as-notes');
-    const assetPath = config.get<string>('assetPath', 'assets/images');
+    const assetPath = config.get<string>('assetPath', 'assets');
     const rootDirectory = config.get<string>('rootDirectory', '').trim().replace(/^[/\\]+|[/\\]+$/g, '');
 
     const target = vscode.ConfigurationTarget.Workspace;

vs-code-extension/src/ImageDropProvider.ts

@@ -40,7 +40,7 @@ import { ensurePreCommitHook } from './GitHookService.js';
 import { applyAssetPathSettings } from './ImageDropProvider.js';
 import { LogService, NO_OP_LOGGER, formatLogError, setActiveLogger } from './LogService.js';
 import { findInnermostOpenBracket, hasNewCompleteWikilink } from './CompletionUtils.js';
-import { IgnoreService } from './IgnoreService.js';
+import { IgnoreService, createConfiguredIgnoreService } from './IgnoreService.js';
 import { SlashCommandProvider } from './SlashCommandProvider.js';
 import { openDatePicker } from './DatePickerService.js';
 import { insertTaskDueDate, insertTaskCompletionDate, insertTagAtTaskStart } from './TaskHashtagService.js';
@@ -774,8 +774,7 @@ async function enterFullMode(
         fs.mkdirSync(notesFolderPath, { recursive: true });
     }
 
-    ignoreService = new IgnoreService(nrp.ignoreFilePath);
-    indexScanner = new IndexScanner(indexService, nrUri, ignoreService, logService);
+    refreshIgnoreInfrastructure();
 
     // Shared services — WikilinkService is index-independent, so create early
     const wikilinkService = new WikilinkService();
@@ -2216,17 +2215,7 @@ async function enterFullMode(
     );
     const onIgnoreFileChange = (): void => {
         ignoreService?.reload();
-        indexScanner?.staleScan().then((summary) => {
-            if (summary.newFiles > 0 || summary.staleFiles > 0 || summary.deletedFiles > 0) {
-                indexService?.saveToFile();
-                completionProvider?.refresh();
-                taskPanelProvider?.refresh();
-                searchPanelProvider?.refresh();
-                backlinkPanelProvider?.refresh();
-                calendarPanelProvider?.refresh();
-                updateFullModeStatusBar();
-            }
-        }).catch(err => logService.warn('extension', `stale scan after .asnotesignore change failed: ${formatLogError(err)}`));
+        runStaleScanAfterExclusionRefresh('.asnotesignore change');
     };
     ignoreFileWatcher.onDidChange(onIgnoreFileChange);
     ignoreFileWatcher.onDidCreate(onIgnoreFileChange);
@@ -2245,6 +2234,10 @@ async function enterFullMode(
                     logService.warn('extension', `failed to apply asset path settings on config change: ${formatLogError(err)}`),
                 );
             }
+            if (e.affectsConfiguration('as-notes.assetPath') || e.affectsConfiguration('as-notes.templateFolder')) {
+                refreshIgnoreInfrastructure();
+                runStaleScanAfterExclusionRefresh('runtime exclusion config change');
+            }
             if (e.affectsConfiguration('as-notes.rootDirectory')) {
                 vscode.window.showWarningMessage(
                     'AS Notes: The root directory setting has changed. Reload the window to apply the new root.',
@@ -2477,7 +2470,7 @@ async function initWorkspace(context: vscode.ExtensionContext): Promise<void> {
             indexService = new IndexService(nrp.databasePath, logService);
             await indexService.initDatabase();
 
-            const initIgnoreService = new IgnoreService(nrp.ignoreFilePath);
+            const initIgnoreService = createRuntimeIgnoreService(nrp.ignoreFilePath);
             indexScanner = new IndexScanner(indexService, nrUri, initIgnoreService, logService);
 
             const result = await indexScanner.fullScan(progress);
@@ -2942,6 +2935,37 @@ function ensureIgnoreFile(notesRootFsPath: string): void {
     }
 }
 
+function createRuntimeIgnoreService(ignoreFilePath: string): IgnoreService {
+    const config = vscode.workspace.getConfiguration('as-notes');
+    return createConfiguredIgnoreService(ignoreFilePath, {
+        templateFolder: config.get<string>('templateFolder', 'templates'),
+        assetPath: config.get<string>('assetPath', 'assets'),
+    });
+}
+
+function refreshIgnoreInfrastructure(): void {
+    if (!notesRootPaths) { return; }
+    ignoreService = createRuntimeIgnoreService(notesRootPaths.ignoreFilePath);
+    if (indexService?.isOpen && notesRootUri) {
+        indexScanner = new IndexScanner(indexService, notesRootUri, ignoreService, logService);
+    }
+}
+
+function runStaleScanAfterExclusionRefresh(reason: string): void {
+    if (!indexScanner) { return; }
+    indexScanner.staleScan().then((summary) => {
+        if (summary.newFiles > 0 || summary.staleFiles > 0 || summary.deletedFiles > 0) {
+            indexService?.saveToFile();
+            completionProvider?.refresh();
+            taskPanelProvider?.refresh();
+            searchPanelProvider?.refresh();
+            backlinkPanelProvider?.refresh();
+            calendarPanelProvider?.refresh();
+            updateFullModeStatusBar();
+        }
+    }).catch(err => logService.warn('extension', `stale scan after ${reason} failed: ${formatLogError(err)}`));
+}
+
 function getWorkspaceRoot(): vscode.Uri | undefined {
     return vscode.workspace.workspaceFolders?.[0]?.uri;
 }

vs-code-extension/src/extension.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { IgnoreService } from '../IgnoreService.js';
+import { IgnoreService, createConfiguredIgnoreService } from '../IgnoreService.js';
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
@@ -212,3 +212,61 @@ describe('IgnoreService — default patterns', () => {
         expect(svc.isIgnored('journal/2024-01-01.md')).toBe(false);
     });
 });
+
+describe('IgnoreService — mandatory runtime exclusions', () => {
+    it('always excludes .asnotes, templateFolder, and assetPath directories', () => {
+        const svc = createConfiguredIgnoreService(ignoreFilePath, {
+            templateFolder: 'templates',
+            assetPath: 'assets',
+        });
+
+        expect(svc.isIgnored('.asnotes/index.db')).toBe(true);
+        expect(svc.isIgnored('.asnotes/logs/main.log')).toBe(true);
+        expect(svc.isIgnored('templates/Journal.md')).toBe(true);
+        expect(svc.isIgnored('assets/diagram.md')).toBe(true);
+        expect(svc.isIgnored('assets/images/diagram.md')).toBe(true);
+        expect(svc.isIgnored('notes/page.md')).toBe(false);
+    });
+
+    it('normalises configured directory paths and preserves mandatory exclusions across reload', () => {
+        writeIgnore('archive/\n');
+        const svc = createConfiguredIgnoreService(ignoreFilePath, {
+            templateFolder: '/templates/',
+            assetPath: '\\assets\\images\\',
+        });
+
+        expect(svc.isIgnored('templates/Journal.md')).toBe(true);
+        expect(svc.isIgnored('assets/images/diagram.md')).toBe(true);
+        expect(svc.isIgnored('.asnotes/index.db')).toBe(true);
+        expect(svc.isIgnored('archive/page.md')).toBe(true);
+
+        writeIgnore('private/\n');
+        svc.reload();
+
+        expect(svc.isIgnored('.asnotes/index.db')).toBe(true);
+        expect(svc.isIgnored('templates/Journal.md')).toBe(true);
+        expect(svc.isIgnored('assets/images/diagram.md')).toBe(true);
+        expect(svc.isIgnored('archive/page.md')).toBe(false);
+        expect(svc.isIgnored('private/page.md')).toBe(true);
+    });
+
+    it('reflects settings changes when a new configured service is created', () => {
+        const initialSvc = createConfiguredIgnoreService(ignoreFilePath, {
+            templateFolder: 'templates',
+            assetPath: 'assets',
+        });
+        expect(initialSvc.isIgnored('templates/Journal.md')).toBe(true);
+        expect(initialSvc.isIgnored('static/diagram.md')).toBe(false);
+        expect(initialSvc.isIgnored('assets/diagram.md')).toBe(true);
+
+        const updatedSvc = createConfiguredIgnoreService(ignoreFilePath, {
+            templateFolder: 'snippets',
+            assetPath: 'static',
+        });
+        expect(updatedSvc.isIgnored('.asnotes/index.db')).toBe(true);
+        expect(updatedSvc.isIgnored('templates/Journal.md')).toBe(false);
+        expect(updatedSvc.isIgnored('snippets/Journal.md')).toBe(true);
+        expect(updatedSvc.isIgnored('assets/diagram.md')).toBe(false);
+        expect(updatedSvc.isIgnored('static/diagram.md')).toBe(true);
+    });
+});