@dinoxx/dinox-cli 1.0.18 → 1.0.20

package/dist/commands/notes/descriptors.js

@@ -0,0 +1,250 @@
+import { registerCommandGroup } from '../descriptor/register.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { runNoteCreate, runNoteDelete, runNoteDetail, runNoteGet, runNotePreview, runNoteSearch, runNoteStar, runNoteUnstar, runNoteUpdate, } from './actions.js';
+const NOTE_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+export const noteCommandGroup = {
+    name: 'note',
+    description: 'Manage notes',
+    commands: [
+        {
+            name: 'search',
+            description: 'Search notes by keyword, tags, date range, boxes, or SQL-like filter',
+            arguments: [{ syntax: '[query]', description: 'Search keyword; may be omitted for filter-only search' }],
+            options: [
+                { flags: '--tags <expr>', description: 'Tag expression with AND/OR/NOT, or [] for empty tags', type: 'string' },
+                { flags: '--from <date>', description: 'created_at start (YYYY-MM-DD or ISO datetime)', type: 'string' },
+                { flags: '--to <date>', description: 'created_at end (YYYY-MM-DD or ISO datetime)', type: 'string' },
+                { flags: '--days <n>', description: 'Recent N days by created_at; mutually exclusive with --from/--to', type: 'number' },
+                { flags: '--starred <true|false>', description: 'Filter by starred status', type: 'string', enum: ['true', 'false'] },
+                { flags: '--boxes <string|@file>', description: 'Box names (JSON array/comma list), or [] for empty boxes', type: 'string' },
+                { flags: '--sql <expr>', description: 'SQL-like expression over id/content_md/summary/tags/zettel_boxes/created_at/type/is_starred', type: 'string' },
+                { flags: '--limit <n>', description: 'Maximum returned notes', type: 'number' },
+                { flags: '--offset <n>', description: 'Result offset for pagination', type: 'number', defaultValue: 0 },
+                { flags: '--fields <list>', description: 'Comma-separated fields: id,title,summary,tags,created_at,boxes,is_starred', type: 'string[]' },
+                { flags: '--include-deleted', description: 'Include soft-deleted notes', type: 'boolean' },
+            ],
+            schema: {
+                path: 'note.search',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'AI-friendly note search payload',
+                    entity: 'note_search_result',
+                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'],
+                    metaFields: ['query', 'returned_count', 'total_count', 'stale', 'pagination', 'fields', 'applied_filters'],
+                },
+                mcp: {
+                    toolName: 'dinox_search_notes',
+                    description: 'Search notes by keyword, tags, date range, or SQL expression',
+                    properties: [
+                        { name: 'query', type: 'string', description: 'Search keyword' },
+                        { name: 'tags', type: 'string', description: 'Tag expression (AND/OR/NOT)' },
+                        { name: 'from', type: 'string', description: 'Start date (YYYY-MM-DD)' },
+                        { name: 'to', type: 'string', description: 'End date (YYYY-MM-DD)' },
+                        { name: 'days', type: 'number', description: 'Recent N days' },
+                        { name: 'boxes', type: 'string[]', description: 'Box names' },
+                        { name: 'limit', type: 'number', description: 'Max results (default: 50)' },
+                        { name: 'offset', type: 'number', description: 'Result offset (default: 0)' },
+                        { name: 'fields', type: 'string[]', description: 'Returned fields: id,title,summary,tags,created_at,boxes,is_starred' },
+                    ],
+                },
+                examples: [
+                    'dino note search "AI" --days 7 --format json',
+                    'dino note search --tags "(work OR life) AND NOT archived" --format json',
+                ],
+            },
+            action: runNoteSearch,
+        },
+        {
+            name: 'get',
+            description: 'Get one note by id, optionally in lightweight context mode',
+            arguments: [{ syntax: '<id>', description: 'Note id' }],
+            options: [{ flags: '--context-only', description: 'Return lightweight note context (title/tags/summary/links)', type: 'boolean' }],
+            schema: {
+                path: 'note.get',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Single note or note context payload',
+                    entity: 'note_context',
+                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'updated_at', 'is_del', 'boxes', 'links'],
+                },
+                examples: ['dino note get <id> --context-only --format json', 'dino note get <id> --format json'],
+            },
+            action: runNoteGet,
+        },
+        {
+            name: 'preview',
+            description: 'Preview the first N lines of note markdown',
+            arguments: [{ syntax: '<id>', description: 'Note id' }],
+            options: [{ flags: '--lines <n>', description: 'Number of lines to return', type: 'number', defaultValue: 10 }],
+            schema: {
+                path: 'note.preview',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Markdown preview payload',
+                    fields: ['note.id', 'note.title', 'note.preview', 'note.lines', 'note.truncated', 'stale'],
+                },
+                examples: ['dino note preview <id> --lines 30 --format json'],
+            },
+            action: runNotePreview,
+        },
+        {
+            name: 'detail',
+            description: 'Get full note details for one or more ids',
+            arguments: [{ syntax: '[id]', description: 'Optional note id when reading a single note' }],
+            options: [{ flags: '--ids <string|@file>', description: 'Batch note ids (JSON array or comma/newline-separated)', type: 'string' }],
+            schema: {
+                path: 'note.detail',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'One full note object or an ordered array of note objects',
+                    fields: ['id', 'title', 'content_md', 'content_text', 'content_json', 'tags', 'boxes', 'created_at', 'updated_at', 'is_del'],
+                },
+                mcp: {
+                    toolName: 'dinox_get_note',
+                    description: 'Get note details by ID',
+                    properties: [{ name: 'id', type: 'string', description: 'Note ID', required: true }],
+                },
+                examples: ['dino note detail <id> --format json', 'dino note detail --ids @/tmp/note-ids.txt --format json'],
+            },
+            action: runNoteDetail,
+        },
+        {
+            name: 'create',
+            description: 'Create a new note from markdown content',
+            options: [
+                { flags: '--title <string>', description: 'Note title', required: true, type: 'string' },
+                { flags: '--content <string|@file>', description: 'Markdown content', required: true, type: 'string' },
+                { flags: '--type <note|crawl>', description: 'Note type: note or crawl', type: 'string', defaultValue: 'crawl', enum: ['note', 'crawl'] },
+                { flags: '--tags <string|@file>', description: 'Tag list (JSON array or comma/newline-separated)', type: 'string' },
+                { flags: '--boxes <string|@file>', description: 'Box names (JSON array or comma/newline-separated)', type: 'string' },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
+            schema: {
+                path: 'note.create',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Creation acknowledgement with the new note id',
+                    fields: ['id', 'stale'],
+                },
+                mcp: {
+                    toolName: 'dinox_create_note',
+                    description: 'Create a new note',
+                    properties: [
+                        { name: 'title', type: 'string', description: 'Note title', required: true },
+                        { name: 'content', type: 'string', description: 'Markdown content', required: true },
+                        { name: 'tags', type: 'string[]', description: 'Tags' },
+                        { name: 'boxes', type: 'string[]', description: 'Zettel boxes' },
+                    ],
+                },
+                examples: ['dino note create --title "Weekly note" --content @/tmp/note.md --type note --format json'],
+            },
+            action: runNoteCreate,
+        },
+        {
+            name: 'update',
+            description: 'Full-replace note tags, boxes, and/or starred state',
+            arguments: [{ syntax: '[id]', description: 'Optional note id for single-note update' }],
+            options: [
+                { flags: '--ids <string|@file>', description: 'Batch note ids (JSON array or comma/newline-separated)', type: 'string' },
+                { flags: '--tags <string|@file>', description: 'Full-replace tag list; use [] to clear', type: 'string' },
+                { flags: '--boxes <string|@file>', description: 'Full-replace box names; use [] to clear', type: 'string' },
+                { flags: '--starred <true|false>', description: 'Set starred status', type: 'string', enum: ['true', 'false'] },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
+            schema: {
+                path: 'note.update',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Mutation result with per-note update status',
+                    fields: ['total', 'updatedCount', 'results', 'stale'],
+                },
+                examples: ['dino note update <id> --tags "work,ai" --format json', 'dino note update --ids @/tmp/note-ids.txt --boxes "Inbox" --format json'],
+            },
+            action: runNoteUpdate,
+        },
+        {
+            name: 'delete',
+            description: 'Soft-delete a note by setting is_del=1',
+            arguments: [{ syntax: '<id>', description: 'Note id' }],
+            options: [{ flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' }],
+            schema: {
+                path: 'note.delete',
+                risk: 'high-risk-write',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Deletion acknowledgement',
+                    fields: ['id', 'stale'],
+                },
+                examples: ['dino note delete <id> --format json'],
+            },
+            action: runNoteDelete,
+        },
+        {
+            name: 'star',
+            description: 'Mark one or more notes as starred',
+            arguments: [{ syntax: '[id]', description: 'Optional note id for single-note update' }],
+            options: [
+                { flags: '--ids <string|@file>', description: 'Batch note ids (JSON array or comma/newline-separated)', type: 'string' },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
+            schema: {
+                path: 'note.star',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Mutation result with per-note starred status',
+                    fields: ['total', 'updatedCount', 'results', 'stale'],
+                },
+                examples: ['dino note star <id> --format json --dry-run'],
+            },
+            action: runNoteStar,
+        },
+        {
+            name: 'unstar',
+            description: 'Mark one or more notes as not starred',
+            arguments: [{ syntax: '[id]', description: 'Optional note id for single-note update' }],
+            options: [
+                { flags: '--ids <string|@file>', description: 'Batch note ids (JSON array or comma/newline-separated)', type: 'string' },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
+            schema: {
+                path: 'note.unstar',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: NOTE_GLOBAL_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Mutation result with per-note starred status',
+                    fields: ['total', 'updatedCount', 'results', 'stale'],
+                },
+                examples: ['dino note unstar <id> --format json --dry-run'],
+            },
+            action: runNoteUnstar,
+        },
+    ],
+};
+export function registerNoteCommands(program) {
+    registerCommandGroup(program, noteCommandGroup);
+}

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

@@ -0,0 +1,31 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { ResolvedDinoxConfig } from '../../config/types.js';
+import type { DryRunPreview } from '../../utils/dryRun.js';
+export declare function buildNoteCreateDryRunPreview(args: {
+    db: AbstractPowerSyncDatabase;
+    config: ResolvedDinoxConfig;
+    offline: boolean;
+    userId: string;
+    title: string;
+    noteType: 'note' | 'crawl';
+    contentMd: string;
+    tagsInput: string[];
+    zettelBoxNames: string[];
+}): Promise<DryRunPreview>;
+export declare function buildNoteUpdateDryRunPreview(args: {
+    db: AbstractPowerSyncDatabase;
+    config: ResolvedDinoxConfig;
+    offline: boolean;
+    ids: string[];
+    tagsInput?: string[];
+    zettelBoxNames?: string[];
+    starred?: boolean;
+    commandName: 'dino note update' | 'dino note star' | 'dino note unstar';
+    action: 'update_note' | 'star_note' | 'unstar_note';
+}): Promise<DryRunPreview>;
+export declare function buildNoteDeleteDryRunPreview(args: {
+    db: AbstractPowerSyncDatabase;
+    config: ResolvedDinoxConfig;
+    offline: boolean;
+    id: string;
+}): Promise<DryRunPreview>;

package/dist/commands/notes/dryRun.js

@@ -0,0 +1,130 @@
+import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
+import { canonicalizeBidlinksInMarkdown } from '../../utils/bidlinkCanonicalization.js';
+import { DinoxError } from '../../utils/errors.js';
+import { assertNotesUpdatable, getNoteDetails, parseStoredTags, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForUpdate, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+function normalizeDistinctStrings(values) {
+    return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+function normalizeLowerSet(values) {
+    return normalizeDistinctStrings(values).map((value) => value.toLowerCase()).sort();
+}
+function sameNormalizedSet(left, right) {
+    const leftNormalized = normalizeLowerSet(left);
+    const rightNormalized = normalizeLowerSet(right);
+    if (leftNormalized.length !== rightNormalized.length) {
+        return false;
+    }
+    return leftNormalized.every((value, index) => value === rightNormalized[index]);
+}
+function buildExecutionWarnings(config, offline) {
+    const warnings = [];
+    if (offline) {
+        warnings.push('Execution would run in offline mode and only use the local cache.');
+    }
+    if (!offline && !config.powersync.uploadBaseUrl) {
+        warnings.push('Execution would be local-only because powersync.uploadBaseUrl is unset.');
+    }
+    return warnings;
+}
+export async function buildNoteCreateDryRunPreview(args) {
+    const canonicalContentMd = await canonicalizeBidlinksInMarkdown(args.db, args.contentMd, args.userId);
+    const { contentText } = convertMarkdownToNoteContent(canonicalContentMd);
+    const tags = await validateTagsForCreate(args.db, args.tagsInput);
+    await resolveZettelBoxIdsForCreate(args.db, args.zettelBoxNames);
+    return {
+        dry_run: true,
+        command: 'dino note create',
+        action: 'create_note',
+        risk: 'write',
+        summary: `Create a ${args.noteType} note titled "${args.title}".`,
+        warnings: buildExecutionWarnings(args.config, args.offline),
+        inputs: {
+            title: args.title,
+            type: args.noteType,
+            tags,
+            boxes: normalizeDistinctStrings(args.zettelBoxNames),
+            content_chars: args.contentMd.length,
+            canonicalized_content_chars: canonicalContentMd.length,
+            markdown_changed: canonicalContentMd !== args.contentMd,
+        },
+        changes: {
+            title: args.title,
+            type: args.noteType,
+            tags,
+            boxes: normalizeDistinctStrings(args.zettelBoxNames),
+            content_preview: contentText.slice(0, 200),
+        },
+    };
+}
+export async function buildNoteUpdateDryRunPreview(args) {
+    await assertNotesUpdatable(args.db, args.ids);
+    const nextTags = Array.isArray(args.tagsInput)
+        ? await validateTagsForUpdate(args.db, args.tagsInput)
+        : undefined;
+    if (Array.isArray(args.zettelBoxNames)) {
+        await resolveZettelBoxIdsForUpdate(args.db, args.zettelBoxNames);
+    }
+    const details = await getNoteDetails(args.db, args.ids);
+    const changes = details.map((note) => {
+        const currentTags = parseStoredTags(note.tags);
+        const nextBoxes = Array.isArray(args.zettelBoxNames) ? normalizeDistinctStrings(args.zettelBoxNames) : note.zettel_boxes;
+        const tagsTo = nextTags ?? currentTags;
+        const starredTo = typeof args.starred === 'boolean' ? args.starred : note.is_starred;
+        return {
+            id: note.id,
+            title: note.title ?? '',
+            tags_from: currentTags,
+            tags_to: tagsTo,
+            tags_changed: Array.isArray(args.tagsInput) ? !sameNormalizedSet(currentTags, tagsTo) : false,
+            boxes_from: note.zettel_boxes,
+            boxes_to: nextBoxes,
+            boxes_changed: Array.isArray(args.zettelBoxNames) ? !sameNormalizedSet(note.zettel_boxes, nextBoxes) : false,
+            starred_from: note.is_starred,
+            starred_to: starredTo,
+            starred_changed: typeof args.starred === 'boolean' ? note.is_starred !== starredTo : false,
+        };
+    });
+    const changedCount = changes.filter((item) => item.tags_changed || item.boxes_changed || item.starred_changed).length;
+    return {
+        dry_run: true,
+        command: args.commandName,
+        action: args.action,
+        risk: 'write',
+        summary: `Preview ${args.action.replace(/_/g, ' ')} for ${args.ids.length} note(s); ${changedCount} note(s) would change.`,
+        warnings: buildExecutionWarnings(args.config, args.offline),
+        inputs: {
+            ids: args.ids,
+            ...(Array.isArray(args.tagsInput) ? { tags: nextTags } : {}),
+            ...(Array.isArray(args.zettelBoxNames) ? { boxes: normalizeDistinctStrings(args.zettelBoxNames) } : {}),
+            ...(typeof args.starred === 'boolean' ? { starred: args.starred } : {}),
+        },
+        targets: changes.map((item) => ({ id: item.id, title: item.title })),
+        changes,
+    };
+}
+export async function buildNoteDeleteDryRunPreview(args) {
+    const details = await getNoteDetails(args.db, [args.id]);
+    const note = details[0];
+    if (!note) {
+        throw new DinoxError(`Note not found: ${args.id}`);
+    }
+    return {
+        dry_run: true,
+        command: 'dino note delete',
+        action: 'delete_note',
+        risk: 'high-risk-write',
+        summary: `Soft-delete note "${note.title ?? ''}" (${note.id}).`,
+        warnings: buildExecutionWarnings(args.config, args.offline),
+        targets: [
+            {
+                id: note.id,
+                title: note.title ?? '',
+                is_del: note.is_del,
+            },
+        ],
+        changes: {
+            is_del_from: note.is_del ?? 0,
+            is_del_to: 1,
+        },
+    };
+}

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

@@ -1,51 +1,2 @@
-import { Command } from 'commander';
-import { type NoteSearchField, type NoteSearchResultItem } from './searchOutput.js';
-type NoteSearchResponse = {
-    meta: {
-        query: string;
-        returned_count: number;
-        total_count: number;
-        stale: boolean;
-        pagination: {
-            limit: number | null;
-            offset: number;
-            has_more: boolean;
-        };
-        fields: NoteSearchField[] | null;
-        applied_filters: {
-            include_deleted: boolean;
-            tags_expression: string | null;
-            created_at_range: {
-                from: string | null;
-                to: string | null;
-            } | null;
-            days: number | null;
-            box_names: string[];
-            box_ids: string[];
-            match_empty_boxes: boolean;
-            sql_expression: string | null;
-        };
-    };
-    notes: NoteSearchResultItem[];
-};
-type BuildNoteSearchResponseInput = {
-    query: string;
-    notes: NoteSearchResultItem[];
-    totalCount: number;
-    stale: boolean;
-    includeDeleted: boolean;
-    limit?: number;
-    offset?: number;
-    fields?: NoteSearchField[];
-    tagsExpression?: string;
-    createdAtFrom?: string;
-    createdAtTo?: string;
-    days?: number;
-    boxNames: string[];
-    boxIds: string[];
-    matchEmptyBoxes: boolean;
-    sqlExpression?: string;
-};
-export declare function buildNoteSearchResponse(input: BuildNoteSearchResponseInput): NoteSearchResponse;
-export declare function registerNoteCommands(program: Command): void;
-export {};
+export { buildNoteSearchResponse, type BuildNoteSearchResponseInput, type NoteSearchResponse, } from './searchResponse.js';
+export { noteCommandGroup, registerNoteCommands } from './descriptors.js';