@dinoxx/dinox-cli 1.0.18 → 1.0.20

package/dist/commands/graph/index.js

@@ -1,12 +1,15 @@
-import { printYaml } from '../../utils/output.js';
-import { sendDaemonRequest } from '../../daemon/client.js';
-import { ensureDaemonRunning } from '../../daemon/ensure.js';
-import { DinoxError } from '../../utils/errors.js';
 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 { DinoxError } from '../../utils/errors.js';
+import { printSuccess } from '../../utils/output.js';
 import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from './repo.js';
+const GRAPH_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
 function parseDepth(value) {
     if (value === undefined || value === null || value === '') {
         return 2;
@@ -26,8 +29,7 @@ function parseDepth(value) {
 }
 async function withOfflineDb(command, fn) {
     const globals = command.optsWithGlobals?.() ?? {};
-    const offline = Boolean(globals.offline);
-    if (!offline) {
+    if (!Boolean(globals.offline)) {
         throw new DinoxError('withOfflineDb called without --offline');
     }
     const config = resolveConfig(await loadConfig());
@@ -40,74 +42,142 @@ async function withOfflineDb(command, fn) {
         await db.close().catch(() => undefined);
     }
 }
-export function registerGraphCommands(program) {
-    const graph = program.command('graph').description('Query knowledge graph');
-    graph
-        .command('backlinks')
-        .description('Get notes that link to this note')
-        .argument('<id>', 'note id')
-        .action(async (id, _options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        if (offline) {
-            const result = await withOfflineDb(command, (db) => getBacklinks(db, id));
-            printYaml(result);
-            return;
-        }
-        await ensureDaemonRunning();
-        const result = await sendDaemonRequest('graph.backlinks', { id });
-        printYaml(result);
-    });
-    graph
-        .command('outlinks')
-        .description('Get notes that this note links to')
-        .argument('<id>', 'note id')
-        .action(async (id, _options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        if (offline) {
-            const result = await withOfflineDb(command, (db) => getOutlinks(db, id));
-            printYaml(result);
-            return;
+async function runGraphCommand(context, onlineAction, offlineAction) {
+    const globals = context.globals;
+    if (Boolean(globals.offline)) {
+        printSuccess(await withOfflineDb(context.command, offlineAction));
+        return;
+    }
+    await ensureDaemonRunning();
+    printSuccess(await onlineAction());
+}
+const graphBacklinksCommand = {
+    name: 'backlinks',
+    description: 'Get notes that link to a target note',
+    arguments: [{ syntax: '<id>', description: 'Note id' }],
+    schema: {
+        path: 'graph.backlinks',
+        risk: 'read',
+        auth: 'required',
+        globalOptions: GRAPH_GLOBAL_OPTIONS,
+        output: {
+            type: 'structured',
+            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) => {
+        const id = context.args.id;
+        if (!id) {
+            throw new DinoxError('Note id is required');
         }
-        await ensureDaemonRunning();
-        const result = await sendDaemonRequest('graph.outlinks', { id });
-        printYaml(result);
-    });
-    graph
-        .command('stats')
-        .description('Get graph statistics')
-        .action(async (_options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        if (offline) {
-            const result = await withOfflineDb(command, (db) => getGraphStats(db));
-            printYaml(result);
-            return;
+        await runGraphCommand(context, () => sendDaemonRequest('graph.backlinks', { id }), (db) => getBacklinks(db, id));
+    },
+};
+const graphOutlinksCommand = {
+    name: 'outlinks',
+    description: 'Get notes that this note links to',
+    arguments: [{ syntax: '<id>', description: 'Note id' }],
+    schema: {
+        path: 'graph.outlinks',
+        risk: 'read',
+        auth: 'required',
+        globalOptions: GRAPH_GLOBAL_OPTIONS,
+        output: {
+            type: 'structured',
+            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) => {
+        const id = context.args.id;
+        if (!id) {
+            throw new DinoxError('Note id is required');
         }
-        await ensureDaemonRunning();
-        const result = await sendDaemonRequest('graph.stats');
-        printYaml(result);
-    });
-    graph
-        .command('related')
-        .description('Get related notes within N degrees of separation')
-        .argument('<id>', 'note id')
-        .option('--depth <n>', 'degrees of separation (1-5, default: 2)')
-        .action(async (id, options, command) => {
-        const depth = parseDepth(options.depth);
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        if (offline) {
-            const result = await withOfflineDb(command, (db) => getRelatedNotes(db, id, depth));
-            printYaml(result);
-            return;
+        await runGraphCommand(context, () => sendDaemonRequest('graph.outlinks', { id }), (db) => getOutlinks(db, id));
+    },
+};
+const graphRelatedCommand = {
+    name: 'related',
+    description: 'Get notes related within N degrees of separation',
+    arguments: [{ syntax: '<id>', description: 'Note id' }],
+    options: [{ flags: '--depth <n>', description: 'Degrees of separation (1-5)', defaultValue: '2' }],
+    schema: {
+        path: 'graph.related',
+        risk: 'read',
+        auth: 'required',
+        globalOptions: GRAPH_GLOBAL_OPTIONS,
+        output: {
+            type: 'structured',
+            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) => {
+        const id = context.args.id;
+        if (!id) {
+            throw new DinoxError('Note id is required');
         }
-        await ensureDaemonRunning();
-        const result = await sendDaemonRequest('graph.related', { id, depth });
-        printYaml(result);
-    });
-    graph.action((_options, command) => {
-        command.outputHelp();
-    });
+        const depth = parseDepth(context.options.depth);
+        await runGraphCommand(context, () => sendDaemonRequest('graph.related', { id, depth }), (db) => getRelatedNotes(db, id, depth));
+    },
+};
+const graphStatsCommand = {
+    name: 'stats',
+    description: 'Get graph statistics for notes and links',
+    schema: {
+        path: 'graph.stats',
+        risk: 'read',
+        auth: 'required',
+        globalOptions: GRAPH_GLOBAL_OPTIONS,
+        output: {
+            type: 'structured',
+            summary: 'Graph statistics payload',
+            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) => {
+        await runGraphCommand(context, () => sendDaemonRequest('graph.stats'), (db) => getGraphStats(db));
+    },
+};
+export const graphCommandGroup = {
+    name: 'graph',
+    description: 'Query knowledge graph',
+    commands: [
+        graphBacklinksCommand,
+        graphOutlinksCommand,
+        graphRelatedCommand,
+        graphStatsCommand,
+    ],
+};
+export function registerGraphCommands(program) {
+    registerCommandGroup(program, graphCommandGroup);
 }

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandDescriptor } from '../descriptor/types.js';
+export declare const infoCommandDescriptor: CommandDescriptor;
 export declare function registerInfoCommand(program: Command): void;

package/dist/commands/info/index.js

@@ -1,23 +1,50 @@
+import { registerStandaloneCommand } from '../descriptor/register.js';
+import { FORMAT_OPTIONS } from '../schema/globalOptions.js';
 import { SKILLS_REPO_URL } from '../../constants/links.js';
-import { printYaml } from '../../utils/output.js';
+import { clearPendingStructuredNoticeProvider, getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, setPendingStructuredNoticeProvider, } from '../../utils/output.js';
+import { getUpdateNotice } from '../../utils/updateNotice.js';
 import { getPackageVersion } from '../../utils/version.js';
-export function registerInfoCommand(program) {
-    program
-        .command('info')
-        .description('Show CLI version info')
-        .action((_options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const jsonOutput = Boolean(globals.json);
+export const infoCommandDescriptor = {
+    name: 'info',
+    description: 'Show CLI version and bundled skills location',
+    schema: {
+        path: 'info',
+        risk: 'read',
+        auth: 'none',
+        globalOptions: FORMAT_OPTIONS,
+        output: {
+            type: 'structured',
+            summary: 'CLI version metadata',
+            fields: ['name', 'version', 'skills_repo'],
+        },
+        examples: ['dino info', 'dino info --format json'],
+    },
+    action: async (_context) => {
+        const version = getPackageVersion();
         const payload = {
             name: 'dino',
-            version: getPackageVersion(),
+            version,
             skills_repo: SKILLS_REPO_URL,
         };
-        if (jsonOutput) {
-            printYaml(payload);
+        if (getRequestedStructuredOutputFormat()) {
+            const updateNotice = await getUpdateNotice(version);
+            setPendingStructuredNoticeProvider(() => updateNotice
+                ? {
+                    update: updateNotice,
+                }
+                : null);
+            try {
+                printSuccess(payload);
+            }
+            finally {
+                clearPendingStructuredNoticeProvider();
+            }
             return;
         }
-        console.log(payload.version);
-        console.log(`skills repo: ${payload.skills_repo}`);
-    });
+        printHumanReadableLine(payload.version);
+        printHumanReadableLine(`skills repo: ${payload.skills_repo}`);
+    },
+};
+export function registerInfoCommand(program) {
+    registerStandaloneCommand(program, infoCommandDescriptor);
 }

package/dist/commands/mcp/index.js

@@ -3,6 +3,7 @@ import { mcpTools } from './tools.js';
 import { isLoopbackHost, resolveMCPAuthToken } from './auth.js';
 import { DEFAULT_MCP_PORT } from './types.js';
 import { DinoxError } from '../../utils/errors.js';
+import { printHumanReadableLine } from '../../utils/output.js';
 function parsePort(value) {
     if (value === undefined || value === null || value === '') {
         return DEFAULT_MCP_PORT;
@@ -49,20 +50,20 @@ export function registerMCPCommands(program) {
         if (!loopback && !token) {
             throw new DinoxError('--token (or DINOX_MCP_TOKEN) is required when --host is non-loopback');
         }
-        console.log('Starting Dinox MCP server...');
-        console.log(`Host: ${host}`);
-        console.log(`Port: ${port}`);
-        console.log(`Auth: ${token ? 'enabled' : 'disabled (loopback only)'}`);
-        console.log('Protocol: Model Context Protocol (MCP)');
+        printHumanReadableLine('Starting Dinox MCP server...');
+        printHumanReadableLine(`Host: ${host}`);
+        printHumanReadableLine(`Port: ${port}`);
+        printHumanReadableLine(`Auth: ${token ? 'enabled' : 'disabled (loopback only)'}`);
+        printHumanReadableLine('Protocol: Model Context Protocol (MCP)');
         if (!loopback) {
-            console.log('warning: binding to a non-loopback host may expose your local data; use firewall/auth as needed');
+            printHumanReadableLine('warning: binding to a non-loopback host may expose your local data; use firewall/auth as needed');
         }
-        console.log('');
-        console.log('Available tools:');
+        printHumanReadableLine('');
+        printHumanReadableLine('Available tools:');
         for (const tool of mcpTools) {
-            console.log(`  - ${tool.name}`);
+            printHumanReadableLine(`  - ${tool.name}`);
         }
-        console.log('');
+        printHumanReadableLine('');
         const { server, mcpServer } = await startMCPServer(port, host, token);
         let shuttingDown = false;
         const shutdown = async () => {

package/dist/commands/mcp/server.js

@@ -6,6 +6,7 @@ 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 { canonicalizeBidlinksInMarkdown } from '../../utils/bidlinkCanonicalization.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';
@@ -13,6 +14,7 @@ import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../gr
 import { searchTodoTasks } from '../todo/repo.js';
 import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
 import { generateId } from '../../utils/id.js';
+import { printHumanReadableLine } from '../../utils/output.js';
 import { getPackageVersion } from '../../utils/version.js';
 const MAX_MCP_REQUEST_BYTES = 1 * 1024 * 1024;
 const DEFAULT_SEARCH_LIMIT = 50;
@@ -214,7 +216,8 @@ export class MCPServer {
             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 rawBoxes = args.boxes ?? args.box;
+                const { names: boxNames, matchEmpty: matchEmptyBoxes } = parseBoxFilter(rawBoxes);
                 const zettelBoxIds = await resolveZettelBoxIdsForSearch(this.db, boxNames);
                 const daysInput = typeof args.days === 'number' ? String(args.days) : args.days;
                 const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
@@ -269,7 +272,8 @@ export class MCPServer {
                 const rawConfig = await loadConfig();
                 const config = resolveConfig(rawConfig);
                 const identity = await resolveAuthIdentity(rawConfig, config);
-                const { contentJson, contentText } = convertMarkdownToNoteContent(contentMd);
+                const canonicalContentMd = await canonicalizeBidlinksInMarkdown(this.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 id = generateId();
@@ -277,7 +281,7 @@ export class MCPServer {
                     id,
                     title,
                     noteType: 'crawl',
-                    contentMd,
+                    contentMd: canonicalContentMd,
                     contentText,
                     contentJson,
                     tags,
@@ -386,7 +390,7 @@ export async function startMCPServer(port = DEFAULT_MCP_PORT, host = '127.0.0.1'
     server.headersTimeout = 5_000;
     server.requestTimeout = 10_000;
     server.listen(port, host, () => {
-        console.log(`MCP server listening on http://${host}:${port}`);
+        printHumanReadableLine(`MCP server listening on http://${host}:${port}`);
     });
     return { server, mcpServer };
 }

package/dist/commands/mcp/tools.js

@@ -1,104 +1,30 @@
-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)' },
-            },
-        },
-    },
-];
+import { listMcpCommandSchemas } from '../schema/spec.js';
+function toMcpProperty(property) {
+    if (property.type === 'string[]') {
+        return {
+            type: 'array',
+            items: { type: 'string' },
+            ...(property.description ? { description: property.description } : {}),
+            ...(property.enum ? { enum: property.enum } : {}),
+        };
+    }
+    return {
+        type: property.type,
+        ...(property.description ? { description: property.description } : {}),
+        ...(property.enum ? { enum: property.enum } : {}),
+    };
+}
+export const mcpTools = 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);
+    return {
+        name: mcp.toolName,
+        description: mcp.description,
+        inputSchema: {
+            type: 'object',
+            properties,
+            ...(required.length > 0 ? { required } : {}),
+        },
+    };
+});

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

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

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const metaCommandGroup: CommandGroupDescriptor;
 export declare function registerMetaCommands(program: Command): void;