@dinoxx/dinox-cli 1.0.18 → 1.0.20

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>;

package/dist/commands/notes/actions.js

@@ -0,0 +1,403 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { canonicalizeBidlinksInMarkdown } from '../../utils/bidlinkCanonicalization.js';
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { generateId } from '../../utils/id.js';
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { DinoxError } from '../../utils/errors.js';
+import { waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { createNote, getNote, getNoteContext, getNoteDetails, getNotePreview, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+import { buildNoteCreateDryRunPreview, buildNoteDeleteDryRunPreview, buildNoteUpdateDryRunPreview, } from './dryRun.js';
+import { parseNoteSearchFields, projectNoteSearchFields } from './searchOutput.js';
+import { parseCreatedAtRange } from './searchTime.js';
+import { buildNoteSearchResponse, normalizeDaysForMeta } from './searchResponse.js';
+import { parseNoteType, parsePreviewLineCount, parseSearchLimit, parseSearchListInput, parseSearchOffset, parseStarredOption, parseStringInput, parseStringListInput, parseTargetNoteIds, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+function toPublicNoteContext(note) {
+    if (!note) {
+        return null;
+    }
+    const { zettel_boxes, ...rest } = note;
+    return {
+        ...rest,
+        boxes: zettel_boxes,
+    };
+}
+function toPublicNoteDetail(note) {
+    const { zettel_boxes, ...rest } = note;
+    return {
+        ...rest,
+        boxes: zettel_boxes,
+    };
+}
+function toPublicNote(note) {
+    if (!note) {
+        return null;
+    }
+    const { zettel_boxes, ...rest } = note;
+    return {
+        ...rest,
+        ...(zettel_boxes !== undefined ? { boxes: zettel_boxes } : {}),
+    };
+}
+async function settleMutation(db, timeoutMs) {
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
+}
+async function executeNoteUpdateOperation(args) {
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(args.command, async ({ db, config, offline, timeoutMs, stale }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        const ids = await parseTargetNoteIds(args.id, args.idsOption, 'update');
+        const hasTags = typeof args.tagsOption === 'string';
+        const hasBoxes = typeof args.boxOption === 'string';
+        const hasStarred = typeof args.starred === 'boolean';
+        if (!hasTags && !hasBoxes && !hasStarred) {
+            throw new DinoxError('At least one option is required: --tags, --boxes, or --starred');
+        }
+        const tags = hasTags
+            ? await validateTagsForUpdate(db, await parseStringListInput(args.tagsOption, '--tags'))
+            : undefined;
+        const zettelBoxIds = hasBoxes
+            ? await resolveZettelBoxIdsForUpdate(db, await parseStringListInput(args.boxOption, '--boxes'))
+            : undefined;
+        await assertNotesUpdatable(db, ids);
+        if (args.dryRun) {
+            const preview = await buildNoteUpdateDryRunPreview({
+                db,
+                config,
+                offline,
+                ids,
+                tagsInput: tags,
+                zettelBoxNames: hasBoxes ? await parseStringListInput(args.boxOption, '--boxes') : undefined,
+                starred: hasStarred ? args.starred : undefined,
+                commandName: args.commandName ?? 'dino note update',
+                action: args.actionName ?? 'update_note',
+            });
+            printDryRunPreview(preview);
+            return;
+        }
+        const results = [];
+        for (const targetId of ids) {
+            results.push(await updateNote(db, {
+                id: targetId,
+                tags,
+                zettelBoxIds,
+                starred: hasStarred ? args.starred : undefined,
+            }));
+        }
+        const updatedCount = results.filter((item) => item.updated).length;
+        if (!offline && !config.powersync.uploadBaseUrl) {
+            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
+        }
+        if (!offline) {
+            await settleMutation(db, timeoutMs);
+        }
+        const payload = {
+            ok: true,
+            total: results.length,
+            updatedCount,
+            results: results.map((item) => ({
+                id: item.id,
+                updated: item.updated,
+                tags: item.tags,
+                boxes: item.zettelBoxIds,
+                is_starred: item.is_starred,
+            })),
+            stale: offline ? true : stale,
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        if (results.length === 1) {
+            if (!args.actionLabel) {
+                printHumanReadableLine(results[0].updated ? 'OK' : 'No changes');
+            }
+            else if (results[0].updated) {
+                printHumanReadableLine(args.actionLabel);
+            }
+            else {
+                printHumanReadableLine(`Already ${args.staleVerb ?? args.actionLabel.toLowerCase()}`);
+            }
+        }
+        else if (args.actionLabel) {
+            printHumanReadableLine(`${args.actionLabel} ${updatedCount}/${results.length} notes`);
+        }
+        else {
+            printHumanReadableLine(`Updated ${updatedCount}/${results.length} notes`);
+        }
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    });
+}
+export async function runNoteSearch({ command, options, args }) {
+    const searchOptions = options;
+    await withNoteDatabase(command, async ({ db, offline, timeoutMs, stale }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        const keyword = args.query?.trim() ?? '';
+        const tagsExpression = typeof searchOptions.tags === 'string' ? searchOptions.tags.trim() : '';
+        const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
+            from: searchOptions.from,
+            to: searchOptions.to,
+            days: searchOptions.days,
+        });
+        const starred = typeof searchOptions.starred === 'string'
+            ? parseStarredOption(searchOptions.starred, '--starred')
+            : undefined;
+        const boxInput = typeof searchOptions.boxes === 'string' ? searchOptions.boxes : '';
+        const parsedBoxInput = boxInput
+            ? await parseSearchListInput(boxInput, '--boxes')
+            : { values: [], isExplicitEmptyArray: false };
+        const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, parsedBoxInput.values);
+        const sqlExpression = typeof searchOptions.sql === 'string' ? searchOptions.sql.trim() : '';
+        const limit = parseSearchLimit(searchOptions.limit);
+        const offset = parseSearchOffset(searchOptions.offset);
+        const fields = parseNoteSearchFields(searchOptions.fields, '--fields');
+        const rows = await searchNotes(db, keyword, {
+            includeDeleted: Boolean(searchOptions.includeDeleted),
+            tagsExpression: tagsExpression || undefined,
+            createdAtFrom,
+            createdAtTo,
+            starred,
+            zettelBoxIds,
+            matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
+            sqlExpression: sqlExpression || undefined,
+        });
+        printSuccess(buildNoteSearchResponse({
+            query: keyword,
+            notes: projectNoteSearchFields(rows.slice(offset, offset + limit), fields),
+            totalCount: rows.length,
+            stale: offline ? true : stale,
+            includeDeleted: Boolean(searchOptions.includeDeleted),
+            limit,
+            offset,
+            fields,
+            tagsExpression: tagsExpression || undefined,
+            createdAtFrom,
+            createdAtTo,
+            days: normalizeDaysForMeta(searchOptions.days),
+            starred,
+            boxNames: parsedBoxInput.values,
+            boxIds: zettelBoxIds,
+            matchEmptyBoxes: parsedBoxInput.isExplicitEmptyArray,
+            sqlExpression: sqlExpression || undefined,
+        }));
+    });
+}
+export async function runNoteGet({ command, options, args }) {
+    const getOptions = options;
+    const id = args.id;
+    if (!id) {
+        throw new DinoxError('Note id is required');
+    }
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(command, async ({ db, offline, timeoutMs, stale }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        if (getOptions.contextOnly) {
+            const context = await getNoteContext(db, id);
+            if (!context) {
+                throw new DinoxError(`Note not found: ${id}`, {
+                    code: 'NOTE_NOT_FOUND',
+                    suggestion: "Run 'dino note search <keyword>' to locate the note id.",
+                    recoverable: true,
+                });
+            }
+            printSuccess({ stale: offline ? true : stale, note: toPublicNoteContext(context) });
+            return;
+        }
+        const note = await getNote(db, id);
+        if (!note) {
+            throw new DinoxError(`Note not found: ${id}`, {
+                code: 'NOTE_NOT_FOUND',
+                suggestion: "Run 'dino note search <keyword>' to locate the note id.",
+                recoverable: true,
+            });
+        }
+        if (structuredOutput) {
+            printSuccess({ stale, note: toPublicNote(note) });
+            return;
+        }
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; result may be stale');
+        }
+        printHumanReadableLine(`${note.id}`);
+        printHumanReadableLine(`title: ${note.title ?? ''}`);
+        if (note.updated_at) {
+            printHumanReadableLine(`updated_at: ${note.updated_at}`);
+        }
+        if (note.is_starred) {
+            printHumanReadableLine('is_starred: 1');
+        }
+        if (note.is_del) {
+            printHumanReadableLine('is_del: 1');
+        }
+    });
+}
+export async function runNotePreview({ command, options, args }) {
+    const previewOptions = options;
+    const id = args.id;
+    if (!id) {
+        throw new DinoxError('Note id is required');
+    }
+    await withNoteDatabase(command, async ({ db, offline, timeoutMs, stale }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        const preview = await getNotePreview(db, id, parsePreviewLineCount(previewOptions.lines));
+        if (!preview) {
+            throw new DinoxError(`Note not found: ${id}`, {
+                code: 'NOTE_NOT_FOUND',
+                suggestion: "Run 'dino note search <keyword>' to locate the note id.",
+                recoverable: true,
+            });
+        }
+        printSuccess({ stale: offline ? true : stale, note: preview });
+    });
+}
+export async function runNoteDetail({ command, options, args }) {
+    const detailOptions = options;
+    await withNoteDatabase(command, async ({ db, offline, timeoutMs }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        const ids = await parseTargetNoteIds(args.id, detailOptions.ids, 'detail');
+        const notes = await getNoteDetails(db, ids);
+        const foundIds = new Set(notes.map((note) => note.id));
+        const missing = ids.filter((noteId) => !foundIds.has(noteId));
+        if (missing.length > 0) {
+            throw new DinoxError(ids.length === 1 ? `Note not found: ${missing[0]}` : `Notes not found: ${missing.join(', ')}`);
+        }
+        const publicNotes = notes.map((note) => toPublicNoteDetail(note));
+        printSuccess(publicNotes.length === 1 ? publicNotes[0] : publicNotes);
+    });
+}
+export async function runNoteCreate({ command, options }) {
+    const createOptions = options;
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(command, async ({ db, rawConfig, config, offline, timeoutMs, stale }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        const contentMd = await parseStringInput(String(createOptions.content));
+        const canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
+        const { contentJson, contentText } = convertMarkdownToNoteContent(canonicalContentMd);
+        const tagsInput = typeof createOptions.tags === 'string'
+            ? await parseStringListInput(createOptions.tags, '--tags')
+            : [];
+        const boxNames = typeof createOptions.boxes === 'string'
+            ? await parseStringListInput(createOptions.boxes, '--boxes')
+            : [];
+        const noteType = parseNoteType(createOptions.type);
+        if (Boolean(createOptions.dryRun)) {
+            printDryRunPreview(await buildNoteCreateDryRunPreview({
+                db,
+                config,
+                offline,
+                userId: identity.userId,
+                title: String(createOptions.title),
+                noteType,
+                contentMd,
+                tagsInput,
+                zettelBoxNames: boxNames,
+            }));
+            return;
+        }
+        const id = generateId();
+        await createNote(db, {
+            id,
+            title: String(createOptions.title),
+            noteType,
+            contentMd: canonicalContentMd,
+            contentJson,
+            contentText,
+            tags: await validateTagsForCreate(db, tagsInput),
+            zettelBoxIds: await resolveZettelBoxIdsForCreate(db, boxNames),
+            userId: identity.userId,
+        });
+        if (!offline && !config.powersync.uploadBaseUrl) {
+            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
+        }
+        if (!offline) {
+            await settleMutation(db, timeoutMs);
+        }
+        const payload = { ok: true, id, stale: offline ? true : stale };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(id);
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    });
+}
+export async function runNoteDelete({ command, options, args }) {
+    const deleteOptions = options;
+    const id = args.id;
+    if (!id) {
+        throw new DinoxError('Note id is required');
+    }
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(command, async ({ db, config, offline, timeoutMs, stale }) => {
+        await syncBeforeNoteCommand(db, offline, timeoutMs);
+        if (Boolean(deleteOptions.dryRun)) {
+            printDryRunPreview(await buildNoteDeleteDryRunPreview({ db, config, offline, id }));
+            return;
+        }
+        await softDeleteNote(db, id);
+        if (!offline && !config.powersync.uploadBaseUrl) {
+            printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
+        }
+        if (!offline) {
+            await settleMutation(db, timeoutMs);
+        }
+        const payload = { ok: true, id, stale: offline ? true : stale };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine('OK');
+        if (stale && !offline) {
+            printHumanReadableLine('warning: sync timed out; local cache may be stale');
+        }
+    });
+}
+export async function runNoteUpdate({ command, options, args }) {
+    const updateOptions = options;
+    await executeNoteUpdateOperation({
+        boxOption: updateOptions.boxes,
+        command,
+        dryRun: Boolean(updateOptions.dryRun),
+        id: args.id,
+        idsOption: updateOptions.ids,
+        starred: typeof updateOptions.starred === 'string'
+            ? parseStarredOption(updateOptions.starred, '--starred')
+            : undefined,
+        tagsOption: updateOptions.tags,
+        commandName: 'dino note update',
+        actionName: 'update_note',
+    });
+}
+export async function runNoteStar({ command, options, args }) {
+    const starOptions = options;
+    await executeNoteUpdateOperation({
+        actionLabel: 'Starred',
+        command,
+        dryRun: Boolean(starOptions.dryRun),
+        id: args.id,
+        idsOption: starOptions.ids,
+        starred: true,
+        staleVerb: 'starred',
+        commandName: 'dino note star',
+        actionName: 'star_note',
+    });
+}
+export async function runNoteUnstar({ command, options, args }) {
+    const unstarOptions = options;
+    await executeNoteUpdateOperation({
+        actionLabel: 'Unstarred',
+        command,
+        dryRun: Boolean(unstarOptions.dryRun),
+        id: args.id,
+        idsOption: unstarOptions.ids,
+        starred: false,
+        staleVerb: 'unstarred',
+        commandName: 'dino note unstar',
+        actionName: 'unstar_note',
+    });
+}

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

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