@andespindola/brainlink 1.0.0 → 1.0.1

package/README.md

@@ -537,6 +537,7 @@ Available tools:
 - `brainlink_dedupe`: detect duplicate candidates using exact hash + semantic similarity scores.
 - `brainlink_resolve_duplicate`: resolve duplicate pairs (`merge`, `link`, `ignore`) with connectivity-safe fallback edges.
 - `brainlink_add_note`: write durable Markdown memory and reindex.
+- `brainlink_delete_note`: delete a durable Markdown note by title or path after explicit confirmation and reindex.
 - `brainlink_add_file`: ingest a local file as a note and reindex.
 - `brainlink_canonicalize_context_links`: ensure existing notes link to inferred context hubs.
 - `brainlink_volatile_add`: write temporary agent-decided memory with TTL; volatile sections are included in context and never create durable graph edges.
@@ -732,6 +733,17 @@ Lists known vaults from the configured default, `allowedVaults`, and the built-i
 `vaults use` chooses the default vault without migrating memory; use `migrate-vault` or `config set-vault --migrate-from` when you want to copy Markdown memory between vaults.
 `vaults delete` only deletes local filesystem vaults, requires `--yes`, refuses bucket vaults, and refuses deleting the current default vault. Choose another default first with `vaults use`.
 
+### `delete-note`
+
+```bash
+blink delete-note --title "Architecture" --yes
+blink delete-note --path agents/shared/architecture.md --yes
+blink delete-note --title "Architecture" --agent coding-agent --yes
+blink delete-note --path agents/shared/architecture.md --yes --no-auto-index
+```
+
+Deletes a durable Markdown note from the selected vault. The command requires `--yes`, accepts exactly one selector (`--title` or `--path`), refuses non-Markdown/protected paths, and reindexes by default. Bucket vault note deletion is intentionally refused until provider-native object deletion is implemented safely.
+
 ### `migrate-vault`
 
 ```bash

package/dist/application/delete-note.js

@@ -0,0 +1,80 @@
+import { relative, resolve } from 'node:path';
+import { parseMarkdownDocument } from '../domain/markdown.js';
+import { deleteMarkdownFile, ensureVault, isBucketVaultPath, readMarkdownFiles } from '../infrastructure/file-system-vault.js';
+import { indexVault } from './index-vault.js';
+const normalizeTitleKey = (title) => title.trim().replace(/\.md$/i, '').toLowerCase();
+const validateSelector = (input) => {
+    const hasTitle = input.title != null && input.title.trim().length > 0;
+    const hasPath = input.path != null && input.path.trim().length > 0;
+    if (!input.confirm) {
+        throw new Error('Refusing to delete note without explicit confirmation.');
+    }
+    if (hasTitle === hasPath) {
+        throw new Error('Use exactly one selector: title or path.');
+    }
+};
+const readCandidates = async (vaultPath) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const files = await readMarkdownFiles(vaultPath);
+    return files.map((file) => {
+        const document = parseMarkdownDocument({
+            absolutePath: file.absolutePath,
+            vaultPath: absoluteVaultPath,
+            content: file.content,
+            createdAt: file.createdAt,
+            updatedAt: file.updatedAt
+        });
+        return {
+            absolutePath: file.absolutePath,
+            relativePath: document.path,
+            title: document.title,
+            agentId: document.agentId
+        };
+    });
+};
+const findByTitle = async (vaultPath, title, agentId) => {
+    const expected = normalizeTitleKey(title);
+    const matches = (await readCandidates(vaultPath)).filter((candidate) => normalizeTitleKey(candidate.title) === expected && (agentId == null || candidate.agentId === agentId));
+    if (matches.length === 0) {
+        throw new Error(`No note found with title: ${title}`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`Multiple notes match title "${title}". Delete by path instead: ${matches.map((match) => match.relativePath).join(', ')}`);
+    }
+    return matches[0];
+};
+const findByPath = async (vaultPath, path) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const expectedPath = resolve(absoluteVaultPath, path);
+    const candidates = await readCandidates(vaultPath);
+    const match = candidates.find((candidate) => resolve(candidate.absolutePath) === expectedPath);
+    if (match) {
+        return match;
+    }
+    const absolutePath = expectedPath;
+    return {
+        absolutePath,
+        relativePath: relative(absoluteVaultPath, absolutePath).replaceAll('\\', '/'),
+        title: relative(absoluteVaultPath, absolutePath).replace(/\.md$/i, ''),
+        agentId: 'shared'
+    };
+};
+export const deleteNote = async (vaultPath, input) => {
+    validateSelector(input);
+    if (isBucketVaultPath(vaultPath)) {
+        throw new Error('Deleting bucket vault notes is not supported from Brainlink yet. Remove bucket objects with your storage provider tooling.');
+    }
+    const candidate = input.title != null
+        ? await findByTitle(vaultPath, input.title, input.agentId)
+        : await findByPath(vaultPath, input.path ?? '');
+    await deleteMarkdownFile(vaultPath, candidate.relativePath);
+    const index = input.autoIndex === false ? undefined : await indexVault(vaultPath);
+    return {
+        deleted: true,
+        path: candidate.absolutePath,
+        relativePath: candidate.relativePath,
+        title: candidate.title,
+        agentId: candidate.agentId,
+        ...(index ? { index } : {})
+    };
+};

package/dist/cli/commands/write-commands.js

@@ -5,6 +5,7 @@ import { platform, tmpdir } from 'node:os';
 import { spawn, spawnSync } from 'node:child_process';
 import { addNoteWithMetadata } from '../../application/add-note.js';
 import { buildContextPackage } from '../../application/build-context.js';
+import { deleteNote } from '../../application/delete-note.js';
 import { resolveDuplicateNotes, scanDuplicateNotes } from '../../application/dedupe-notes.js';
 import { importLegacySqliteDatabase } from '../../application/import-legacy-sqlite.js';
 import { indexVault, indexVaultWithOptions } from '../../application/index-vault.js';
@@ -873,6 +874,30 @@ export const registerWriteCommands = (program) => {
             return `Created note at ${added.path}.${linkMessage}${duplicateMessage}`;
         });
     });
+    program
+        .command('delete-note')
+        .option('-v, --vault <vault>', 'vault directory')
+        .option('-a, --agent <agent>', 'agent memory namespace when deleting by title')
+        .option('--title <title>', 'note title to delete')
+        .option('--path <path>', 'vault-relative or absolute markdown note path to delete')
+        .option('--yes', 'confirm note deletion')
+        .option('--no-auto-index', 'skip reindexing after delete')
+        .option('--json', 'print machine-readable JSON')
+        .description('delete a Markdown note from the vault after explicit confirmation')
+        .action(async (options) => {
+        const resolved = await resolveOptions(options);
+        const result = await deleteNote(resolved.vault, {
+            title: options.title,
+            path: options.path,
+            agentId: resolved.agent,
+            confirm: Boolean(options.yes),
+            autoIndex: options.autoIndex !== false
+        });
+        print(options.json, {
+            vault: resolved.vault,
+            ...result
+        }, () => `Deleted note ${result.relativePath}.`);
+    });
     program
         .command('dedupe')
         .option('-v, --vault <vault>', 'vault directory')

package/dist/infrastructure/file-system-vault.js

@@ -1,4 +1,4 @@
-import { chmod, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { resolvePath } from './paths.js';
 import { getBucketVaultCachePath, isBucketVaultUri, parseBucketVaultUri, syncBucketVaultToCache, writeBucketMarkdownFile } from './bucket-vault.js';
@@ -109,3 +109,23 @@ export const writeMarkdownFile = async (vaultPath, filename, content) => {
     await chmod(absolutePath, fileMode);
     return absolutePath;
 };
+export const deleteMarkdownFile = async (vaultPath, filename) => {
+    if (isBucketVaultUri(vaultPath)) {
+        throw new Error('Deleting bucket vault notes is not supported from Brainlink yet. Remove bucket objects with your storage provider tooling.');
+    }
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const absolutePath = isAbsolute(filename) ? resolve(filename) : resolve(absoluteVaultPath, filename);
+    if (!isPathInside(absoluteVaultPath, absolutePath)) {
+        throw new Error(`Refusing to delete outside vault: ${absolutePath}`);
+    }
+    if (extname(absolutePath).toLowerCase() !== '.md') {
+        throw new Error(`Refusing to delete non-Markdown vault item: ${absolutePath}`);
+    }
+    const relativePath = relative(absoluteVaultPath, absolutePath);
+    const segments = relativePath.split(/[\\/]+/);
+    if (segments.some((segment) => excludedDirectories.has(segment))) {
+        throw new Error(`Refusing to delete protected vault path: ${relativePath}`);
+    }
+    await rm(absolutePath, { force: false });
+    return absolutePath;
+};

package/dist/mcp/server.js

@@ -1,5 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { addNoteInputSchema, addFileInputSchema, addFileTool, addNoteTool, volatileAddInputSchema, volatileAddTool, volatileClearInputSchema, volatileClearTool, dedupeInputSchema, dedupeResolveInputSchema, dedupeResolveTool, dedupeTool, brokenLinksInputSchema, brokenLinksTool, bootstrapInputSchema, bootstrapTool, canonicalizeContextLinksInputSchema, canonicalizeContextLinksTool, contextInputSchema, contextPacksInputSchema, contextPacksTool, contextTool, graphContextsInputSchema, graphContextsTool, graphInputSchema, graphTool, indexInputSchema, indexTool, orphansInputSchema, orphansTool, policyInputSchema, policyTool, recommendationsInputSchema, recommendationsTool, searchInputSchema, searchTool, statsInputSchema, statsTool, syncInputSchema, syncTool, validateInputSchema, validateTool, versionInputSchema, versionTool } from './tools.js';
+import { addNoteInputSchema, addFileInputSchema, addFileTool, addNoteTool, deleteNoteInputSchema, deleteNoteTool, volatileAddInputSchema, volatileAddTool, volatileClearInputSchema, volatileClearTool, dedupeInputSchema, dedupeResolveInputSchema, dedupeResolveTool, dedupeTool, brokenLinksInputSchema, brokenLinksTool, bootstrapInputSchema, bootstrapTool, canonicalizeContextLinksInputSchema, canonicalizeContextLinksTool, contextInputSchema, contextPacksInputSchema, contextPacksTool, contextTool, graphContextsInputSchema, graphContextsTool, graphInputSchema, graphTool, indexInputSchema, indexTool, orphansInputSchema, orphansTool, policyInputSchema, policyTool, recommendationsInputSchema, recommendationsTool, searchInputSchema, searchTool, statsInputSchema, statsTool, syncInputSchema, syncTool, validateInputSchema, validateTool, versionInputSchema, versionTool } from './tools.js';
 import { getRuntimeVersion } from './runtime.js';
 export const createBrainlinkMcpServer = () => {
     const server = new McpServer({
@@ -58,6 +58,11 @@ export const createBrainlinkMcpServer = () => {
         description: 'Write durable Markdown memory, then reindex the vault. Include explicit [[wiki links]] for connected graph memory. Add priority markers near links, such as priority: high, #important or #critical, when a relationship should be weighted higher.',
         inputSchema: addNoteInputSchema
     }, addNoteTool);
+    server.registerTool('brainlink_delete_note', {
+        title: 'Delete Brainlink Note',
+        description: 'Delete a durable Markdown note from the vault after explicit confirmation. Select by title or path; reindexes by default.',
+        inputSchema: deleteNoteInputSchema
+    }, deleteNoteTool);
     server.registerTool('brainlink_volatile_add', {
         title: 'Add Volatile Brainlink Memory',
         description: 'Write temporary agent-decided memory with TTL. Use for transient task state without polluting durable Markdown memory.',

package/dist/mcp/tools.js

@@ -5,6 +5,7 @@ import { getBrokenLinksReport, getOrphansReport, getStats, validateVault } from
 import { addNoteWithMetadata } from '../application/add-note.js';
 import { buildContextPackage, readContextDataSignature } from '../application/build-context.js';
 import { canonicalizeContextLinks } from '../application/canonical-context-links.js';
+import { deleteNote } from '../application/delete-note.js';
 import { resolveDuplicateNotes, scanDuplicateNotes } from '../application/dedupe-notes.js';
 import { getGraph } from '../application/get-graph.js';
 import { getGraphContexts } from '../application/get-graph-contexts.js';
@@ -263,6 +264,14 @@ export const addNoteInputSchema = {
         .optional()
         .describe('Automatically add canonical Context Links to the inferred visual context hub. Defaults to Brainlink config.')
 };
+export const deleteNoteInputSchema = {
+    ...vaultInput,
+    ...agentInput,
+    title: z.string().min(1).optional().describe('Note title to delete. Use agent to disambiguate namespaced notes.'),
+    path: z.string().min(1).optional().describe('Vault-relative or absolute Markdown note path to delete.'),
+    confirm: z.boolean().describe('Must be true to confirm deletion.'),
+    autoIndex: z.boolean().optional().default(true).describe('Reindex vault after deletion. Defaults to true.')
+};
 export const volatileAddInputSchema = {
     ...vaultInput,
     ...agentInput,
@@ -495,6 +504,20 @@ export const addNoteTool = async (input) => {
         ...(index ? { index } : {})
     });
 };
+export const deleteNoteTool = async (input) => {
+    const context = await resolveExecutionContext(input);
+    const result = await deleteNote(context.vault, {
+        title: input.title,
+        path: input.path,
+        agentId: context.agent,
+        confirm: input.confirm,
+        autoIndex: input.autoIndex
+    });
+    return jsonResult({
+        vault: context.vault,
+        ...result
+    });
+};
 export const volatileAddTool = async (input) => {
     const context = await resolveExecutionContext(input);
     const entry = await addVolatileMemory(context.vault, input.content, context.agent ?? 'shared', input.ttlMinutes ?? 240, input.tags);

package/docs/AGENT_USAGE.md

@@ -398,6 +398,15 @@ blink vaults delete /absolute/path/to/vault --yes
 `vaults use` switches the default vault without migrating memory.
 `vaults delete` deletes only local filesystem vaults, requires `--yes`, and refuses deleting the current default vault.
 
+### Delete Notes
+
+```bash
+blink delete-note --title "Architecture" --yes
+blink delete-note --path agents/shared/architecture.md --yes
+```
+
+`delete-note` deletes durable Markdown notes only, requires explicit confirmation, accepts either `--title` or `--path`, and reindexes by default. MCP exposes the same capability as `brainlink_delete_note` with `confirm: true`.
+
 ### Migrate Vaults Explicitly
 
 ```bash
@@ -707,6 +716,7 @@ Available MCP tools:
 - `brainlink_dedupe`
 - `brainlink_resolve_duplicate`
 - `brainlink_add_note`
+- `brainlink_delete_note`
 - `brainlink_add_file`
 - `brainlink_canonicalize_context_links`
 - `brainlink_volatile_add`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",