@dinoxx/dinox-cli 1.0.20 → 1.0.22

package/dist/commands/mcp/noteContentTools.js

@@ -0,0 +1,390 @@
+import { generateId } from '../../utils/id.js';
+import { nowIsoUtc } from '../../utils/time.js';
+import { NoteContentEditError, applyNoteEditPatch, blockNodeHash, blockTextHash, buildNoteEditContext, getNoteContentReadInstructions, getNoteContentSchemaSummary, parseNodeRangeString, serializeAnchoredMarkdown, serializeAnchoredShorthand, topNodes, } from '../../utils/noteContentEngine.js';
+export const NOTE_CONTENT_READ_TOOL_NAME = 'noteContentRead';
+export const NOTE_CONTENT_EDIT_TOOL_NAME = 'noteContentEdit';
+const DEFAULT_MAX_RANGE_CHARS = 20_000;
+const DEFAULT_READ_PAGE_MAX_NODES = 24;
+const READ_TOKEN_TTL_MS = 30 * 60 * 1000;
+const MAX_READ_TOKENS = 500;
+export const noteContentMcpTools = [
+    {
+        name: NOTE_CONTENT_READ_TOOL_NAME,
+        description: 'Read canonical note content as paginated dinox-shorthand with block hashes, readToken, and preferred edit targets.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                noteId: { type: 'string', description: 'Target note ID.' },
+                from: { type: 'number', description: 'Zero-based top-level node index to read from.' },
+                cursor: {
+                    type: 'object',
+                    description: 'Continuation cursor returned by noteContentRead.',
+                    properties: {
+                        from: { type: 'number' },
+                        contentHash: { type: 'string' },
+                    },
+                },
+                nodeRange: { type: 'string', description: 'Top-level node range such as "0:5", "5:", or ":10".' },
+                includeJson: { type: 'boolean', description: 'Return local Tiptap JSON for diagnostics. Do not write raw JSON back.' },
+                maxChars: { type: 'number', description: 'Maximum characters for the local range text.' },
+                maxNodes: { type: 'number', description: 'Maximum top-level nodes to include when nodeRange is not set.' },
+            },
+            required: ['noteId'],
+        },
+    },
+    {
+        name: NOTE_CONTENT_EDIT_TOOL_NAME,
+        description: 'Persist structured edits to an existing note after noteContentRead returned a readToken. Use structured blocks, not Markdown strings or raw Tiptap JSON.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                readToken: { type: 'string', description: 'readToken returned by noteContentRead.' },
+                operations: {
+                    type: 'array',
+                    description: 'Structured edit operations. Prefer preferredTarget and expectedNodeHash/expectedTextHash for destructive edits.',
+                    items: { type: 'object' },
+                },
+            },
+            required: ['readToken', 'operations'],
+        },
+    },
+];
+export class NoteContentMcpService {
+    getDatabase;
+    now;
+    #readTokens = new Map();
+    constructor(getDatabase, now = () => Date.now()) {
+        this.getDatabase = getDatabase;
+        this.now = now;
+    }
+    async read(input, runtime) {
+        const row = await this.#readNote(this.getDatabase(), input.noteId);
+        this.#assertUser(row, runtime.userId);
+        const context = buildNoteEditContext({
+            noteId: row.id,
+            title: row.title,
+            contentJson: row.content_json,
+            updatedAt: row.updated_at,
+            version: normalizeVersion(row.version),
+        });
+        const token = this.#rememberReadToken(context, runtime);
+        const page = this.#readPage(context.document, context.blocks, context.contentHash, input);
+        return {
+            success: true,
+            hasError: false,
+            docChanged: false,
+            document: null,
+            noteId: context.noteId,
+            title: context.title,
+            readToken: token.token,
+            readTokenExpiresAt: new Date(token.expiresAtMs).toISOString(),
+            base: {
+                contentHash: context.contentHash,
+                updatedAt: context.updatedAt,
+                version: context.version,
+            },
+            totalNodes: context.blocks.length,
+            totalCharCount: context.totalCharCount,
+            estimatedTokens: context.estimatedTokens,
+            from: page.from,
+            nodeRange: page.nodeRangeTuple,
+            format: page.format,
+            content: page.shorthand,
+            canReadMore: Boolean(page.nextCursor),
+            nextCursor: page.nextCursor,
+            schema: getNoteContentSchemaSummary(),
+            readFormatInstructions: getNoteContentReadInstructions(),
+            chunks: context.chunks,
+            blocks: context.blocks.map(({ text, ...block }) => ({
+                ...block,
+                preferredTarget: {
+                    anchorId: block.anchorId,
+                    nodeRange: block.nodeRange,
+                    expectedTextHash: block.textHash,
+                    expectedNodeHash: block.nodeHash,
+                },
+            })),
+            page,
+            ...(input.nodeRange ? { range: page } : {}),
+        };
+    }
+    async edit(input, runtime) {
+        const token = this.#requireReadToken(input.readToken, runtime);
+        const db = this.getDatabase();
+        try {
+            const result = await runWrite(db, async (tx) => {
+                const row = await this.#readNote(tx, token.noteId);
+                this.#assertUser(row, runtime.userId);
+                this.#assertTokenMatchesRow(token, row);
+                const patch = {
+                    base: {
+                        contentHash: token.contentHash,
+                        updatedAt: token.updatedAt,
+                        version: token.version,
+                    },
+                    operations: input.operations,
+                };
+                const applied = applyNoteEditPatch({
+                    noteId: row.id,
+                    title: row.title,
+                    contentJson: row.content_json,
+                    updatedAt: row.updated_at,
+                    version: normalizeVersion(row.version),
+                    createAnchorId: () => generateId(),
+                    patch,
+                });
+                if (!applied.changed)
+                    return buildSuccess(applied, false);
+                const savedAt = nowIsoUtc();
+                await updateNoteProjection(tx, row.id, {
+                    content_json: applied.projection.content_json,
+                    content_text: applied.projection.content_text,
+                    content_md: applied.projection.content_md,
+                    images: applied.projection.images,
+                    bid_links: applied.projection.bid_links,
+                    updated_at: savedAt,
+                });
+                return buildSuccess(applied, true, savedAt, nextVersion(row.version));
+            });
+            this.#readTokens.delete(token.token);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof NoteContentEditError && error.code === 'content_conflict') {
+                this.#readTokens.delete(token.token);
+            }
+            throw error;
+        }
+    }
+    #readPage(document, blocks, contentHash, input) {
+        const nodes = topNodes(document);
+        const parsed = resolveReadPageRange(input, nodes.length);
+        if (input.cursor?.contentHash && input.cursor.contentHash !== contentHash) {
+            throw new Error('noteContentRead cursor 已过期，请重新从 from: 0 读取笔记内容');
+        }
+        const selectedNodes = nodes.slice(parsed.start, parsed.end);
+        const maxChars = clampInt(input.maxChars, 1, 100_000, DEFAULT_MAX_RANGE_CHARS);
+        const text = truncateContent(selectedNodes.map((node) => blocks[nodes.indexOf(node)]?.text ?? '').join('\n\n').trim(), maxChars);
+        const markdown = truncateContent(serializeAnchoredMarkdown(selectedNodes, blocks, parsed.start), maxChars);
+        const shorthand = truncateContent(serializeAnchoredShorthand(selectedNodes, blocks, parsed.start), maxChars);
+        const textHash = blockTextHash(blocks, parsed.start, parsed.end);
+        const nodeHash = blockNodeHash(blocks, parsed.start, parsed.end);
+        const nextCursor = parsed.end < nodes.length ? { from: parsed.end, contentHash } : null;
+        return {
+            nodeRange: `${parsed.start}:${parsed.end}`,
+            nodeRangeTuple: [parsed.start, parsed.end],
+            format: 'dinox-shorthand',
+            from: parsed.start,
+            text: text.value,
+            textHash,
+            nodeHash,
+            preferredTarget: {
+                nodeRange: `${parsed.start}:${parsed.end}`,
+                anchorIds: blocks.slice(parsed.start, parsed.end).map((block) => block.anchorId),
+                expectedTextHash: textHash,
+                expectedNodeHash: nodeHash,
+            },
+            shorthand: shorthand.value,
+            markdown: markdown.value,
+            textWindow: text.window,
+            shorthandWindow: shorthand.window,
+            markdownWindow: markdown.window,
+            isTruncated: text.isTruncated || shorthand.isTruncated || markdown.isTruncated,
+            nextCursor,
+            ...(input.includeJson ? { json: selectedNodes } : {}),
+        };
+    }
+    async #readNote(db, noteId) {
+        const id = normalizeText(noteId);
+        if (!id)
+            throw new Error('noteId 不能为空');
+        const row = await db.getOptional('SELECT * FROM c_note WHERE id = ? LIMIT 1', [id]);
+        if (!row || Number(row.is_del ?? 0) === 1)
+            throw new Error('笔记不存在或已删除');
+        return row;
+    }
+    #assertUser(row, userId) {
+        const owner = normalizeText(row.user_no) || normalizeText(row.user_id);
+        const actor = normalizeText(userId);
+        if (!actor || !owner || owner !== actor)
+            throw new Error('无权更新此笔记');
+    }
+    #rememberReadToken(context, runtime) {
+        this.#pruneReadTokens();
+        const token = {
+            token: generateId(),
+            noteId: context.noteId,
+            userId: normalizeText(runtime.userId),
+            contentHash: context.contentHash,
+            updatedAt: context.updatedAt,
+            version: context.version,
+            expiresAtMs: this.now() + READ_TOKEN_TTL_MS,
+        };
+        this.#readTokens.set(token.token, token);
+        this.#pruneReadTokens();
+        return token;
+    }
+    #requireReadToken(tokenId, runtime) {
+        const id = normalizeText(tokenId);
+        if (!id)
+            throw new Error(`缺少 readToken，请先调用 ${NOTE_CONTENT_READ_TOOL_NAME} 读取笔记内容`);
+        this.#pruneReadTokens();
+        const token = this.#readTokens.get(id);
+        if (!token)
+            throw new Error(`readToken 已失效，请重新调用 ${NOTE_CONTENT_READ_TOOL_NAME} 读取最新笔记内容`);
+        if (token.userId !== normalizeText(runtime.userId))
+            throw new Error('readToken 与当前用户不匹配，请重新读取笔记内容');
+        return token;
+    }
+    #assertTokenMatchesRow(token, row) {
+        if (token.noteId !== row.id)
+            throw new NoteContentEditError('content_conflict', 'readToken 与目标笔记不匹配，请重新读取笔记内容');
+        if (token.updatedAt !== (row.updated_at ?? null) || token.version !== normalizeVersion(row.version)) {
+            throw new NoteContentEditError('content_conflict', '笔记内容已变化，请重新读取后再编辑');
+        }
+    }
+    #pruneReadTokens() {
+        const now = this.now();
+        for (const [token, record] of this.#readTokens) {
+            if (record.expiresAtMs <= now)
+                this.#readTokens.delete(token);
+        }
+        while (this.#readTokens.size > MAX_READ_TOKENS) {
+            const oldest = this.#readTokens.keys().next().value;
+            if (!oldest)
+                break;
+            this.#readTokens.delete(oldest);
+        }
+    }
+}
+export function buildNoteContentToolError(error, operations = []) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof NoteContentEditError ? error.code : 'unexpectedError';
+    return {
+        success: false,
+        hasError: true,
+        docChanged: false,
+        document: null,
+        reason: mapToolErrorReason(code),
+        error: message,
+        shouldRetry: isRetryable(code, message),
+        operationResults: operations.map((operation, index) => ({
+            operationIndex: index,
+            type: operation.op,
+            success: false,
+            target: describeOperationTarget(operation.target),
+            nodeRange: null,
+            error: message,
+        })),
+    };
+}
+async function updateNoteProjection(db, noteId, values) {
+    const columns = await db.getAll('PRAGMA table_info(c_note)', []);
+    const columnNames = new Set(columns.map((row) => normalizeText(row.name)).filter(Boolean));
+    for (const required of ['content_json', 'content_text', 'content_md']) {
+        if (!columnNames.has(required))
+            throw new Error(`c_note table is missing required column: ${required}`);
+    }
+    const updates = [];
+    const params = [];
+    for (const [column, value] of Object.entries(values)) {
+        if (!columnNames.has(column))
+            continue;
+        updates.push(`${column} = ?`);
+        params.push(value);
+    }
+    if (columnNames.has('version'))
+        updates.push('version = COALESCE(version, 0) + 1');
+    params.push(noteId);
+    await db.execute(`
+    UPDATE c_note
+    SET ${updates.join(', ')}
+    WHERE id = ?
+    `, params);
+}
+async function runWrite(db, callback) {
+    if (typeof db.writeTransaction === 'function')
+        return db.writeTransaction(callback);
+    if (typeof db.writeLock === 'function')
+        return db.writeLock(callback);
+    return callback(db);
+}
+function buildSuccess(result, saved, updatedAt, version) {
+    return {
+        success: true,
+        hasError: false,
+        docChanged: result.changed,
+        document: null,
+        saved,
+        noteId: result.noteId,
+        title: result.after.title,
+        changed: result.changed,
+        appliedOperations: result.appliedOperations,
+        operationResults: result.operationResults,
+        updatedAt: updatedAt ?? result.after.updatedAt,
+        before: { contentHash: result.before.contentHash, totalNodes: result.before.blocks.length },
+        after: { contentHash: result.after.contentHash, totalNodes: result.after.blocks.length, version: version ?? result.after.version },
+    };
+}
+function resolveReadPageRange(input, total) {
+    if (input.nodeRange)
+        return parseNodeRangeString(input.nodeRange, total);
+    const start = clampInt(input.cursor?.from ?? input.from, 0, total, 0);
+    const maxNodes = clampInt(input.maxNodes, 1, 100, DEFAULT_READ_PAGE_MAX_NODES);
+    return { start, end: Math.min(total, start + maxNodes) };
+}
+function truncateContent(value, maxChars) {
+    const isTruncated = value.length > maxChars;
+    const length = isTruncated ? maxChars : value.length;
+    return {
+        value: isTruncated ? value.slice(0, maxChars) : value,
+        isTruncated,
+        window: { offset: 0, length, total: value.length, nextOffset: isTruncated ? length : null },
+    };
+}
+function clampInt(value, min, max, fallback) {
+    const number = typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : fallback;
+    return Math.max(min, Math.min(max, number));
+}
+function normalizeVersion(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+}
+function nextVersion(value) {
+    const current = normalizeVersion(value);
+    return current == null ? null : current + 1;
+}
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function mapToolErrorReason(code) {
+    if (code === 'invalid_plan' || code === 'invalid_content')
+        return 'validationError';
+    if (code === 'content_conflict')
+        return 'contentConflict';
+    if (code === 'target_not_found' || code === 'target_conflict')
+        return 'targetError';
+    return 'unexpectedError';
+}
+function isRetryable(code, message) {
+    return code === 'content_conflict' || code === 'target_not_found' || code === 'target_conflict' || /readToken|cursor|过期|变化|重新读取/i.test(message);
+}
+function describeOperationTarget(target) {
+    if (!target)
+        return 'unknown';
+    if (target.anchorId)
+        return target.anchorId;
+    if (target.anchorIds?.length)
+        return target.anchorIds.join(',');
+    if (target.nodeRange)
+        return target.nodeRange;
+    if (typeof target.nodeIndex === 'number')
+        return String(target.nodeIndex);
+    if (target.expectedNodeHash)
+        return target.expectedNodeHash;
+    if (target.expectedTextHash)
+        return target.expectedTextHash;
+    if (target.textMatch)
+        return target.textMatch;
+    return 'unknown';
+}

package/dist/commands/mcp/server.d.ts

@@ -17,11 +17,14 @@ type MCPResponse = {
 };
 export declare class MCPServer {
     private db;
+    private readonly noteContent;
     initialize(): Promise<void>;
     handleRequest(req: MCPRequest): Promise<MCPResponse | null>;
     private handleInitialize;
     private handleToolsList;
     private handleToolsCall;
+    private requireDb;
+    private getRuntime;
     close(): Promise<void>;
 }
 export declare function startMCPServer(port?: number, host?: string, authToken?: string): Promise<{

package/dist/commands/mcp/server.js

@@ -2,6 +2,7 @@ import { createServer } from 'node:http';
 import { DEFAULT_MCP_PORT } from './types.js';
 import { mcpTools } from './tools.js';
 import { isAuthorizedMCPRequest } from './auth.js';
+import { NOTE_CONTENT_EDIT_TOOL_NAME, NOTE_CONTENT_READ_TOOL_NAME, NoteContentMcpService, buildNoteContentToolError, } from './noteContentTools.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { loadConfig } from '../../config/store.js';
 import { resolveConfig } from '../../config/resolve.js';
@@ -141,6 +142,7 @@ async function readJsonBody(req) {
 }
 export class MCPServer {
     db = null;
+    noteContent = new NoteContentMcpService(() => this.requireDb());
     async initialize() {
         const config = resolveConfig(await loadConfig());
         const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
@@ -204,9 +206,7 @@ export class MCPServer {
         return buildResponse(req, { result: { tools: mcpTools } });
     }
     async handleToolsCall(req) {
-        if (!this.db) {
-            throw new Error('Database not initialized');
-        }
+        const db = this.requireDb();
         const name = req.params?.name;
         const args = req.params?.arguments ?? {};
         if (typeof name !== 'string') {
@@ -218,7 +218,7 @@ export class MCPServer {
                 const tagsExpression = typeof args.tags === 'string' ? args.tags.trim() : '';
                 const rawBoxes = args.boxes ?? args.box;
                 const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(rawBoxes);
-                const zettelBoxIds = await resolveZettelBoxIdsForSearch(this.db, boxNames);
+                const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, boxNames);
                 const daysInput = typeof args.days === 'number' ? String(args.days) : args.days;
                 const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
                     from: args.from,
@@ -228,7 +228,7 @@ export class MCPServer {
                 const limit = normalizeLimit(args.limit);
                 const offset = normalizeOffset(args.offset);
                 const fields = parseNoteSearchFields(args.fields, 'dinox_search_notes.fields');
-                const rows = await searchNotes(this.db, keyword, {
+                const rows = await searchNotes(db, keyword, {
                     includeDeleted: false,
                     tagsExpression: tagsExpression || undefined,
                     createdAtFrom,
@@ -256,7 +256,7 @@ export class MCPServer {
                 if (typeof args.id !== 'string' || !args.id.trim()) {
                     throw new Error('dinox_get_note: id is required');
                 }
-                const notes = await getNoteDetails(this.db, [args.id.trim()]);
+                const notes = await getNoteDetails(db, [args.id.trim()]);
                 const text = JSON.stringify(notes[0] ?? null);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -272,12 +272,12 @@ export class MCPServer {
                 const rawConfig = await loadConfig();
                 const config = resolveConfig(rawConfig);
                 const identity = await resolveAuthIdentity(rawConfig, config);
-                const canonicalContentMd = await canonicalizeBidlinksInMarkdown(this.db, contentMd, identity.userId);
+                const canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
                 const { contentJson, contentText } = convertMarkdownToNoteContent(canonicalContentMd);
-                const tags = await validateTagsForCreate(this.db, normalizeStringArray(args.tags));
-                const zettelBoxIds = await resolveZettelBoxIdsForCreate(this.db, normalizeStringArray(args.boxes));
+                const tags = await validateTagsForCreate(db, normalizeStringArray(args.tags));
+                const zettelBoxIds = await resolveZettelBoxIdsForCreate(db, normalizeStringArray(args.boxes));
                 const id = generateId();
-                await createNote(this.db, {
+                await createNote(db, {
                     id,
                     title,
                     noteType: 'crawl',
@@ -295,7 +295,7 @@ export class MCPServer {
                 if (typeof args.id !== 'string' || !args.id.trim()) {
                     throw new Error('dinox_graph_backlinks: id is required');
                 }
-                const result = await getBacklinks(this.db, args.id.trim());
+                const result = await getBacklinks(db, args.id.trim());
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -303,7 +303,7 @@ export class MCPServer {
                 if (typeof args.id !== 'string' || !args.id.trim()) {
                     throw new Error('dinox_graph_outlinks: id is required');
                 }
-                const result = await getOutlinks(this.db, args.id.trim());
+                const result = await getOutlinks(db, args.id.trim());
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -315,12 +315,12 @@ export class MCPServer {
                     ? Math.trunc(args.depth)
                     : 2;
                 const depth = Math.min(Math.max(depthRaw, 1), 5);
-                const result = await getRelatedNotes(this.db, args.id.trim(), depth);
+                const result = await getRelatedNotes(db, args.id.trim(), depth);
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
             case 'dinox_graph_stats': {
-                const result = await getGraphStats(this.db);
+                const result = await getGraphStats(db);
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
@@ -330,7 +330,7 @@ export class MCPServer {
                     ? args.status
                     : 'all';
                 const limit = normalizeLimit(args.limit);
-                const result = await searchTodoTasks(this.db, query, {
+                const result = await searchTodoTasks(db, query, {
                     includeDeleted: false,
                     taskStatus: status || 'all',
                     taskTagFilter: normalizeStringArray(args.tags),
@@ -340,10 +340,38 @@ export class MCPServer {
                 const text = JSON.stringify(result);
                 return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
             }
+            case NOTE_CONTENT_READ_TOOL_NAME: {
+                const runtime = await this.getRuntime();
+                const result = await this.noteContent.read(args, runtime).catch((error) => buildNoteContentToolError(error));
+                const text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case NOTE_CONTENT_EDIT_TOOL_NAME: {
+                const runtime = await this.getRuntime();
+                const operations = Array.isArray(args.operations) ? args.operations : [];
+                const result = await this.noteContent.edit({
+                    readToken: args.readToken,
+                    operations,
+                }, runtime).catch((error) => buildNoteContentToolError(error, operations));
+                const text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
     }
+    requireDb() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        return this.db;
+    }
+    async getRuntime() {
+        const rawConfig = await loadConfig();
+        const config = resolveConfig(rawConfig);
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        return { userId: identity.userId };
+    }
     async close() {
         if (this.db) {
             await this.db.close().catch(() => undefined);

package/dist/commands/mcp/tools.js

@@ -1,4 +1,5 @@
 import { listMcpCommandSchemas } from '../schema/spec.js';
+import { noteContentMcpTools } from './noteContentTools.js';
 function toMcpProperty(property) {
     if (property.type === 'string[]') {
         return {
@@ -14,7 +15,7 @@ function toMcpProperty(property) {
         ...(property.enum ? { enum: property.enum } : {}),
     };
 }
-export const mcpTools = listMcpCommandSchemas().map((schema) => {
+const schemaBackedMcpTools = listMcpCommandSchemas().map((schema) => {
     const mcp = schema.mcp;
     const properties = Object.fromEntries(mcp.properties.map((property) => [property.name, toMcpProperty(property)]));
     const required = mcp.properties.filter((property) => property.required).map((property) => property.name);
@@ -28,3 +29,4 @@ export const mcpTools = listMcpCommandSchemas().map((schema) => {
         },
     };
 });
+export const mcpTools = [...schemaBackedMcpTools, ...noteContentMcpTools];

package/dist/commands/mcp/types.d.ts

@@ -4,12 +4,16 @@ export type MCPTool = {
     inputSchema: {
         type: 'object';
         properties: Record<string, {
-            type: 'string' | 'number' | 'boolean' | 'array';
+            type: 'string' | 'number' | 'boolean' | 'array' | 'object';
             description?: string;
             enum?: string[];
             items?: {
-                type: 'string';
+                type: 'string' | 'object';
             };
+            properties?: Record<string, {
+                type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+                description?: string;
+            }>;
         }>;
         required?: string[];
     };

package/dist/commands/meta/index.js

@@ -1,32 +1,16 @@
-import { loadConfig } from '../../config/store.js';
-import { resolveConfig } from '../../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { printSuccess } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { commandStale, syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getMetaSchema, getMetaStats } from './repo.js';
-async function syncBeforeMetaCommand(db, offline, timeoutMs) {
-    if (offline) {
-        return;
-    }
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-}
 async function runMetaStats(context) {
-    const config = resolveConfig(await loadConfig());
-    const offline = Boolean(context.globals.offline);
-    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? config.sync.timeoutMs;
-    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-    try {
-        await syncBeforeMetaCommand(db, offline, timeoutMs);
+    await withCommandRuntime(context, async (runtime) => {
+        await syncBeforeCommand(runtime);
         printSuccess({
-            stale: offline ? true : stale,
-            stats: await getMetaStats(db),
+            stale: commandStale(runtime),
+            stats: await getMetaStats(runtime.db),
         });
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
+    });
 }
 async function runMetaSchema() {
     printSuccess(getMetaSchema());
@@ -42,7 +26,7 @@ export const metaCommandGroup = {
                 path: 'meta.stats',
                 risk: 'read',
                 auth: 'required',
-                globalOptions: [...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
+                globalOptions: [...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
                 output: {
                     type: 'structured',
                     summary: 'Metadata stats payload',

package/dist/commands/meta/repo.d.ts

@@ -24,9 +24,6 @@ export type MetaSchema = {
         command_schema: {
             fields: string[];
         };
-        mcp_tool: {
-            fields: string[];
-        };
     };
 };
 export declare function getMetaStats(db: AbstractPowerSyncDatabase): Promise<MetaStats>;

package/dist/commands/meta/repo.js

@@ -67,10 +67,7 @@ export function getMetaSchema() {
                 fields: ['notes_count', 'tags_count', 'boxes_count', 'latest_note_updated_at'],
             },
             command_schema: {
-                fields: ['path', 'command', 'summary', 'risk', 'auth', 'globalOptions', 'arguments', 'options', 'output', 'examples', 'mcp'],
-            },
-            mcp_tool: {
-                fields: ['name', 'description', 'inputSchema'],
+                fields: ['path', 'command', 'summary', 'risk', 'auth', 'globalOptions', 'arguments', 'options', 'output', 'examples'],
             },
         },
     };

package/dist/commands/notes/actions.d.ts

@@ -6,5 +6,7 @@ export declare function runNoteDetail({ command, options, args }: CommandExecuti
 export declare function runNoteCreate({ command, options }: CommandExecutionContext): Promise<void>;
 export declare function runNoteDelete({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteUpdate({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteTag({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteMove({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteStar({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteUnstar({ command, options, args }: CommandExecutionContext): Promise<void>;