@dinoxx/dinox-cli 1.0.18 → 1.0.19

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