@dinoxx/dinox-cli 1.0.18 → 1.0.19

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;
@@ -269,7 +271,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 +280,7 @@ export class MCPServer {
                     id,
                     title,
                     noteType: 'crawl',
-                    contentMd,
+                    contentMd: canonicalContentMd,
                     contentText,
                     contentJson,
                     tags,
@@ -386,7 +389,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;

package/dist/commands/meta/index.js

@@ -1,8 +1,10 @@
 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 { registerCommandGroup } from '../descriptor/register.js';
+import { OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { printSuccess } from '../../utils/output.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
 import { getMetaSchema, getMetaStats } from './repo.js';
 async function syncBeforeMetaCommand(db, offline, timeoutMs) {
     if (offline) {
@@ -10,36 +12,65 @@ async function syncBeforeMetaCommand(db, offline, timeoutMs) {
     }
     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);
+        printSuccess({
+            stale: offline ? true : stale,
+            stats: await getMetaStats(db),
+        });
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}
+async function runMetaSchema() {
+    printSuccess(getMetaSchema());
+}
+export const metaCommandGroup = {
+    name: 'meta',
+    description: 'Query Dinox metadata',
+    commands: [
+        {
+            name: 'stats',
+            description: 'Get metadata stats (notes/tags/boxes)',
+            schema: {
+                path: 'meta.stats',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: [...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
+                output: {
+                    type: 'structured',
+                    summary: 'Metadata stats payload',
+                    fields: ['stale', 'stats'],
+                },
+                examples: ['dino meta stats --format json'],
+            },
+            action: runMetaStats,
+        },
+        {
+            name: 'schema',
+            description: 'Get structured Dinox data schema for AI integrations',
+            schema: {
+                path: 'meta.schema',
+                risk: 'read',
+                auth: 'none',
+                globalOptions: [],
+                output: {
+                    type: 'structured',
+                    summary: 'Structured Dinox data schema payload',
+                    fields: ['tables', 'relations', 'command_schema'],
+                },
+                examples: ['dino meta schema --format json'],
+            },
+            action: runMetaSchema,
+        },
+    ],
+};
 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();
-    });
+    registerCommandGroup(program, metaCommandGroup);
 }

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

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

package/dist/commands/meta/repo.js

@@ -66,6 +66,12 @@ export function getMetaSchema() {
             meta_stats: {
                 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'],
+            },
         },
     };
 }

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

@@ -0,0 +1,10 @@
+import type { CommandExecutionContext } from '../descriptor/types.js';
+export declare function runNoteSearch({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteGet({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNotePreview({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteDetail({ command, options, args }: CommandExecutionContext): Promise<void>;
+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 runNoteStar({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteUnstar({ command, options, args }: CommandExecutionContext): Promise<void>;