@dinoxx/dinox-cli 1.1.1 → 2.1.0

package/dist/commands/sync.js

@@ -42,7 +42,8 @@ export async function executeSyncCommand(context, overrides = {}) {
         config,
         offline: false,
         timeoutMs: remainingTimeoutMs(),
-        deadlineAtMs: operationDeadlineAtMs,
+        deadlineAtMs,
+        operationDeadlineAtMs,
         waitForInitialSync: false,
         expectedTokenFingerprint: config.auth.tokenFingerprint ?? null,
         cleanupFailureMode: 'throw',

package/dist/commands/tags/index.js

@@ -6,6 +6,7 @@ import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { assertWriteConfirmationProvided, parseExpectedCount } from '../writeConfirmation.js';
 import { addTag, inspectAddTag, listTags } from './repo.js';
 import { getTagStats, getTagTree, inspectTagCleanup, mergeTag, moveTag, renameTag, suggestTagMerges, } from './operations.js';
 const TAG_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
@@ -67,7 +68,7 @@ async function runTagAdd(context) {
                     userId: identity.userId,
                     emoji,
                 })),
-            }));
+            }), runtime);
             return;
         }
         const result = await addTag(runtime.db, {
@@ -114,7 +115,7 @@ async function runTagRename(context) {
                 summary: `Rename tag "${result.fromPath}" to "${result.toPath}".`,
                 inputs: { path, new_name: newName },
                 changes: { updated_tags: result.updatedTags, updated_notes: result.updatedNotes },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -139,7 +140,7 @@ async function runTagMove(context) {
                 summary: `Move tag "${result.fromPath}" to "${result.toPath}".`,
                 inputs: { path, to },
                 changes: { updated_tags: result.updatedTags, updated_notes: result.updatedNotes },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -149,9 +150,17 @@ async function runTagMove(context) {
 async function runTagMerge(context) {
     const from = requireArg(context.args.from, 'Source tag path is required');
     const to = requireArg(context.args.to, 'Target tag path is required');
+    const dryRun = Boolean(context.options.dryRun);
+    const expectedCount = parseExpectedCount(context.options.expectedCount);
+    const writeOptions = {
+        dryRun,
+        confirm: Boolean(context.options.confirm),
+        expectedCount,
+    };
+    assertWriteConfirmationProvided('Tag merge', writeOptions);
     await withTagWriteRuntime(context, async ({ runtime, userId }) => {
-        const result = await mergeTag(runtime.db, { from, to, userId }, { dryRun: Boolean(context.options.dryRun) });
-        if (Boolean(context.options.dryRun)) {
+        const result = await mergeTag(runtime.db, { from, to, userId }, writeOptions);
+        if (dryRun) {
             printDryRunPreview(buildTagMutationDryRunPreview({
                 config: runtime.config,
                 offline: runtime.offline,
@@ -159,12 +168,15 @@ async function runTagMerge(context) {
                 action: 'merge_tag',
                 risk: 'high-risk-write',
                 summary: `Merge tag subtree "${result.fromPath}" into "${result.toPath}".`,
-                inputs: { from, to },
+                inputs: { from, to, expected_count: expectedCount },
                 changes: {
+                    affected_count: result.affectedCount,
+                    soft_deleted_tag_count: result.softDeletedTagIds.length,
+                    updated_note_count: result.updatedNotes.length,
                     soft_deleted_tag_ids: result.softDeletedTagIds,
                     updated_notes: result.updatedNotes,
                 },
-            }));
+            }), runtime);
             return;
         }
         await waitForMutationUpload(runtime);
@@ -193,7 +205,7 @@ async function runTagCleanup(context) {
                 summary: `Inspect tag cleanup candidates (${result.issues.length} issues).`,
                 inputs: {},
                 targets: result.issues,
-            }));
+            }), runtime);
             return;
         }
         printSuccess({ stale: commandStale(runtime), ...result });
@@ -328,7 +340,11 @@ export const tagCommandGroup = {
                 { syntax: '<from>', description: 'Source tag path' },
                 { syntax: '<to>', description: 'Target tag path' },
             ],
-            options: [{ flags: '--dry-run', description: 'Preview the write without executing it' }],
+            options: [
+                { flags: '--expected-count <n>', description: 'Required for real writes; must equal source tags plus notes affected', type: 'number' },
+                { flags: '--confirm', description: 'Required for real writes after reviewing a dry run', type: 'boolean' },
+                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+            ],
             schema: {
                 path: 'tag.merge',
                 risk: 'high-risk-write',
@@ -337,9 +353,12 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag merge result',
-                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'stale'],
+                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'affectedCount', 'stale'],
                 },
-                examples: ['dino tag merge "ai" "AI" --format json --dry-run'],
+                examples: [
+                    'dino tag merge "ai" "AI" --format json --dry-run',
+                    'dino tag merge "ai" "AI" --expected-count 4 --confirm --format json',
+                ],
             },
             action: runTagMerge,
         },

package/dist/commands/tags/operations.d.ts

@@ -1,4 +1,5 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type ConfirmedWriteOptions } from '../writeConfirmation.js';
 import type { TagListItem } from './model.js';
 export type TagTreeNode = TagListItem & {
     isActual: boolean;
@@ -63,6 +64,7 @@ export type TagMergeResult = {
         before: string[];
         after: string[];
     }>;
+    affectedCount: number;
 };
 export type TagSuggestResult = {
     suggestions: Array<{
@@ -98,8 +100,6 @@ export declare function renameTag(db: AbstractPowerSyncDatabase, input: TagRenam
 export declare function moveTag(db: AbstractPowerSyncDatabase, input: TagMoveInput, options?: {
     dryRun?: boolean;
 }): Promise<TagRenameMoveResult>;
-export declare function mergeTag(db: AbstractPowerSyncDatabase, input: TagMergeInput, options?: {
-    dryRun?: boolean;
-}): Promise<TagMergeResult>;
+export declare function mergeTag(db: AbstractPowerSyncDatabase, input: TagMergeInput, options?: ConfirmedWriteOptions): Promise<TagMergeResult>;
 export declare function inspectTagCleanup(db: AbstractPowerSyncDatabase, input?: TagReadInput): Promise<TagCleanupResult>;
 export declare function suggestTagMerges(db: AbstractPowerSyncDatabase, input?: TagReadInput): Promise<TagSuggestResult>;

package/dist/commands/tags/operations.js

@@ -1,6 +1,7 @@
 import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
 import { nowIsoUtc } from '../../utils/time.js';
+import { assertConfirmedWrite, assertWriteConfirmationProvided, } from '../writeConfirmation.js';
 import { mergeTagReferencesInNote, renameTagReferencesInNote } from './content.js';
 import { MAX_TAG_SEGMENT_LENGTH, REQUIRED_NOTE_TAG_COLUMNS, REQUIRED_TAG_NODE_COLUMNS, canonicalizeTagPath, getLeafName, isActiveTagNode, isActualTagNode, isTagPathWithinPrefix, normalizeTagLookupKey, parseStoredTags, parentPathOf, renameTagPathWithPrefix, trimString, } from './model.js';
 import { activeTagNodes, actualActiveTagNodes, assertCanWriteTag, assertRequiredColumns, assertWritableTagNodes, descendantsOf, ensureNoTagPathConflict, getTableColumns, loadTagNodes, parentIdForPath, requireActiveTagPath, toTagListItem, } from './store.js';
@@ -297,7 +298,7 @@ export async function moveTag(db, input, options = {}) {
         updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
     };
 }
-export async function mergeTag(db, input, options = {}) {
+async function buildTagMergePlan(db, input) {
     const from = assertPath(input.from, 'Source tag path');
     const to = assertPath(input.to, 'Target tag path');
     const userId = trimString(input.userId);
@@ -318,28 +319,52 @@ export async function mergeTag(db, input, options = {}) {
         .map((row) => updateNoteTagsForPrefix(row, source.fullPath, target.fullPath, 'merge', lookup))
         .filter((row) => row.id && row.changed);
     const softDeletedTagIds = sourceNodes.map((node) => node.id);
-    if (!options.dryRun) {
-        await withPowerSyncWriteTransaction(db, async (tx) => {
-            const timestamp = nowIsoUtc();
-            await applyNoteUpdates(tx, noteUpdates, timestamp);
-            for (const tagId of softDeletedTagIds) {
-                await tx.execute(`
-          UPDATE c_tag_node
-          SET is_del = 1, updated_at = ?
-          WHERE id = ?
-          `, [timestamp, tagId]);
-            }
-        });
-    }
+    const affectedCount = softDeletedTagIds.length + noteUpdates.length;
     return {
-        fromId: source.id,
-        toId: target.id,
-        fromPath: source.fullPath,
-        toPath: target.fullPath,
-        softDeletedTagIds,
-        updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
+        result: {
+            fromId: source.id,
+            toId: target.id,
+            fromPath: source.fullPath,
+            toPath: target.fullPath,
+            softDeletedTagIds,
+            updatedNotes: noteUpdates.map(({ id, before, after }) => ({ id, before, after })),
+            affectedCount,
+        },
+        noteUpdates,
+        userId,
     };
 }
+function assertTagMergeCount(plan, options) {
+    assertConfirmedWrite({
+        operation: 'Tag merge',
+        schemaPath: 'tag.merge',
+        actualCount: plan.result.affectedCount,
+        options,
+    });
+}
+export async function mergeTag(db, input, options = {}) {
+    if (options.dryRun) {
+        const plan = await buildTagMergePlan(db, input);
+        assertTagMergeCount(plan, options);
+        return plan.result;
+    }
+    assertWriteConfirmationProvided('Tag merge', options);
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const plan = await buildTagMergePlan(tx, input);
+        assertTagMergeCount(plan, options);
+        const timestamp = nowIsoUtc();
+        await applyNoteUpdates(tx, plan.noteUpdates, timestamp);
+        for (const tagId of plan.result.softDeletedTagIds) {
+            await tx.execute(`
+        UPDATE c_tag_node
+        SET is_del = 1, updated_at = ?
+        WHERE id = ?
+          AND TRIM(COALESCE(user_id, '')) = ?
+        `, [timestamp, tagId, plan.userId]);
+        }
+        return plan.result;
+    });
+}
 export async function inspectTagCleanup(db, input = {}) {
     const columns = await getTableColumns(db, 'c_tag_node');
     assertRequiredColumns('c_tag_node', columns, REQUIRED_TAG_NODE_COLUMNS);

package/dist/commands/templates/model.d.ts

@@ -0,0 +1,50 @@
+import { type TiptapNode } from '../notes/contentEngine.js';
+export declare const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
+export declare const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+export declare const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200000;
+export type NoteTemplatePropertyDef = {
+    version: typeof NOTE_TEMPLATE_PROPERTY_DEF_VERSION;
+    keys: string[];
+};
+export type NoteTemplateRow = {
+    id: string;
+    user_id: string | null;
+    name: string | null;
+    content: string | null;
+    priority: number | null;
+    is_show: number | null;
+    extra_data: string | null;
+    property_def: string | null;
+    insert_at: string | null;
+    update_at: string | null;
+    is_del: number | null;
+};
+export type NoteTemplateSummary = {
+    id: string;
+    name: string;
+    propertyKeys: string[];
+    content: string;
+    hasContent: boolean;
+    isShow: boolean;
+    priority: number;
+    updateAt: string | null;
+};
+export type NoteTemplateTokenValues = {
+    date: string;
+    datetime: string;
+    time: string;
+    location: string;
+};
+export declare function isNotePropertyKeyValid(value: unknown): value is string;
+export declare function validateNoteTemplatePropertyKeys(keys: readonly unknown[]): string[];
+export declare function parseNoteTemplatePropertyDef(raw: string | null | undefined): NoteTemplatePropertyDef | null;
+export declare function serializeNoteTemplatePropertyDef(keys: readonly string[]): string | null;
+export declare function isNoteTemplateDocumentEmpty(document: TiptapNode | null | undefined): boolean;
+export declare function parseNoteTemplateContent(raw: string | null | undefined): TiptapNode | null;
+export declare function serializeNoteTemplateContent(document: unknown): string;
+export declare function buildNoteTemplateTokenValues(now?: Date, location?: string): NoteTemplateTokenValues;
+export declare function hydrateNoteTemplateDocument(document: TiptapNode, options?: {
+    now?: Date;
+    location?: string;
+}): TiptapNode;
+export declare function mapNoteTemplateRow(row: NoteTemplateRow): NoteTemplateSummary;

package/dist/commands/templates/model.js

@@ -0,0 +1,239 @@
+import { projectNoteContent } from '../notes/contentEngine.js';
+import { DinoxError } from '../../utils/errors.js';
+export const NOTE_TEMPLATE_PROPERTY_DEF_VERSION = 1;
+export const MAX_NOTE_TEMPLATE_PROPERTY_KEYS = 50;
+export const MAX_NOTE_TEMPLATE_CONTENT_LENGTH = 200_000;
+const MAX_TIPTAP_NODE_DEPTH = 100;
+const MAX_TIPTAP_NODE_COUNT = 10_000;
+const NON_TEXT_TEMPLATE_NODE_TYPES = new Set([
+    'image',
+    'table',
+    'mermaid',
+    'mindgraph',
+    'codeBlock',
+    'horizontalRule',
+    'taskList',
+]);
+function formatError(message, code, details) {
+    return new DinoxError(message, {
+        code,
+        details,
+        recoverable: false,
+    });
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function isNotePropertyKeyValid(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed !== value || trimmed.length > 64)
+        return false;
+    if (trimmed === '__proto__')
+        return false;
+    return !trimmed.includes('.') && !/[\n\r\t]/.test(trimmed);
+}
+export function validateNoteTemplatePropertyKeys(keys) {
+    if (keys.length > MAX_NOTE_TEMPLATE_PROPERTY_KEYS) {
+        throw formatError(`Note templates support at most ${MAX_NOTE_TEMPLATE_PROPERTY_KEYS} property keys`, 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', { maxKeys: MAX_NOTE_TEMPLATE_PROPERTY_KEYS, receivedKeys: keys.length });
+    }
+    const seen = new Set();
+    const validated = [];
+    for (const key of keys) {
+        if (!isNotePropertyKeyValid(key)) {
+            throw formatError('Note template property_def contains an invalid property key', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
+                key,
+            });
+        }
+        if (seen.has(key)) {
+            throw formatError('Note template property_def contains duplicate property keys', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
+                key,
+            });
+        }
+        seen.add(key);
+        validated.push(key);
+    }
+    return validated;
+}
+export function parseNoteTemplatePropertyDef(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw formatError('Note template property_def must be valid JSON', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF', {
+            cause: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+    if (!isPlainRecord(parsed)) {
+        throw formatError('Note template property_def must be a versioned object', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF');
+    }
+    if (parsed.version !== NOTE_TEMPLATE_PROPERTY_DEF_VERSION) {
+        throw formatError(`Unsupported note template property_def version: ${String(parsed.version)}`, 'NOTE_TEMPLATE_UNSUPPORTED_PROPERTY_DEF_VERSION', { supportedVersion: NOTE_TEMPLATE_PROPERTY_DEF_VERSION, receivedVersion: parsed.version });
+    }
+    if (!Array.isArray(parsed.keys)) {
+        throw formatError('Note template property_def keys must be an array', 'NOTE_TEMPLATE_INVALID_PROPERTY_DEF');
+    }
+    return {
+        version: NOTE_TEMPLATE_PROPERTY_DEF_VERSION,
+        keys: validateNoteTemplatePropertyKeys(parsed.keys),
+    };
+}
+export function serializeNoteTemplatePropertyDef(keys) {
+    const validated = validateNoteTemplatePropertyKeys(keys);
+    if (validated.length === 0)
+        return null;
+    return JSON.stringify({
+        version: NOTE_TEMPLATE_PROPERTY_DEF_VERSION,
+        keys: validated,
+    });
+}
+function assertTiptapNode(value, state, depth) {
+    if (depth > MAX_TIPTAP_NODE_DEPTH) {
+        throw formatError(`Note template content exceeds the maximum node depth of ${MAX_TIPTAP_NODE_DEPTH}`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (!isPlainRecord(value) || typeof value.type !== 'string' || !value.type.trim()) {
+        throw formatError('Note template content contains an invalid Tiptap node', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    state.count += 1;
+    if (state.count > MAX_TIPTAP_NODE_COUNT) {
+        throw formatError(`Note template content exceeds the maximum node count of ${MAX_TIPTAP_NODE_COUNT}`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (value.text !== undefined && typeof value.text !== 'string') {
+        throw formatError('Tiptap node text must be a string', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (value.attrs !== undefined && !isPlainRecord(value.attrs)) {
+        throw formatError('Tiptap node attrs must be an object', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    if (value.marks !== undefined) {
+        if (!Array.isArray(value.marks)) {
+            throw formatError('Tiptap node marks must be an array', 'NOTE_TEMPLATE_INVALID_CONTENT');
+        }
+        for (const mark of value.marks) {
+            if (!isPlainRecord(mark) || typeof mark.type !== 'string' || !mark.type.trim()) {
+                throw formatError('Tiptap node contains an invalid mark', 'NOTE_TEMPLATE_INVALID_CONTENT');
+            }
+            if (mark.attrs !== undefined && !isPlainRecord(mark.attrs)) {
+                throw formatError('Tiptap mark attrs must be an object', 'NOTE_TEMPLATE_INVALID_CONTENT');
+            }
+        }
+    }
+    if (value.content !== undefined) {
+        if (!Array.isArray(value.content)) {
+            throw formatError('Tiptap node content must be an array', 'NOTE_TEMPLATE_INVALID_CONTENT');
+        }
+        for (const child of value.content) {
+            assertTiptapNode(child, state, depth + 1);
+        }
+    }
+}
+function assertCanonicalTemplateDocument(value) {
+    assertTiptapNode(value, { count: 0 }, 1);
+    if (value.type !== 'doc' || !Array.isArray(value.content)) {
+        throw formatError('Note template content must be a Tiptap doc with a content array', 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+}
+function extractTemplatePlainText(node) {
+    if (node.type === 'text')
+        return typeof node.text === 'string' ? node.text : '';
+    if (node.type === 'hardBreak')
+        return '\n';
+    return (node.content ?? []).map(extractTemplatePlainText).join('');
+}
+function hasNonTextTemplateContent(node) {
+    if (NON_TEXT_TEMPLATE_NODE_TYPES.has(node.type))
+        return true;
+    return (node.content ?? []).some(hasNonTextTemplateContent);
+}
+export function isNoteTemplateDocumentEmpty(document) {
+    if (!document)
+        return true;
+    if (extractTemplatePlainText(document).trim())
+        return false;
+    return !hasNonTextTemplateContent(document);
+}
+export function parseNoteTemplateContent(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value)
+        return null;
+    if (value.length > MAX_NOTE_TEMPLATE_CONTENT_LENGTH) {
+        throw formatError(`Note template content must be at most ${MAX_NOTE_TEMPLATE_CONTENT_LENGTH} characters`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw formatError('Note template content must be valid Tiptap JSON', 'NOTE_TEMPLATE_INVALID_CONTENT', {
+            cause: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+    assertCanonicalTemplateDocument(parsed);
+    return projectNoteContent(parsed).document;
+}
+export function serializeNoteTemplateContent(document) {
+    assertCanonicalTemplateDocument(document);
+    if (isNoteTemplateDocumentEmpty(document))
+        return '';
+    const content = projectNoteContent(document).contentJson;
+    if (content.length > MAX_NOTE_TEMPLATE_CONTENT_LENGTH) {
+        throw formatError(`Note template content must be at most ${MAX_NOTE_TEMPLATE_CONTENT_LENGTH} characters`, 'NOTE_TEMPLATE_INVALID_CONTENT');
+    }
+    return content;
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+export function buildNoteTemplateTokenValues(now = new Date(), location = '') {
+    if (Number.isNaN(now.getTime())) {
+        throw formatError('Note template token time must be a valid date', 'NOTE_TEMPLATE_INVALID_TOKEN_CONTEXT');
+    }
+    const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const time = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+    return {
+        date,
+        time,
+        datetime: `${date} ${time}`,
+        location,
+    };
+}
+function hydrateTemplateNode(node, values) {
+    if (node.type === 'text' && typeof node.text === 'string') {
+        const text = node.text
+            .replaceAll('{{date}}', values.date)
+            .replaceAll('{{datetime}}', values.datetime)
+            .replaceAll('{{time}}', values.time)
+            .replaceAll('{{location}}', values.location);
+        return text ? { ...node, text } : null;
+    }
+    if (!Array.isArray(node.content))
+        return { ...node };
+    const content = node.content
+        .map((child) => hydrateTemplateNode(child, values))
+        .filter((child) => child !== null);
+    return { ...node, content };
+}
+export function hydrateNoteTemplateDocument(document, options = {}) {
+    assertCanonicalTemplateDocument(document);
+    const values = buildNoteTemplateTokenValues(options.now, options.location ?? '');
+    return hydrateTemplateNode(document, values) ?? { type: 'doc', content: [] };
+}
+export function mapNoteTemplateRow(row) {
+    const propertyDef = parseNoteTemplatePropertyDef(row.property_def);
+    const document = parseNoteTemplateContent(row.content);
+    const content = document ? serializeNoteTemplateContent(document) : '';
+    return {
+        id: row.id,
+        name: (row.name ?? '').trim(),
+        propertyKeys: propertyDef?.keys ?? [],
+        content,
+        hasContent: Boolean(content),
+        isShow: Number(row.is_show ?? 0) === 1,
+        priority: Number.isFinite(row.priority) ? Math.trunc(Number(row.priority)) : 0,
+        updateAt: row.update_at ?? null,
+    };
+}

package/dist/commands/todo/index.js

@@ -182,7 +182,7 @@ async function runTodoAppend({ args, globals, options }) {
                 noteId: typeof appendOptions.noteId === 'string' ? appendOptions.noteId : undefined,
                 taskTexts,
             });
-            printDryRunPreview(preview);
+            printDryRunPreview(preview, runtime);
             return;
         }
         const result = await appendTodoTasks(db, {
@@ -216,7 +216,7 @@ async function runTodoCreate({ args, globals, options }) {
                 title: typeof createOptions.title === 'string' ? createOptions.title : undefined,
                 taskTexts,
             });
-            printDryRunPreview(preview);
+            printDryRunPreview(preview, runtime);
             return;
         }
         const identity = await resolveAuthIdentity(config);
@@ -254,7 +254,7 @@ async function runTodoUpdate({ args, globals, options }) {
                 noteId: typeof updateOptions.noteId === 'string' ? updateOptions.noteId : undefined,
                 checked,
             });
-            printDryRunPreview(preview);
+            printDryRunPreview(preview, runtime);
             return;
         }
         const result = await updateTodoTaskStatus(db, {

package/dist/commands/update.d.ts

@@ -8,6 +8,7 @@ type UpdateCommandDeps = {
         structuredOutput: boolean;
     }) => Promise<void>;
     getVersion: () => string;
+    getLatestVersion: () => Promise<string | null>;
     log: LogFn;
 };
 export declare function detectPackageManager(input?: {

package/dist/commands/update.js

@@ -2,9 +2,11 @@ import { spawn } from 'node:child_process';
 import { realpathSync } from 'node:fs';
 import { registerStandaloneCommand } from './descriptor/register.js';
 import { FORMAT_OPTIONS } from './schema/globalOptions.js';
-import { SKILLS_REPO_URL } from '../constants/links.js';
+import { getSkillsReleaseMetadata } from '../constants/links.js';
+import { RETIRED_SKILLS, RETIRED_SKILLS_CLEANUP, formatRetiredSkillsSummary, } from '../skills/retired.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
 import { DinoxError } from '../utils/errors.js';
+import { fetchLatestPublishedVersion } from '../utils/updateNotice.js';
 import { getPackageVersion } from '../utils/version.js';
 const PACKAGE_NAME = '@dinoxx/dinox-cli';
 const MAX_CAPTURED_UPDATE_OUTPUT_BYTES = 64 * 1024;
@@ -123,13 +125,20 @@ function resolveDeps(overrides) {
         detectPackageManager,
         runUpdate,
         getVersion: getPackageVersion,
+        getLatestVersion: fetchLatestPublishedVersion,
         log: logHumanReadable,
         ...overrides,
     };
 }
-function printSkillsReminder(log) {
-    log(`skills repo: ${SKILLS_REPO_URL}`);
-    log('ai reminder: review and update local Dinox skills after CLI updates (especially dino-dinox and dino-update-cli).');
+function printSkillsReminder(log, version) {
+    const skills = getSkillsReleaseMetadata(version);
+    log(`skills repo: ${skills.repository}`);
+    log(`skills release: ${skills.release}`);
+    log(`skills installer: ${skills.installer.name}@${skills.installer.version}`);
+    log(`skills install: ${skills.installCommand}`);
+    log(`ai reminder: update local Dinox skills to ${skills.tag} after this CLI update.`);
+    log(`retired skills: ${formatRetiredSkillsSummary()}`);
+    log(`retired skills cleanup: ${RETIRED_SKILLS_CLEANUP.guidance}`);
 }
 function parsePackageManagerOverride(value) {
     if (value === undefined || value === null || value === '') {
@@ -161,32 +170,60 @@ export function createUpdateCommandDescriptor(overrides = {}) {
             globalOptions: FORMAT_OPTIONS,
             output: {
                 type: 'structured',
-                summary: 'Updater result and bundled skills reminder',
-                fields: ['previousVersion', 'packageManager', 'package', 'target', 'skillsRepo'],
+                summary: 'Updater result and matching standalone skills release metadata',
+                fields: [
+                    'previousVersion',
+                    'version',
+                    'packageManager',
+                    'package',
+                    'target',
+                    'skillsRepo',
+                    'skillsVersion',
+                    'skillsTag',
+                    'skillsRelease',
+                    'skillsInstaller',
+                    'skillsInstallCommand',
+                    'retiredSkills',
+                    'retiredSkillsCleanup',
+                ],
             },
             examples: ['dino update', 'dino update --package-manager pnpm --format json'],
         },
         action: async (context) => {
             const pm = parsePackageManagerOverride(context.options.packageManager) ?? deps.detectPackageManager();
             const previousVersion = deps.getVersion();
+            const targetVersion = await deps.getLatestVersion();
             const structuredOutput = getRequestedStructuredOutputFormat() !== null;
             if (!structuredOutput) {
                 deps.log(`current version: ${previousVersion}`);
                 deps.log(`updating ${PACKAGE_NAME} via ${pm}...`);
             }
             await deps.runUpdate(pm, { structuredOutput });
+            const observedVersion = deps.getVersion();
+            const version = observedVersion !== previousVersion
+                ? observedVersion
+                : targetVersion ?? observedVersion;
+            const skills = getSkillsReleaseMetadata(version);
             if (structuredOutput) {
                 printSuccess({
                     previousVersion,
+                    version,
                     packageManager: pm,
                     package: PACKAGE_NAME,
                     target: 'latest',
-                    skillsRepo: SKILLS_REPO_URL,
+                    skillsRepo: skills.repository,
+                    skillsVersion: skills.version,
+                    skillsTag: skills.tag,
+                    skillsRelease: skills.release,
+                    skillsInstaller: skills.installer,
+                    skillsInstallCommand: skills.installCommand,
+                    retiredSkills: RETIRED_SKILLS,
+                    retiredSkillsCleanup: RETIRED_SKILLS_CLEANUP,
                 });
                 return;
             }
-            deps.log('done');
-            printSkillsReminder(deps.log);
+            deps.log(`done: ${version}`);
+            printSkillsReminder(deps.log, version);
         },
     };
 }