@dinoxx/dinox-cli 1.0.20 → 1.0.21

package/dist/commands/notes/bulk.js

@@ -0,0 +1,204 @@
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { DinoxError } from '../../utils/errors.js';
+import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, waitForMutationUpload, } from '../runtime.js';
+import { resolveZettelBoxIdsForBulk, resolveZettelBoxIdsForSearch, searchNotes, validateTagsForBulk, } from './repo.js';
+import { applyNoteMetadataMutation, planNoteMetadataMutation, } from './metadataMutation.js';
+import { parseCreatedAtRange } from './searchTime.js';
+import { normalizeDaysForMeta, } from './searchResponse.js';
+import { parseSearchListInput, parseStarredOption, parseStringListInput, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+const BULK_PREVIEW_LIMIT = 100;
+export function selectBulkMutation(options) {
+    const candidates = [
+        { optionName: '--tag-add', field: 'tags', operation: 'add', rawValues: options.tagAdd },
+        { optionName: '--tag-remove', field: 'tags', operation: 'remove', rawValues: options.tagRemove },
+        { optionName: '--tag-replace', field: 'tags', operation: 'replace', rawValues: options.tagReplace },
+        { optionName: '--box-add', field: 'boxes', operation: 'add', rawValues: options.boxAdd },
+        { optionName: '--box-remove', field: 'boxes', operation: 'remove', rawValues: options.boxRemove },
+        { optionName: '--box-replace', field: 'boxes', operation: 'replace', rawValues: options.boxReplace },
+    ];
+    const selected = candidates.filter((entry) => typeof entry.rawValues === 'string');
+    if (selected.length !== 1) {
+        throw new DinoxError('Provide exactly one bulk mutation option: --tag-add, --tag-remove, --tag-replace, --box-add, --box-remove, or --box-replace');
+    }
+    return selected[0];
+}
+export function parseExpectedCount(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--expected-count must be a non-negative integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--expected-count must be a non-negative integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isSafeInteger(parsed) || parsed < 0) {
+        throw new DinoxError('--expected-count must be a non-negative integer');
+    }
+    return parsed;
+}
+function hasConcreteTargetFilter(input) {
+    const { query, options } = input;
+    return Boolean(query ||
+        options.tags ||
+        options.from ||
+        options.to ||
+        options.days ||
+        options.starred ||
+        options.boxes);
+}
+export function assertBulkTargetFilter(input) {
+    const hasFilter = hasConcreteTargetFilter(input);
+    if (input.options.all && hasFilter) {
+        throw new DinoxError('--all cannot be combined with other target filters');
+    }
+    if (!input.options.all && !hasFilter) {
+        throw new DinoxError('Provide at least one target filter or --all for note bulk');
+    }
+}
+function buildExecutionWarnings(input) {
+    const warnings = [];
+    if (input.offline) {
+        warnings.push('Execution would run in offline mode and only use the local cache.');
+    }
+    if (!input.offline && !input.uploadEnabled) {
+        warnings.push('Execution would be local-only because powersync.uploadBaseUrl is unset.');
+    }
+    if (input.total > BULK_PREVIEW_LIMIT) {
+        warnings.push(`Preview is truncated to the first ${BULK_PREVIEW_LIMIT} matched notes.`);
+    }
+    return warnings;
+}
+function previewItems(items) {
+    return items.slice(0, BULK_PREVIEW_LIMIT);
+}
+export async function runNoteBulk({ command, options, args }) {
+    const bulkOptions = options;
+    const structuredOutput = getRequestedStructuredOutputFormat() !== null;
+    await withNoteDatabase(command, async (runtime) => {
+        const { db, config, offline } = runtime;
+        await syncBeforeNoteCommand(runtime);
+        const query = args.query?.trim() ?? '';
+        assertBulkTargetFilter({ query, options: bulkOptions });
+        const selected = selectBulkMutation(bulkOptions);
+        const requestedValues = await parseStringListInput(selected.rawValues, selected.optionName);
+        const values = selected.field === 'tags'
+            ? await validateTagsForBulk(db, requestedValues)
+            : await resolveZettelBoxIdsForBulk(db, requestedValues);
+        const tagsExpression = typeof bulkOptions.tags === 'string' ? bulkOptions.tags.trim() : '';
+        const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
+            from: bulkOptions.from,
+            to: bulkOptions.to,
+            days: bulkOptions.days,
+        });
+        const starred = typeof bulkOptions.starred === 'string'
+            ? parseStarredOption(bulkOptions.starred, '--starred')
+            : undefined;
+        const boxInput = typeof bulkOptions.boxes === 'string' ? bulkOptions.boxes : '';
+        const parsedBoxInput = boxInput
+            ? await parseSearchListInput(boxInput, '--boxes')
+            : { values: [], isExplicitEmptyArray: false };
+        const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, parsedBoxInput.values);
+        const matches = await searchNotes(db, query, {
+            includeDeleted: false,
+            tagsExpression: tagsExpression || undefined,
+            createdAtFrom,
+            createdAtTo,
+            starred,
+            zettelBoxIds,
+            matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
+        });
+        const ids = matches.map((note) => note.id);
+        if (ids.length === 0) {
+            throw new DinoxError('No active notes matched the bulk filters');
+        }
+        const plan = await planNoteMetadataMutation(db, {
+            ids,
+            field: selected.field,
+            operation: selected.operation,
+            values,
+            displayValues: requestedValues,
+        });
+        const expectedCount = parseExpectedCount(bulkOptions.expectedCount);
+        const filterMeta = {
+            query,
+            tags_expression: tagsExpression || null,
+            created_at_range: createdAtFrom || createdAtTo
+                ? { from: createdAtFrom ?? null, to: createdAtTo ?? null }
+                : null,
+            days: normalizeDaysForMeta(bulkOptions.days) ?? null,
+            starred: typeof starred === 'boolean' ? starred : null,
+            box_names: parsedBoxInput.values,
+            box_ids: zettelBoxIds,
+            match_empty_boxes: parsedBoxInput.isExplicitEmptyArray,
+            all: Boolean(bulkOptions.all),
+        };
+        if (bulkOptions.dryRun) {
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino note bulk',
+                action: 'bulk_mutate_note_metadata',
+                risk: 'high-risk-write',
+                summary: `Preview bulk ${selected.field} ${selected.operation} for ${plan.total} matched note(s); ${plan.changedCount} note(s) would change.`,
+                warnings: buildExecutionWarnings({
+                    offline,
+                    uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
+                    total: plan.total,
+                }),
+                inputs: {
+                    filters: filterMeta,
+                    operation: selected.operation,
+                    field: selected.field,
+                    [selected.field]: selected.field === 'tags' ? values : requestedValues,
+                    expected_count: expectedCount,
+                    preview_limit: BULK_PREVIEW_LIMIT,
+                    preview_truncated: plan.total > BULK_PREVIEW_LIMIT,
+                },
+                targets: previewItems(plan.results).map((item) => ({ id: item.id, title: item.title })),
+                changes: previewItems(plan.results).map((item) => ({
+                    id: item.id,
+                    title: item.title,
+                    [`${selected.field}_from`]: item.before,
+                    [`${selected.field}_to`]: item.after,
+                    changed: item.changed,
+                })),
+            });
+            return;
+        }
+        if (!bulkOptions.confirm) {
+            throw new DinoxError('Bulk writes require --confirm');
+        }
+        if (expectedCount === null) {
+            throw new DinoxError('Bulk writes require --expected-count <n>');
+        }
+        if (expectedCount !== plan.total) {
+            throw new DinoxError(`--expected-count ${expectedCount} does not match current target count ${plan.total}`);
+        }
+        await applyNoteMetadataMutation(db, plan);
+        printUploadDisabledWarning(runtime);
+        await waitForMutationUpload(runtime);
+        const payload = {
+            ok: true,
+            field: selected.field,
+            operation: selected.operation,
+            total: plan.total,
+            updatedCount: plan.changedCount,
+            filters: filterMeta,
+            results: plan.results.map((item) => ({
+                id: item.id,
+                updated: item.changed,
+                [selected.field]: item.after,
+            })),
+            stale: commandStale(runtime),
+        };
+        if (structuredOutput) {
+            printSuccess(payload);
+            return;
+        }
+        printHumanReadableLine(`Updated ${plan.changedCount}/${plan.total} notes`);
+        printStaleCacheWarning(runtime);
+    });
+}

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

@@ -0,0 +1,95 @@
+export type TiptapNode = {
+    type: string;
+    attrs?: Record<string, unknown>;
+    content?: TiptapNode[];
+    marks?: Array<Record<string, unknown>>;
+    text?: string;
+    [key: string]: unknown;
+};
+export type NoteContentEditMode = 'text' | 'inlineAtom' | 'atomicBlock' | 'container' | 'unsupported';
+export type NoteContentBlockDescriptor = {
+    anchorId: string;
+    hasStableAnchor: boolean;
+    nodeIndex: number;
+    nodeRange: string;
+    type: string;
+    editMode: NoteContentEditMode;
+    level: number | null;
+    text: string;
+    textPreview: string;
+    textHash: string;
+    nodeHash: string;
+    charCount: number;
+    attrs?: Record<string, unknown>;
+};
+export type NoteContentOutlineItem = {
+    path: string;
+    level: number;
+    nodeRange: string;
+    contentHash: string;
+};
+export type NoteContentProjection = {
+    document: TiptapNode;
+    contentJson: string;
+    contentMd: string;
+    contentText: string;
+    hashtags: string[];
+    images: string[];
+    bidLinks: Array<{
+        id: string;
+        type: string;
+    }>;
+};
+export type HashtagReferenceResolver = (input: {
+    id: string;
+    path: string;
+}) => {
+    id: string;
+    path: string;
+} | null;
+export type NoteContentProjectionOptions = {
+    resolveHashtagReference?: HashtagReferenceResolver;
+};
+export type JsonPatchOperation = {
+    kind: 'appendSection';
+    heading: string;
+    content: string;
+} | {
+    kind: 'appendToHeading';
+    headingPath: string;
+    content: string;
+} | {
+    kind: 'replaceSection';
+    headingPath: string;
+    content: string;
+    allowProtectedReplace?: boolean;
+} | {
+    kind: 'replaceBlock';
+    match: string;
+    content: string;
+    allowProtectedReplace?: boolean;
+};
+export type JsonPatchPlan = {
+    operation: JsonPatchOperation['kind'];
+    changed: boolean;
+    beforeHash: string;
+    afterHash: string;
+    beforeContent: string;
+    afterContent: string;
+    beforeBlocks: NoteContentBlockDescriptor[];
+    afterBlocks: NoteContentBlockDescriptor[];
+    beforeProjection: NoteContentProjection;
+    afterProjection: NoteContentProjection;
+    target?: Record<string, unknown>;
+};
+export declare function parseStoredNoteDocument(input: {
+    contentJson: string | null;
+    contentMd: string | null;
+}): TiptapNode;
+export declare function buildNoteContentBlocks(document: TiptapNode): NoteContentBlockDescriptor[];
+export declare function buildNoteContentOutline(document: TiptapNode): NoteContentOutlineItem[];
+export declare function getNoteContentHash(document: TiptapNode): string;
+export declare function serializeNoteContentMarkdown(document: TiptapNode): string;
+export declare function projectNoteContent(document: TiptapNode, options?: NoteContentProjectionOptions): NoteContentProjection;
+export declare function applyJsonPatchToDocument(document: TiptapNode, operation: JsonPatchOperation, options?: NoteContentProjectionOptions): JsonPatchPlan;
+export declare function withStableBlockAnchors(document: TiptapNode): TiptapNode;