@dinoxx/dinox-cli 1.0.20 → 1.0.22

package/dist/commands/graph/index.js

@@ -1,15 +1,12 @@
-import { loadConfig } from '../../config/store.js';
-import { resolveConfig } from '../../config/resolve.js';
-import { connectPowerSync } from '../../powersync/runtime.js';
 import { sendDaemonRequest } from '../../daemon/client.js';
 import { ensureDaemonRunning } from '../../daemon/ensure.js';
 import { registerCommandGroup } from '../descriptor/register.js';
-import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { DinoxError } from '../../utils/errors.js';
 import { printSuccess } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from './repo.js';
-const GRAPH_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+const GRAPH_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 function parseDepth(value) {
     if (value === undefined || value === null || value === '') {
         return 2;
@@ -32,15 +29,7 @@ async function withOfflineDb(command, fn) {
     if (!Boolean(globals.offline)) {
         throw new DinoxError('withOfflineDb called without --offline');
     }
-    const config = resolveConfig(await loadConfig());
-    const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-    const { db } = await connectPowerSync({ config, offline: true, timeoutMs });
-    try {
-        return await fn(db);
-    }
-    finally {
-        await db.close().catch(() => undefined);
-    }
+    return withCommandRuntime(command, async ({ db }) => fn(db));
 }
 async function runGraphCommand(context, onlineAction, offlineAction) {
     const globals = context.globals;
@@ -48,6 +37,13 @@ async function runGraphCommand(context, onlineAction, offlineAction) {
         printSuccess(await withOfflineDb(context.command, offlineAction));
         return;
     }
+    if (Boolean(globals.requireSync)) {
+        await withCommandRuntime(context, async (runtime) => {
+            await syncBeforeCommand(runtime, { syncTokenIndex: true });
+            printSuccess(await offlineAction(runtime.db));
+        });
+        return;
+    }
     await ensureDaemonRunning();
     printSuccess(await onlineAction());
 }
@@ -65,11 +61,6 @@ const graphBacklinksCommand = {
             summary: 'Backlink graph payload',
             fields: ['note_id', 'backlinks'],
         },
-        mcp: {
-            toolName: 'dinox_graph_backlinks',
-            description: 'Get notes that link to this note',
-            properties: [{ name: 'id', type: 'string', description: 'Note ID', required: true }],
-        },
         examples: ['dino graph backlinks <id> --format json'],
     },
     action: async (context) => {
@@ -94,11 +85,6 @@ const graphOutlinksCommand = {
             summary: 'Outlink graph payload',
             fields: ['note_id', 'outlinks'],
         },
-        mcp: {
-            toolName: 'dinox_graph_outlinks',
-            description: 'Get notes that this note links to',
-            properties: [{ name: 'id', type: 'string', description: 'Note ID', required: true }],
-        },
         examples: ['dino graph outlinks <id> --format json'],
     },
     action: async (context) => {
@@ -124,14 +110,6 @@ const graphRelatedCommand = {
             summary: 'Related-notes graph payload',
             fields: ['note_id', 'depth', 'related_notes'],
         },
-        mcp: {
-            toolName: 'dinox_graph_related',
-            description: 'Get related notes within N degrees',
-            properties: [
-                { name: 'id', type: 'string', description: 'Note ID', required: true },
-                { name: 'depth', type: 'number', description: 'Degrees (1-5, default: 2)' },
-            ],
-        },
         examples: ['dino graph related <id> --depth 2 --format json'],
     },
     action: async (context) => {
@@ -157,11 +135,6 @@ const graphStatsCommand = {
             entity: 'graph_stats',
             fields: ['notes_count', 'links_count', 'connected_notes_count', 'isolated_notes_count'],
         },
-        mcp: {
-            toolName: 'dinox_graph_stats',
-            description: 'Get graph statistics for notes and links',
-            properties: [],
-        },
         examples: ['dino graph stats --format json'],
     },
     action: async (context) => {

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

@@ -0,0 +1,222 @@
+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 {};