Default notes directory

Author: gbro3n

CHANGELOG.md

@@ -6,7 +6,8 @@ All notable changes to AS Notes will be documented here.
 
 ## [2.2.3]  - 2026-03-19
 
-- Templates
+- Templates and template placeholders
+- Modified default note placement behaviour
 - Kanban boards markdown formatting
 - Kanban board card conversion from task (markdown todo)
 

README.md

@@ -264,6 +264,10 @@ All table operations in the slash command menu (`/`) are Pro features. Free user
 
 See [Slash Commands](#slash-commands) for the full list of table commands.
 
+### Create Note
+
+Run **AS Notes: Create Note** from the Command Palette to create a new note. You will be prompted for a title and the file is created in the configured notes folder (default: `notes/`).
+
 ### Encrypted notes
 
 Pro users can store sensitive notes in encrypted files. Any file with the `.enc.md` extension is treated as an encrypted note - it is excluded from the search index and never read as plain text by the extension.
@@ -283,7 +287,7 @@ Pro users can store sensitive notes in encrypted files. Any file with the `.enc.
 **Commands:**
 - `AS Notes: Set Encryption Key` - save passphrase to OS keychain
 - `AS Notes: Clear Encryption Key` - remove the stored passphrase
-- `AS Notes: Create Encrypted Note` - create a new named `.enc.md` file
+- `AS Notes: Create Encrypted Note` - create a new named `.enc.md` file in the notes folder
 - `AS Notes: Create Encrypted Journal Note` - create today's journal entry as `.enc.md`
 - `AS Notes: Encrypt All Notes` - encrypt all plaintext `.enc.md` files
 - `AS Notes: Decrypt All Notes` - decrypt all encrypted `.enc.md` files
@@ -374,7 +378,9 @@ Nesting works to arbitrary depth. The extension always identifies the innermost
 
 ### Auto-create missing pages
 
-Navigating to a page that doesn't exist creates it automatically, so you can write forward-references before the target page exists.
+Navigating to a page that doesn't exist creates it automatically in the configured notes folder (default: `notes/`). You can write forward-references before the target page exists.
+
+When `as-notes.createNotesInCurrentDirectory` is enabled, new pages are created in the current editing file's directory instead, unless the source file is in the journal folder (in which case the notes folder is always used).
 
 ### Hover tooltips
 
@@ -656,6 +662,8 @@ Front-matter holds the structured fields; the Markdown body is the card descript
 |---|---|---|
 | `as-notes.periodicScanInterval` | `300` | Seconds between automatic background scans for file changes. Set to `0` to disable. Minimum: `30`. |
 | `as-notes.journalFolder` | `journals` | Folder for daily journal files, relative to workspace root. |
+| `as-notes.notesFolder` | `notes` | Folder for new notes, relative to workspace root. Used when creating pages via wikilink navigation and the Create Note / Create Encrypted Note commands. |
+| `as-notes.createNotesInCurrentDirectory` | `false` | When enabled, new notes created via wikilink navigation are placed in the current editing file's directory instead of the notes folder. Ignored when the source file is in the journal folder. |
 | `as-notes.templateFolder` | `templates` | Folder for note templates, relative to workspace root. Templates are markdown files inserted via the `/Template` slash command. |
 | `as-notes.licenceKey` | *(empty)* | AS Notes Pro licence key (format: `ASNO-XXXX-XXXX-XXXX-XXXX`). Enter via **AS Notes: Enter Licence Key** in the Command Palette or directly in Settings. Scope: machine (not synced). |
 | `as-notes.enableLogging` | `false` | Enable diagnostic logging to `.asnotes/logs/`. Rolling 10 MB files, max 5. Requires reload after changing. Also activated by setting the `AS_NOTES_DEBUG=1` environment variable. |

TECHNICAL.md

@@ -1235,7 +1235,15 @@ The command URI carries:
 {directory of source file}/{pageFileName}.md
 ```
 
-All target files live in the same directory as the file containing the link. There is no support for cross-directory linking — this is intentional to keep the mental model simple (one folder = one wiki).
+This is used by the rename tracker where the file already exists in a known location.
+
+`WikilinkFileService.resolveNewFileTargetUri()` determines where **new** files should be created, respecting user settings:
+
+- By default, new files are created in the configured `notesFolder` (default: `notes/`).
+- When `createNotesInCurrentDirectory` is enabled, new files are placed in the source file's directory -- unless the source file is inside the journal folder, in which case the notes folder is always used.
+- Used by `WikilinkDocumentLinkProvider`, the `navigateToPage` context menu command, and the `navigateWikilink` command.
+
+All target files can live anywhere in the workspace. The index handles global resolution.
 
 ### Case-insensitive matching
 
@@ -1858,7 +1866,7 @@ The `as-notes.navigateToPage` command (registered in `extension.ts`) enables rig
 
 1. Extracts all wikilinks from the current line
 2. Finds the innermost wikilink at the cursor position via `WikilinkService.findInnermostWikilinkAtOffset()`
-3. Resolves the target URI via `WikilinkFileService.resolveTargetUri()`
+3. Resolves the target URI via `WikilinkFileService.resolveNewFileTargetUri()` (respects `notesFolder` and `createNotesInCurrentDirectory` settings)
 4. Calls `WikilinkFileService.navigateToFile()` — which uses index-aware resolution (global filename match, alias support, case-insensitive fallback) and auto-creates the file if it doesn't exist
 
 This provides the same navigation as Ctrl+click (DocumentLink) but via an explicit context menu entry. The command appears in the `editor/context` menu alongside "View Backlinks" when `as-notes.fullMode` is active and the editor language is markdown.
@@ -2647,6 +2655,10 @@ Tests use vitest and are split across fourteen test files (key files described b
 
 1. **Path distance** (10 tests) — same directory (0), nested subdirectory (1), sibling directories (2), root to deep (3), deep to root (3), divergent paths, case-insensitive comparison, deeply nested to root, same prefix different branch, single segment root.
 
+### `WikilinkFileService.resolveNewFileTargetUri.test.ts` (9 tests)
+
+1. **New file target resolution** (9 tests) — default notesFolder, custom notesFolder, createNotesInCurrentDirectory with non-journal source, journal folder override, nested journal subfolder override, empty notesFolder (workspace root), leading/trailing slash normalisation, explicit false setting, resolveTargetUri unchanged.
+
 ### `WikilinkCompletionProvider.test.ts` (30 tests)
 
 1. **Bracket detection** (11 tests) — no brackets, simple `[[`, after text, with text typed, already closed, nested innermost detection, inner closed leaving outer open, all brackets closed, multiple unclosed, partially closed, single `[`.

vs-code-extension/package.json

@@ -102,6 +102,10 @@
                 "command": "as-notes.decryptNotes",
                 "title": "AS Notes: Decrypt All Notes"
             },
+            {
+                "command": "as-notes.createNote",
+                "title": "AS Notes: Create Note"
+            },
             {
                 "command": "as-notes.createEncryptedFile",
                 "title": "AS Notes: Create Encrypted Note"
@@ -276,6 +280,16 @@
                     "type": "string",
                     "default": "templates",
                     "description": "Folder for note templates, relative to workspace root. Templates are markdown files that can be inserted via the /Template slash command."
+                },
+                "as-notes.notesFolder": {
+                    "type": "string",
+                    "default": "notes",
+                    "description": "Folder for new notes, relative to workspace root. Used when creating pages via wikilink navigation and the Create Note / Create Encrypted Note commands."
+                },
+                "as-notes.createNotesInCurrentDirectory": {
+                    "type": "boolean",
+                    "default": false,
+                    "description": "When enabled, new notes created via wikilink navigation are placed in the current editing file's directory instead of the notes folder. Ignored when the source file is in the journal folder."
                 }
             }
         },

vs-code-extension/src/WikilinkDocumentLinkProvider.ts

@@ -53,7 +53,7 @@ export class WikilinkDocumentLinkProvider implements vscode.DocumentLinkProvider
                 );
 
                 const wl = segment.wikilink;
-                const targetUri = this.fileService.resolveTargetUri(document.uri, wl.pageFileName);
+                const targetUri = this.fileService.resolveNewFileTargetUri(document.uri, wl.pageFileName);
 
                 const commandUri = vscode.Uri.parse(
                     `command:as-notes.navigateWikilink?${encodeURIComponent(JSON.stringify({

vs-code-extension/src/WikilinkFileService.ts

@@ -43,6 +43,56 @@ export class WikilinkFileService {
         return vscode.Uri.file(targetPath);
     }
 
+    /**
+     * Build the URI for a **new** wikilink target file, respecting the
+     * `notesFolder` and `createNotesInCurrentDirectory` settings.
+     *
+     * - If `createNotesInCurrentDirectory` is true AND the source file is
+     *   NOT inside the journal folder: uses the source file's directory.
+     * - Otherwise: uses the configured `notesFolder` (relative to workspace root).
+     *
+     * @param sourceUri - URI of the document containing the wikilink
+     * @param pageFileName - Sanitised page filename (without extension)
+     * @returns URI pointing to `{targetDir}/{pageFileName}.md`
+     */
+    resolveNewFileTargetUri(sourceUri: vscode.Uri, pageFileName: string): vscode.Uri {
+        const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri;
+        if (!workspaceRoot) {
+            // No workspace — fall back to source directory
+            return this.resolveTargetUri(sourceUri, pageFileName);
+        }
+
+        const config = vscode.workspace.getConfiguration('as-notes');
+        const createInCurrentDir = config.get<boolean>('createNotesInCurrentDirectory', false);
+
+        if (createInCurrentDir && !this.isInsideJournalFolder(sourceUri, workspaceRoot)) {
+            return this.resolveTargetUri(sourceUri, pageFileName);
+        }
+
+        const notesFolder = config.get<string>('notesFolder', 'notes');
+        const normalised = notesFolder.trim().replace(/^[/\\]+|[/\\]+$/g, '');
+        const targetDir = normalised
+            ? path.join(workspaceRoot.fsPath, normalised)
+            : workspaceRoot.fsPath;
+        const targetPath = path.join(targetDir, `${pageFileName}.md`);
+        return vscode.Uri.file(targetPath);
+    }
+
+    /**
+     * Check whether a source URI is inside the configured journal folder.
+     */
+    private isInsideJournalFolder(sourceUri: vscode.Uri, workspaceRoot: vscode.Uri): boolean {
+        const config = vscode.workspace.getConfiguration('as-notes');
+        const journalFolder = config.get<string>('journalFolder', 'journals');
+        const normalised = journalFolder.trim().replace(/^[/\\]+|[/\\]+$/g, '');
+        if (!normalised) {
+            return false;
+        }
+        const journalDir = path.join(workspaceRoot.fsPath, normalised).replace(/\\/g, '/').toLowerCase();
+        const sourceDir = path.dirname(sourceUri.fsPath).replace(/\\/g, '/').toLowerCase();
+        return sourceDir === journalDir || sourceDir.startsWith(journalDir + '/');
+    }
+
     /**
      * Resolve a wikilink target using the persistent index for global resolution.
      *

vs-code-extension/src/extension.ts

@@ -706,6 +706,13 @@ async function enterFullMode(
         fs.mkdirSync(journalFolderPath, { recursive: true });
     }
 
+    const notesFolder = config.get<string>('notesFolder', 'notes');
+    const normalisedNotes = notesFolder.trim().replace(/^[/\\]+|[/\\]+$/g, '');
+    if (normalisedNotes) {
+        const notesFolderPath = path.join(workspaceRoot.fsPath, normalisedNotes);
+        fs.mkdirSync(notesFolderPath, { recursive: true });
+    }
+
     ignoreService = new IgnoreService(path.join(workspaceRoot.fsPath, IGNORE_FILE));
     indexScanner = new IndexScanner(indexService, workspaceRoot, ignoreService, logService);
 
@@ -1369,7 +1376,7 @@ async function enterFullMode(
 
             if (!wikilink) { return; } // Not on a wikilink — do nothing
 
-            const targetUri = fileService.resolveTargetUri(editor.document.uri, wikilink.pageFileName);
+            const targetUri = fileService.resolveNewFileTargetUri(editor.document.uri, wikilink.pageFileName);
             await fileService.navigateToFile(targetUri, wikilink.pageFileName, editor.document.uri);
         }),
     );
@@ -1587,6 +1594,34 @@ async function enterFullMode(
         }),
     );
 
+    fullModeDisposables.push(
+        vscode.commands.registerCommand('as-notes.createNote', async () => {
+            const title = await vscode.window.showInputBox({
+                prompt: 'Note title',
+                placeHolder: 'My note',
+                ignoreFocusOut: true,
+            });
+            if (!title) { return; }
+            const config = vscode.workspace.getConfiguration('as-notes');
+            const notesFolder = config.get<string>('notesFolder', 'notes');
+            const normalised = notesFolder.trim().replace(/^[/\\]+|[/\\]+$/g, '');
+            const folderUri = normalised
+                ? vscode.Uri.joinPath(workspaceRoot, normalised)
+                : workspaceRoot;
+            await vscode.workspace.fs.createDirectory(folderUri);
+            const filename = `${sanitiseFileName(title)}.md`;
+            const fileUri = vscode.Uri.joinPath(folderUri, filename);
+            try {
+                await vscode.workspace.fs.stat(fileUri);
+                // File already exists — just open it
+            } catch {
+                await vscode.workspace.fs.writeFile(fileUri, Buffer.from('', 'utf-8'));
+            }
+            const doc = await vscode.workspace.openTextDocument(fileUri);
+            await vscode.window.showTextDocument(doc);
+        }),
+    );
+
     fullModeDisposables.push(
         vscode.commands.registerCommand('as-notes.createEncryptedFile', async () => {
             if (!hasProEditor()) {
@@ -1599,8 +1634,15 @@ async function enterFullMode(
                 ignoreFocusOut: true,
             });
             if (!title) { return; }
+            const config = vscode.workspace.getConfiguration('as-notes');
+            const notesFolder = config.get<string>('notesFolder', 'notes');
+            const normalised = notesFolder.trim().replace(/^[/\\]+|[/\\]+$/g, '');
+            const folderUri = normalised
+                ? vscode.Uri.joinPath(workspaceRoot, normalised)
+                : workspaceRoot;
+            await vscode.workspace.fs.createDirectory(folderUri);
             const filename = `${sanitiseFileName(title)}.enc.md`;
-            const fileUri = vscode.Uri.joinPath(workspaceRoot, filename);
+            const fileUri = vscode.Uri.joinPath(folderUri, filename);
             try {
                 await vscode.workspace.fs.stat(fileUri);
                 // File already exists — just open it
@@ -1750,7 +1792,11 @@ async function enterFullMode(
         }) => {
             const targetUri = vscode.Uri.parse(args.targetUri);
             const sourceUri = vscode.Uri.parse(args.sourceUri);
-            await fileService.navigateToFile(targetUri, args.pageFileName, sourceUri);
+            // Re-resolve the creation target using current settings so that the
+            // correct notes folder is used even if the link provider cached a
+            // stale URI (e.g. when the document was first opened).
+            const creationUri = fileService.resolveNewFileTargetUri(sourceUri, args.pageFileName);
+            await fileService.navigateToFile(creationUri, args.pageFileName, sourceUri);
         }),
     );
 
@@ -2127,6 +2173,14 @@ async function initWorkspace(context: vscode.ExtensionContext): Promise<void> {
         fs.writeFileSync(journalTemplatePath, DEFAULT_JOURNAL_TEMPLATE, 'utf-8');
     }
 
+    // Create notes/ directory for new notes
+    const notesFolder = templateConfig.get<string>('notesFolder', 'notes');
+    const normalisedNotes = notesFolder.trim().replace(/^[/\\]+|[/\\]+$/g, '');
+    if (normalisedNotes) {
+        const notesFolderPath = path.join(workspaceRoot.fsPath, normalisedNotes);
+        fs.mkdirSync(notesFolderPath, { recursive: true });
+    }
+
     // Create .gitignore inside .asnotes/ to exclude the DB file
     fs.writeFileSync(path.join(asnotesDir, '.gitignore'), 'index.db\n');