@dinoxx/dinox-cli 1.0.15 → 1.0.17

package/dist/commands/mcp/server.js

@@ -0,0 +1,392 @@
+import { createServer } from 'node:http';
+import { DEFAULT_MCP_PORT } from './types.js';
+import { mcpTools } from './tools.js';
+import { isAuthorizedMCPRequest } from './auth.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { connectPowerSync } from '../../powersync/runtime.js';
+import { parseCreatedAtRange } from '../notes/searchTime.js';
+import { parseNoteSearchFields, projectNoteSearchFields } from '../notes/searchOutput.js';
+import { createNote, getNoteDetails, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, searchNotes, validateTagsForCreate, } from '../notes/repo.js';
+import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../graph/repo.js';
+import { searchTodoTasks } from '../todo/repo.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { generateId } from '../../utils/id.js';
+import { getPackageVersion } from '../../utils/version.js';
+const MAX_MCP_REQUEST_BYTES = 1 * 1024 * 1024;
+const DEFAULT_SEARCH_LIMIT = 50;
+const MAX_SEARCH_LIMIT = 500;
+function normalizeLimit(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_SEARCH_LIMIT;
+    }
+    const raw = typeof value === 'number'
+        ? value
+        : typeof value === 'string'
+            ? Number(value)
+            : NaN;
+    if (!Number.isFinite(raw)) {
+        return DEFAULT_SEARCH_LIMIT;
+    }
+    const int = Math.trunc(raw);
+    if (int <= 0) {
+        return DEFAULT_SEARCH_LIMIT;
+    }
+    return Math.min(int, MAX_SEARCH_LIMIT);
+}
+function normalizeOffset(value) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    const raw = typeof value === 'number'
+        ? value
+        : typeof value === 'string'
+            ? Number(value)
+            : NaN;
+    if (!Number.isFinite(raw)) {
+        return 0;
+    }
+    const int = Math.trunc(raw);
+    if (int < 0) {
+        return 0;
+    }
+    return int;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((item) => (typeof item === 'string' ? item.trim() : '')).filter(Boolean);
+}
+function parseBoxFilter(value) {
+    if (Array.isArray(value)) {
+        return { names: normalizeStringArray(value), matchEmpty: false };
+    }
+    if (typeof value !== 'string') {
+        return { names: [], matchEmpty: false };
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return { names: [], matchEmpty: false };
+    }
+    if (trimmed === '[]') {
+        return { names: [], matchEmpty: true };
+    }
+    const names = trimmed
+        .split(/[,\n]/)
+        .map((name) => name.trim())
+        .filter(Boolean);
+    return { names, matchEmpty: false };
+}
+function isJsonRpcId(value) {
+    return value === null || typeof value === 'string' || typeof value === 'number';
+}
+function parseMCPRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Invalid JSON-RPC request');
+    }
+    const record = value;
+    if (record.jsonrpc !== '2.0') {
+        throw new Error('Invalid JSON-RPC request: jsonrpc must be "2.0"');
+    }
+    if (typeof record.method !== 'string' || !record.method.trim()) {
+        throw new Error('Invalid JSON-RPC request: method is required');
+    }
+    if (record.id !== undefined && !isJsonRpcId(record.id)) {
+        throw new Error('Invalid JSON-RPC request: id must be a string, number, or null');
+    }
+    return {
+        jsonrpc: '2.0',
+        id: record.id,
+        method: record.method.trim(),
+        params: record.params,
+    };
+}
+function hasRequestId(req) {
+    return req.id !== undefined;
+}
+function buildResponse(req, payload) {
+    return {
+        jsonrpc: '2.0',
+        id: req.id ?? null,
+        ...payload,
+    };
+}
+async function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let totalBytes = 0;
+        req.on('data', (chunk) => {
+            totalBytes += chunk.length;
+            if (totalBytes > MAX_MCP_REQUEST_BYTES) {
+                req.destroy(new Error('Request body too large'));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            try {
+                const body = Buffer.concat(chunks).toString('utf-8');
+                resolve(JSON.parse(body));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+export class MCPServer {
+    db = null;
+    async initialize() {
+        const config = resolveConfig(await loadConfig());
+        const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
+        this.db = db;
+    }
+    async handleRequest(req) {
+        if (req.method === 'notifications/initialized') {
+            return hasRequestId(req) ? buildResponse(req, { result: {} }) : null;
+        }
+        const shouldRespond = hasRequestId(req);
+        try {
+            switch (req.method) {
+                case 'initialize':
+                    if (!shouldRespond) {
+                        return null;
+                    }
+                    return this.handleInitialize(req);
+                case 'tools/list':
+                    if (!shouldRespond) {
+                        return null;
+                    }
+                    return this.handleToolsList(req);
+                case 'tools/call':
+                    if (!shouldRespond) {
+                        await this.handleToolsCall(req);
+                        return null;
+                    }
+                    return await this.handleToolsCall(req);
+                default:
+                    if (!shouldRespond) {
+                        return null;
+                    }
+                    return buildResponse(req, {
+                        error: { code: -32601, message: 'Method not found' },
+                    });
+            }
+        }
+        catch (error) {
+            if (!shouldRespond) {
+                return null;
+            }
+            return buildResponse(req, {
+                error: { code: -32603, message: error.message || 'Internal error' },
+            });
+        }
+    }
+    handleInitialize(req) {
+        const result = {
+            protocolVersion: '2024-11-05',
+            capabilities: {
+                tools: {},
+            },
+            serverInfo: {
+                name: 'dinox-mcp-server',
+                version: getPackageVersion(),
+            },
+        };
+        return buildResponse(req, { result });
+    }
+    handleToolsList(req) {
+        return buildResponse(req, { result: { tools: mcpTools } });
+    }
+    async handleToolsCall(req) {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const name = req.params?.name;
+        const args = req.params?.arguments ?? {};
+        if (typeof name !== 'string') {
+            throw new Error('Invalid tools/call: missing tool name');
+        }
+        switch (name) {
+            case 'dinox_search_notes': {
+                const keyword = typeof args.query === 'string' ? args.query : '';
+                const tagsExpression = typeof args.tags === 'string' ? args.tags.trim() : '';
+                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(args.box);
+                const zettelBoxIds = await resolveZettelBoxIdsForSearch(this.db, boxNames);
+                const daysInput = typeof args.days === 'number' ? String(args.days) : args.days;
+                const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
+                    from: args.from,
+                    to: args.to,
+                    days: daysInput,
+                });
+                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, {
+                    includeDeleted: false,
+                    tagsExpression: tagsExpression || undefined,
+                    createdAtFrom,
+                    createdAtTo,
+                    zettelBoxIds,
+                    matchEmptyZettelBoxes: matchEmptyBoxes,
+                });
+                const totalCount = rows.length;
+                const paged = rows.slice(offset, offset + limit);
+                const result = projectNoteSearchFields(paged, fields);
+                const text = JSON.stringify({
+                    meta: {
+                        total_count: totalCount,
+                        returned_count: result.length,
+                        limit,
+                        offset,
+                        has_more: offset + result.length < totalCount,
+                        fields: fields ?? null,
+                    },
+                    notes: result,
+                });
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_get_note': {
+                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 text = JSON.stringify(notes[0] ?? null);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_create_note': {
+                const title = typeof args.title === 'string' ? args.title.trim() : '';
+                const contentMd = typeof args.content === 'string' ? args.content : '';
+                if (!title) {
+                    throw new Error('dinox_create_note: title is required');
+                }
+                if (!contentMd) {
+                    throw new Error('dinox_create_note: content is required');
+                }
+                const rawConfig = await loadConfig();
+                const config = resolveConfig(rawConfig);
+                const identity = await resolveAuthIdentity(rawConfig, config);
+                const { contentJson, contentText } = convertMarkdownToNoteContent(contentMd);
+                const tags = await validateTagsForCreate(this.db, normalizeStringArray(args.tags));
+                const zettelBoxIds = await resolveZettelBoxIdsForCreate(this.db, normalizeStringArray(args.boxes));
+                const id = generateId();
+                await createNote(this.db, {
+                    id,
+                    title,
+                    noteType: 'crawl',
+                    contentMd,
+                    contentText,
+                    contentJson,
+                    tags,
+                    zettelBoxIds,
+                    userId: identity.userId,
+                });
+                const text = JSON.stringify({ id });
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_graph_backlinks': {
+                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 text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_graph_outlinks': {
+                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 text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_graph_related': {
+                if (typeof args.id !== 'string' || !args.id.trim()) {
+                    throw new Error('dinox_graph_related: id is required');
+                }
+                const depthRaw = typeof args.depth === 'number' && Number.isFinite(args.depth)
+                    ? 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 text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_graph_stats': {
+                const result = await getGraphStats(this.db);
+                const text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            case 'dinox_search_todos': {
+                const query = typeof args.query === 'string' ? args.query : '';
+                const status = typeof args.status === 'string' && ['all', 'completed', 'uncompleted'].includes(args.status)
+                    ? args.status
+                    : 'all';
+                const limit = normalizeLimit(args.limit);
+                const result = await searchTodoTasks(this.db, query, {
+                    includeDeleted: false,
+                    taskStatus: status || 'all',
+                    taskTagFilter: normalizeStringArray(args.tags),
+                    limit,
+                    scanLimit: 200,
+                });
+                const text = JSON.stringify(result);
+                return buildResponse(req, { result: { content: [{ type: 'text', text }] } });
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    async close() {
+        if (this.db) {
+            await this.db.close().catch(() => undefined);
+        }
+    }
+}
+export async function startMCPServer(port = DEFAULT_MCP_PORT, host = '127.0.0.1', authToken) {
+    const mcpServer = new MCPServer();
+    await mcpServer.initialize();
+    const server = createServer(async (req, res) => {
+        if (req.method === 'POST') {
+            if (!isAuthorizedMCPRequest(req.headers, authToken)) {
+                res.writeHead(401, {
+                    'Content-Type': 'application/json',
+                    'WWW-Authenticate': 'Bearer realm="dinox-mcp"',
+                });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+            try {
+                const body = await readJsonBody(req);
+                const mcpReq = parseMCPRequest(body);
+                const mcpRes = await mcpServer.handleRequest(mcpReq);
+                if (!mcpRes) {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(mcpRes));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const statusCode = message.includes('too large') ? 413 : 400;
+                res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: message }));
+            }
+        }
+        else {
+            res.writeHead(405);
+            res.end();
+        }
+    });
+    server.headersTimeout = 5_000;
+    server.requestTimeout = 10_000;
+    server.listen(port, host, () => {
+        console.log(`MCP server listening on http://${host}:${port}`);
+    });
+    return { server, mcpServer };
+}

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

@@ -0,0 +1,2 @@
+import type { MCPTool } from './types.js';
+export declare const mcpTools: MCPTool[];

package/dist/commands/mcp/tools.js

@@ -0,0 +1,104 @@
+export const mcpTools = [
+    {
+        name: 'dinox_search_notes',
+        description: 'Search notes by keyword, tags, date range, or SQL expression',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search keyword' },
+                tags: { type: 'string', description: 'Tag expression (AND/OR/NOT)' },
+                from: { type: 'string', description: 'Start date (YYYY-MM-DD)' },
+                to: { type: 'string', description: 'End date (YYYY-MM-DD)' },
+                days: { type: 'number', description: 'Recent N days' },
+                box: { type: 'string', description: 'Zettel box name' },
+                limit: { type: 'number', description: 'Max results (default: 50)' },
+                offset: { type: 'number', description: 'Result offset (default: 0)' },
+                fields: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Returned fields: id,title,summary,tags,created_at,zettel_boxes',
+                },
+            },
+        },
+    },
+    {
+        name: 'dinox_get_note',
+        description: 'Get note details by ID',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_create_note',
+        description: 'Create a new note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Note title' },
+                content: { type: 'string', description: 'Markdown content' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                boxes: { type: 'array', items: { type: 'string' }, description: 'Zettel boxes' },
+            },
+            required: ['title', 'content'],
+        },
+    },
+    {
+        name: 'dinox_graph_backlinks',
+        description: 'Get notes that link to this note',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_graph_outlinks',
+        description: 'Get notes that this note links to',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_graph_related',
+        description: 'Get related notes within N degrees',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Note ID' },
+                depth: { type: 'number', description: 'Degrees (1-5, default: 2)' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'dinox_graph_stats',
+        description: 'Get graph statistics for notes and links',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'dinox_search_todos',
+        description: 'Search todo tasks',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Task text query' },
+                status: { type: 'string', enum: ['all', 'completed', 'uncompleted'], description: 'Task status' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' },
+                limit: { type: 'number', description: 'Max results (default: 50)' },
+            },
+        },
+    },
+];

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

@@ -0,0 +1,28 @@
+export type MCPTool = {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+};
+export type MCPResource = {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+};
+export type MCPServerInfo = {
+    name: string;
+    version: string;
+};
+export type MCPInitializeResult = {
+    protocolVersion: string;
+    capabilities: {
+        tools?: Record<string, never>;
+        resources?: Record<string, never>;
+    };
+    serverInfo: MCPServerInfo;
+};
+export declare const DEFAULT_MCP_PORT = 45137;

package/dist/commands/mcp/types.js

@@ -0,0 +1 @@
+export const DEFAULT_MCP_PORT = 45137;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerMetaCommands(program: Command): void;

package/dist/commands/meta/index.js

@@ -0,0 +1,45 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { printYaml } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/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));
+}
+export function registerMetaCommands(program) {
+    const meta = program.command('meta').description('Query Dinox metadata');
+    meta
+        .command('stats')
+        .description('Get metadata stats (notes/tags/boxes)')
+        .action(async (_options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeMetaCommand(db, offline, timeoutMs);
+            const stats = await getMetaStats(db);
+            printYaml({
+                stale: offline ? true : stale,
+                stats,
+            });
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    meta
+        .command('schema')
+        .description('Get structured Dinox data schema for AI integrations')
+        .action(() => {
+        printYaml(getMetaSchema());
+    });
+    meta.action((_options, command) => {
+        command.outputHelp();
+    });
+}

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

@@ -0,0 +1,27 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export type MetaStats = {
+    notes_count: number;
+    tags_count: number;
+    boxes_count: number;
+    latest_note_updated_at: string | null;
+};
+export type MetaSchema = {
+    version: number;
+    entities: {
+        note_search_result: {
+            fields: string[];
+            meta_fields: string[];
+        };
+        note_context: {
+            fields: string[];
+        };
+        graph_stats: {
+            fields: string[];
+        };
+        meta_stats: {
+            fields: string[];
+        };
+    };
+};
+export declare function getMetaStats(db: AbstractPowerSyncDatabase): Promise<MetaStats>;
+export declare function getMetaSchema(): MetaSchema;

package/dist/commands/meta/repo.js

@@ -0,0 +1,71 @@
+export async function getMetaStats(db) {
+    const [notesRow, tagsRow, boxesRow, latestNoteRow] = await Promise.all([
+        db.getOptional(`
+      SELECT COUNT(1) AS count
+      FROM c_note n
+      WHERE n.is_del IS NULL OR n.is_del = 0
+      `, []),
+        db.getOptional(`
+      SELECT COUNT(1) AS count
+      FROM c_tag_node t
+      WHERE t.is_del IS NULL OR t.is_del = 0
+      `, []),
+        db.getOptional(`
+      SELECT COUNT(1) AS count
+      FROM c_zettel_box b
+      WHERE b.is_del IS NULL OR b.is_del = 0
+      `, []),
+        db.getOptional(`
+      SELECT MAX(COALESCE(n.updated_at, n.created_at)) AS latest
+      FROM c_note n
+      WHERE n.is_del IS NULL OR n.is_del = 0
+      `, []),
+    ]);
+    return {
+        notes_count: Number(notesRow?.count ?? 0),
+        tags_count: Number(tagsRow?.count ?? 0),
+        boxes_count: Number(boxesRow?.count ?? 0),
+        latest_note_updated_at: latestNoteRow?.latest ?? null,
+    };
+}
+export function getMetaSchema() {
+    return {
+        version: 1,
+        entities: {
+            note_search_result: {
+                fields: ['id', 'title', 'summary', 'tags', 'created_at', 'zettel_boxes'],
+                meta_fields: [
+                    'query',
+                    'returned_count',
+                    'total_count',
+                    'stale',
+                    'pagination.limit',
+                    'pagination.offset',
+                    'pagination.has_more',
+                    'fields',
+                    'applied_filters',
+                ],
+            },
+            note_context: {
+                fields: [
+                    'id',
+                    'title',
+                    'summary',
+                    'tags',
+                    'created_at',
+                    'updated_at',
+                    'is_del',
+                    'zettel_boxes',
+                    'links.backlinks',
+                    'links.outlinks',
+                ],
+            },
+            graph_stats: {
+                fields: ['notes_count', 'links_count', 'connected_notes_count', 'isolated_notes_count'],
+            },
+            meta_stats: {
+                fields: ['notes_count', 'tags_count', 'boxes_count', 'latest_note_updated_at'],
+            },
+        },
+    };
+}