@dinoxx/dinox-cli 1.0.22 → 1.1.1

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

@@ -1,222 +0,0 @@
-import type { AbstractPowerSyncDatabase } from '@powersync/common';
-import { type NoteEditOperation, type TiptapJsonNode } from '../../utils/noteContentEngine.js';
-import type { MCPTool } from './types.js';
-export declare const NOTE_CONTENT_READ_TOOL_NAME = "noteContentRead";
-export declare const NOTE_CONTENT_EDIT_TOOL_NAME = "noteContentEdit";
-type ReadInput = {
-    noteId: string;
-    from?: number | null;
-    cursor?: {
-        from: number;
-        contentHash?: string | null;
-    } | null;
-    nodeRange?: string | null;
-    includeJson?: boolean | null;
-    maxChars?: number | null;
-    maxNodes?: number | null;
-};
-type EditInput = {
-    readToken: string;
-    operations: NoteEditOperation[];
-};
-type Runtime = {
-    userId: string;
-};
-export declare const noteContentMcpTools: MCPTool[];
-export declare class NoteContentMcpService {
-    #private;
-    private readonly getDatabase;
-    private readonly now;
-    constructor(getDatabase: () => AbstractPowerSyncDatabase, now?: () => number);
-    read(input: ReadInput, runtime: Runtime): Promise<{
-        range?: {
-            json?: TiptapJsonNode[] | undefined;
-            nodeRange: string;
-            nodeRangeTuple: readonly [number, number];
-            format: "dinox-shorthand";
-            from: number;
-            text: string;
-            textHash: string;
-            nodeHash: string;
-            preferredTarget: {
-                nodeRange: string;
-                anchorIds: string[];
-                expectedTextHash: string;
-                expectedNodeHash: string;
-            };
-            shorthand: string;
-            markdown: string;
-            textWindow: {
-                offset: number;
-                length: number;
-                total: number;
-                nextOffset: number | null;
-            };
-            shorthandWindow: {
-                offset: number;
-                length: number;
-                total: number;
-                nextOffset: number | null;
-            };
-            markdownWindow: {
-                offset: number;
-                length: number;
-                total: number;
-                nextOffset: number | null;
-            };
-            isTruncated: boolean;
-            nextCursor: {
-                from: number;
-                contentHash: string;
-            } | null;
-        } | undefined;
-        success: boolean;
-        hasError: boolean;
-        docChanged: boolean;
-        document: null;
-        noteId: string;
-        title: string;
-        readToken: string;
-        readTokenExpiresAt: string;
-        base: {
-            contentHash: string;
-            updatedAt: string | null;
-            version: number | null;
-        };
-        totalNodes: number;
-        totalCharCount: number;
-        estimatedTokens: number;
-        from: number;
-        nodeRange: readonly [number, number];
-        format: "dinox-shorthand";
-        content: string;
-        canReadMore: boolean;
-        nextCursor: {
-            from: number;
-            contentHash: string;
-        } | null;
-        schema: {
-            version: string;
-            readFormat: string;
-            editProtocol: string;
-            operations: ("insertBlocksAfter" | "insertBlocksBefore" | "replaceBlocks" | "deleteBlocks" | "replaceText" | "updateBlockAttrs" | "replaceContainerContent")[];
-        };
-        readFormatInstructions: string;
-        chunks: {
-            index: number;
-            nodeRange: string;
-            anchorIds: string[];
-            textPreview: string;
-            charCount: number;
-            estimatedTokens: number;
-        }[];
-        blocks: {
-            preferredTarget: {
-                anchorId: string;
-                nodeRange: string;
-                expectedTextHash: string;
-                expectedNodeHash: string;
-            };
-            anchorId: string;
-            hasStableAnchor: boolean;
-            nodeIndex: number;
-            nodeRange: string;
-            type: string;
-            editMode: string;
-            level: number | null;
-            textPreview: string;
-            textHash: string;
-            nodeHash: string;
-            charCount: number;
-            attrs: Record<string, unknown> | undefined;
-        }[];
-        page: {
-            json?: TiptapJsonNode[] | undefined;
-            nodeRange: string;
-            nodeRangeTuple: readonly [number, number];
-            format: "dinox-shorthand";
-            from: number;
-            text: string;
-            textHash: string;
-            nodeHash: string;
-            preferredTarget: {
-                nodeRange: string;
-                anchorIds: string[];
-                expectedTextHash: string;
-                expectedNodeHash: string;
-            };
-            shorthand: string;
-            markdown: string;
-            textWindow: {
-                offset: number;
-                length: number;
-                total: number;
-                nextOffset: number | null;
-            };
-            shorthandWindow: {
-                offset: number;
-                length: number;
-                total: number;
-                nextOffset: number | null;
-            };
-            markdownWindow: {
-                offset: number;
-                length: number;
-                total: number;
-                nextOffset: number | null;
-            };
-            isTruncated: boolean;
-            nextCursor: {
-                from: number;
-                contentHash: string;
-            } | null;
-        };
-    }>;
-    edit(input: EditInput, runtime: Runtime): Promise<{
-        success: boolean;
-        hasError: boolean;
-        docChanged: boolean;
-        document: null;
-        saved: boolean;
-        noteId: string;
-        title: string;
-        changed: boolean;
-        appliedOperations: number;
-        operationResults: {
-            operationIndex: number;
-            type: "insertBlocksAfter" | "insertBlocksBefore" | "replaceBlocks" | "deleteBlocks" | "replaceText" | "updateBlockAttrs" | "replaceContainerContent";
-            success: boolean;
-            target: string;
-            nodeRange: string;
-            error: null;
-        }[];
-        updatedAt: string | null;
-        before: {
-            contentHash: string;
-            totalNodes: number;
-        };
-        after: {
-            contentHash: string;
-            totalNodes: number;
-            version: number | null;
-        };
-    }>;
-}
-export declare function buildNoteContentToolError(error: unknown, operations?: NoteEditOperation[]): {
-    success: boolean;
-    hasError: boolean;
-    docChanged: boolean;
-    document: null;
-    reason: string;
-    error: string;
-    shouldRetry: boolean;
-    operationResults: {
-        operationIndex: number;
-        type: "insertBlocksAfter" | "insertBlocksBefore" | "replaceBlocks" | "deleteBlocks" | "replaceText" | "updateBlockAttrs" | "replaceContainerContent";
-        success: boolean;
-        target: string;
-        nodeRange: null;
-        error: string;
-    }[];
-};
-export {};

package/dist/commands/mcp/noteContentTools.js

@@ -1,390 +0,0 @@
-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

@@ -1,34 +0,0 @@
-import type { IncomingMessage, Server } from 'node:http';
-type JsonRpcId = string | number | null;
-type MCPRequest = {
-    jsonrpc: '2.0';
-    id?: JsonRpcId;
-    method: string;
-    params?: any;
-};
-type MCPResponse = {
-    jsonrpc: '2.0';
-    id: JsonRpcId;
-    result?: any;
-    error?: {
-        code: number;
-        message: string;
-    };
-};
-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<{
-    server: Server<typeof IncomingMessage, typeof import("http").ServerResponse>;
-    mcpServer: MCPServer;
-}>;
-export {};