@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/todo/repo.js

@@ -4,9 +4,71 @@ import { generateId } from '../../utils/id.js';
 import { nowIsoUtc } from '../../utils/time.js';
 import { applyTaskCheckedStatus, appendTasksToDoc, buildAppendMarkdown, buildContentTextPreview, buildCreateMarkdown, buildSummaryTitle, createTodoDocFromTasks, deriveImageDetailFromContentJson, normalizeTaskTexts, patchTaskMarkdownByOrder, parseTiptapDocFromDb, } from './contentModel.js';
 import { buildTaskKey, extractFlattenedTasks, filterTasksForTodoList, } from './taskModel.js';
+import { isLegacyTaskId } from './taskIdentity.js';
 export { normalizeTaskTexts } from './contentModel.js';
+const TODO_TASK_CANDIDATE_SCAN_LIMIT = 500;
+export function validateTodoAppendTarget(target) {
+    if (typeof target.is_del === 'number' && target.is_del !== 0) {
+        throw new DinoxError(`Note has been deleted: ${target.id}`);
+    }
+    const noteId = target.id?.trim() ?? '';
+    if (!noteId) {
+        throw new DinoxError('Note id is required');
+    }
+    const currentDoc = parseTiptapDocFromDb(target.content_json);
+    const hasMarkdownSnapshot = Boolean(target.content_md?.trim());
+    const hasDocContent = Array.isArray(currentDoc.content) && currentDoc.content.length > 0;
+    if (!hasMarkdownSnapshot && hasDocContent) {
+        throw new DinoxError('Cannot append todo: current note has non-empty content_json but empty content_md. Please repair note markdown before append.');
+    }
+    return { currentDoc, noteId, expectedVersion: normalizeVersion(target.version) };
+}
+function normalizeVersion(value) {
+    const parsed = Number(value ?? 0);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+function assertSingleUpdatedRow(result, message) {
+    if (result.rows?.length !== 1) {
+        throw new DinoxError(message);
+    }
+}
+/** Serialize parsed todo-search options into a JSON-safe wire payload. */
+export function toTodoSearchWire(query, options) {
+    return {
+        query,
+        includeDeleted: options.includeDeleted,
+        taskStatus: options.taskStatus,
+        taskTagFilter: options.taskTagFilter,
+        limit: options.limit,
+        scanLimit: options.scanLimit,
+        startDate: options.taskDateRange?.startDate?.toISOString(),
+        endDate: options.taskDateRange?.endDate?.toISOString(),
+    };
+}
+/**
+ * Run a todo search from a wire payload. Shared by the local command path and the daemon
+ * RPC handler so both produce identical results from one implementation.
+ */
+export async function executeTodoSearch(db, wire) {
+    const taskDateRange = wire.startDate || wire.endDate
+        ? {
+            startDate: wire.startDate ? new Date(wire.startDate) : undefined,
+            endDate: wire.endDate ? new Date(wire.endDate) : undefined,
+        }
+        : undefined;
+    return searchTodoTasks(db, wire.query, {
+        includeDeleted: wire.includeDeleted,
+        taskStatus: wire.taskStatus,
+        taskTagFilter: wire.taskTagFilter,
+        taskDateRange,
+        limit: wire.limit,
+        scanLimit: wire.scanLimit,
+    });
+}
 export async function searchTodoTasks(db, query, options) {
-    const noteRows = await loadTodoNoteRows(db, options.includeDeleted, options.scanLimit);
+    const scannedRows = await loadTodoNoteRows(db, options.includeDeleted, options.scanLimit + 1);
+    const scanTruncated = scannedRows.length > options.scanLimit;
+    const noteRows = scannedRows.slice(0, options.scanLimit);
     const allTasks = extractFlattenedTasks(noteRows);
     const filteredTasks = filterTasksForTodoList(allTasks, query, options.taskStatus, options.taskTagFilter, options.taskDateRange);
     const visibleTasks = filteredTasks.slice(0, options.limit);
@@ -32,10 +94,13 @@ export async function searchTodoTasks(db, query, options) {
             query: query.trim(),
             returned_count: tasks.length,
             total_count: filteredTasks.length,
-            matched_note_count: new Set(tasks.map((task) => task.note_id)).size,
+            matched_note_count: new Set(filteredTasks.map((task) => task.noteId)).size,
             limit: options.limit,
             scan_limit: options.scanLimit,
-            truncated: filteredTasks.length > tasks.length,
+            scanned_note_count: noteRows.length,
+            scan_truncated: scanTruncated,
+            total_count_is_lower_bound: scanTruncated,
+            truncated: scanTruncated || filteredTasks.length > tasks.length,
             applied_filters: {
                 status: options.taskStatus,
                 tags: [...options.taskTagFilter],
@@ -59,24 +124,13 @@ export async function appendTodoTasks(db, options) {
         }
         throw new DinoxError('No eligible note found for append. Try `dino todo create ...` first.');
     }
-    if (typeof target.is_del === 'number' && target.is_del !== 0) {
-        throw new DinoxError(`Note has been deleted: ${target.id}`);
-    }
-    if (!target.id?.trim()) {
-        throw new DinoxError('Note id is required');
-    }
-    const currentDoc = parseTiptapDocFromDb(target.content_json);
-    const hasMarkdownSnapshot = Boolean(target.content_md?.trim());
-    const hasDocContent = Array.isArray(currentDoc.content) && currentDoc.content.length > 0;
-    if (!hasMarkdownSnapshot && hasDocContent) {
-        throw new DinoxError('Cannot append todo: current note has non-empty content_json but empty content_md. Please repair note markdown before append.');
-    }
+    const { currentDoc, noteId, expectedVersion } = validateTodoAppendTarget(target);
     const nextDoc = appendTasksToDoc(currentDoc, taskTexts);
-    const imageDetail = deriveImageDetailFromContentJson(nextDoc);
+    const imageDetail = deriveImageDetailFromContentJson(nextDoc, noteId);
     const contentMd = buildAppendMarkdown(target.content_md, taskTexts);
     const contentText = buildContentTextPreview(contentMd);
     const now = nowIsoUtc();
-    await db.execute(`
+    const updateResult = await db.execute(`
     UPDATE c_note
     SET
       content_json = ?,
@@ -87,16 +141,20 @@ export async function appendTodoTasks(db, options) {
       version = COALESCE(version, 0) + 1
     WHERE id = ?
       AND (is_del IS NULL OR is_del = 0)
+      AND COALESCE(version, 0) = ?
+    RETURNING id
     `, [
         JSON.stringify(nextDoc),
         JSON.stringify(imageDetail),
         contentMd,
         contentText,
         now,
-        target.id,
+        noteId,
+        expectedVersion,
     ]);
+    assertSingleUpdatedRow(updateResult, `Note changed concurrently: ${noteId}. Re-run the todo append command.`);
     return {
-        note_id: target.id,
+        note_id: noteId,
         title: (target.title ?? '').trim(),
         appended_count: taskTexts.length,
         source,
@@ -105,12 +163,13 @@ export async function appendTodoTasks(db, options) {
 export async function createTodoNote(db, options) {
     const taskTexts = normalizeTaskTexts(options.taskTexts);
     const title = options.title?.trim() || buildSummaryTitle(taskTexts);
+    const noteId = generateId();
     const contentJson = createTodoDocFromTasks(taskTexts);
-    const imageDetail = deriveImageDetailFromContentJson(contentJson);
+    const imageDetail = deriveImageDetailFromContentJson(contentJson, noteId);
     const contentMd = buildCreateMarkdown(taskTexts);
     const contentText = buildContentTextPreview(contentMd);
     const created = await createNote(db, {
-        id: generateId(),
+        id: noteId,
         title,
         noteType: 'note',
         contentMd,
@@ -132,13 +191,17 @@ export async function updateTodoTaskStatus(db, options) {
     if (!taskId) {
         throw new DinoxError('taskId is required');
     }
-    const candidates = await loadTodoTaskCandidatesByTaskId(db, taskId);
+    const candidates = await loadTodoTaskCandidatesByTaskId(db, taskId, { noteId: options.noteId });
     const matches = [];
     const skippedCandidates = [];
     for (const candidate of candidates) {
         try {
+            const noteId = (candidate.id ?? '').trim();
+            if (!noteId) {
+                throw new DinoxError('Note id is required');
+            }
             const doc = parseTiptapDocFromDb(candidate.content_json);
-            const applied = applyTaskCheckedStatus(doc, taskId, options.checked);
+            const applied = applyTaskCheckedStatus(doc, noteId, taskId, options.checked);
             if (applied.matchedIndices.length === 0) {
                 continue;
             }
@@ -190,10 +253,10 @@ export async function updateTodoTaskStatus(db, options) {
     }
     const nextContentMd = patchTaskMarkdownByOrder(match.candidate.content_md, match.applied.taskOrder, match.applied.matchedIndices, options.checked);
     const nextContentText = buildContentTextPreview(nextContentMd);
-    const nextImageDetail = deriveImageDetailFromContentJson(match.applied.nextDoc);
+    const nextImageDetail = deriveImageDetailFromContentJson(match.applied.nextDoc, noteId);
     const hasMarkdownChanged = nextContentMd !== (match.candidate.content_md ?? '');
-    const hasContentJsonChanged = match.applied.changedCount > 0;
-    if (!hasContentJsonChanged && !hasMarkdownChanged) {
+    const hasStatusChanged = match.applied.statusChangedCount > 0;
+    if (!hasStatusChanged && !hasMarkdownChanged) {
         return {
             note_id: noteId,
             task_id: taskId,
@@ -202,7 +265,7 @@ export async function updateTodoTaskStatus(db, options) {
             title: (match.candidate.title ?? '').trim(),
         };
     }
-    await db.execute(`
+    const updateResult = await db.execute(`
     UPDATE c_note
     SET
       content_json = ?,
@@ -213,6 +276,8 @@ export async function updateTodoTaskStatus(db, options) {
       version = COALESCE(version, 0) + 1
     WHERE id = ?
       AND (is_del IS NULL OR is_del = 0)
+      AND COALESCE(version, 0) = ?
+    RETURNING id
     `, [
         JSON.stringify(match.applied.nextDoc),
         JSON.stringify(nextImageDetail),
@@ -220,7 +285,9 @@ export async function updateTodoTaskStatus(db, options) {
         nextContentText,
         nowIsoUtc(),
         noteId,
+        normalizeVersion(match.candidate.version),
     ]);
+    assertSingleUpdatedRow(updateResult, `Note changed concurrently: ${noteId}. Re-run the todo update command.`);
     return {
         note_id: noteId,
         task_id: taskId,
@@ -257,7 +324,8 @@ export async function getTodoAppendTargetById(db, noteId) {
       n.title,
       n.content_json,
       n.content_md,
-      n.is_del
+      n.is_del,
+      n.version
     FROM c_note n
     WHERE n.id = ?
     `, [noteId]);
@@ -269,7 +337,8 @@ export async function getLatestTodoAppendTarget(db) {
       n.title,
       n.content_json,
       n.content_md,
-      n.is_del
+      n.is_del,
+      n.version
     FROM c_note n
     WHERE (n.is_del IS NULL OR n.is_del = 0)
       AND n.image_detail IS NOT NULL
@@ -279,24 +348,64 @@ export async function getLatestTodoAppendTarget(db) {
     LIMIT 1
     `, []);
 }
-export async function loadTodoTaskCandidatesByTaskId(db, taskId) {
-    const escapedTaskId = escapeLikePattern(taskId);
-    return db.getAll(`
+export async function loadTodoTaskCandidatesByTaskId(db, taskId, options = {}) {
+    const exactNoteId = options.noteId?.trim();
+    if (options.noteId !== undefined && !exactNoteId) {
+        throw new DinoxError('--note-id cannot be empty');
+    }
+    if (exactNoteId) {
+        return db.getAll(`
+      SELECT
+        n.id,
+        n.title,
+        n.content_json,
+        n.content_md,
+        n.is_del,
+        n.created_at,
+        n.version
+      FROM c_note n
+      WHERE n.id = ?
+        AND (n.is_del IS NULL OR n.is_del = 0)
+        AND n.content_json IS NOT NULL
+        AND LENGTH(TRIM(n.content_json)) > 0
+      LIMIT 1
+      `, [exactNoteId]);
+    }
+    const pattern = isLegacyTaskId(taskId)
+        ? '%taskItem%'
+        : `%${escapeLikePattern(taskId)}%`;
+    const escapeClause = isLegacyTaskId(taskId) ? '' : " ESCAPE '\\'";
+    const candidates = await db.getAll(`
     SELECT
       n.id,
       n.title,
       n.content_json,
       n.content_md,
       n.is_del,
-      n.created_at
+      n.created_at,
+      n.version
     FROM c_note n
     WHERE (n.is_del IS NULL OR n.is_del = 0)
       AND n.content_json IS NOT NULL
       AND LENGTH(TRIM(n.content_json)) > 0
-      AND n.content_json LIKE ? ESCAPE '\\'
-    ORDER BY n.created_at DESC
-    LIMIT 500
-    `, [`%${escapedTaskId}%`]);
+      AND n.content_json LIKE ?${escapeClause}
+    LIMIT ?
+    `, [pattern, TODO_TASK_CANDIDATE_SCAN_LIMIT + 1]);
+    if (candidates.length > TODO_TASK_CANDIDATE_SCAN_LIMIT) {
+        throw new DinoxError(`Task lookup reached the ${TODO_TASK_CANDIDATE_SCAN_LIMIT}-note safety limit; refusing to update because task id uniqueness could not be verified.`, {
+            code: 'TODO_TASK_LOOKUP_TRUNCATED',
+            exitCode: 5,
+            suggestion: 'Run `dino todo search <task-text> --scan-limit 5000 --format json` to get the task note_id, then retry with `--note-id <note_id>`.',
+            details: {
+                taskId,
+                candidateLimit: TODO_TASK_CANDIDATE_SCAN_LIMIT,
+                scannedCandidateCount: candidates.length,
+                scanTruncated: true,
+            },
+            recoverable: true,
+        });
+    }
+    return candidates;
 }
 function escapeLikePattern(value) {
     return value.replace(/[\\%_]/g, (token) => `\\${token}`);

package/dist/commands/todo/taskIdentity.d.ts

@@ -0,0 +1,2 @@
+export declare function buildLegacyTaskId(noteId: string, preorderIndex: number, taskNode: unknown): string;
+export declare function isLegacyTaskId(value: string): boolean;

package/dist/commands/todo/taskIdentity.js

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+const LEGACY_TASK_ID_PREFIX = 'legacy-task-';
+const LEGACY_TASK_ID_RE = /^legacy-task-[a-f0-9]{24}$/;
+function normalizeChecked(value) {
+    if (value === true || value === 'true')
+        return true;
+    if (value === false || value === 'false')
+        return false;
+    return undefined;
+}
+function canonicalizeTaskIdentityValue(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => canonicalizeTaskIdentityValue(item))
+            .filter((item) => item !== undefined);
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const record = value;
+    if (record.type === 'taskList') {
+        return undefined;
+    }
+    const normalized = {};
+    for (const key of Object.keys(record).sort()) {
+        if (key === 'id' || key === 'checked') {
+            continue;
+        }
+        const next = canonicalizeTaskIdentityValue(record[key]);
+        if (next === undefined) {
+            continue;
+        }
+        if (key === 'attrs'
+            && next
+            && typeof next === 'object'
+            && !Array.isArray(next)
+            && Object.keys(next).length === 0) {
+            continue;
+        }
+        normalized[key] = next;
+    }
+    return normalized;
+}
+export function buildLegacyTaskId(noteId, preorderIndex, taskNode) {
+    const node = taskNode && typeof taskNode === 'object'
+        ? taskNode
+        : {};
+    const signature = JSON.stringify({
+        checked: normalizeChecked(node.checked) ?? normalizeChecked(node.attrs?.checked) ?? false,
+        node: canonicalizeTaskIdentityValue(taskNode),
+    });
+    const digest = createHash('sha256')
+        .update(noteId.trim())
+        .update('\0')
+        .update(String(preorderIndex))
+        .update('\0')
+        .update(signature)
+        .digest('hex')
+        .slice(0, 24);
+    return `${LEGACY_TASK_ID_PREFIX}${digest}`;
+}
+export function isLegacyTaskId(value) {
+    return LEGACY_TASK_ID_RE.test(value.trim());
+}

package/dist/commands/todo/taskModel.js

@@ -1,3 +1,4 @@
+import { buildLegacyTaskId } from './taskIdentity.js';
 const DEFAULT_TASK_TIME_DISPLAY_FORMAT = 'datetime';
 export function buildTaskKey(noteId, taskId) {
     return `${noteId}:${taskId}`;
@@ -14,6 +15,7 @@ export function extractFlattenedTasks(rows) {
             continue;
         }
         const { createdAt, createdAtRaw } = parseCreatedAt(row.created_at, row.updated_at);
+        const preorderState = { nextIndex: 0 };
         extracted.push(...extractTasksFromDetailWithHierarchy({
             noteId,
             noteTitle: normalizeString(row.title),
@@ -21,6 +23,7 @@ export function extractFlattenedTasks(rows) {
             createdAtRaw,
             noteTags: parseNoteTags(row.tags),
             taskItems,
+            preorderState,
         }));
     }
     extracted.sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime());
@@ -233,16 +236,15 @@ function extractNestedTasks(content) {
     return nested;
 }
 function extractTasksFromDetailWithHierarchy(input) {
-    const { noteId, noteTitle, createdAt, createdAtRaw, noteTags, taskItems, depth = 0 } = input;
+    const { noteId, noteTitle, createdAt, createdAtRaw, noteTags, taskItems, preorderState, depth = 0, } = input;
     const result = [];
     for (const item of taskItems) {
+        const preorderIndex = preorderState.nextIndex;
+        preorderState.nextIndex += 1;
         const taskId = normalizeString(item.id) ||
             normalizeString(item.attrs?.id) ||
-            '';
-        if (!taskId) {
-            continue;
-        }
-        const checked = item.checked === true || item.checked === 'true' || item.attrs?.checked === true;
+            buildLegacyTaskId(noteId, preorderIndex, item);
+        const checked = normalizeTaskChecked(item.checked) ?? normalizeTaskChecked(item.attrs?.checked) ?? false;
         const text = getTaskText(item).trim();
         const tags = getTaskTags(item);
         const { startTime, dueTime } = getTaskTimeRange(item);
@@ -253,6 +255,7 @@ function extractTasksFromDetailWithHierarchy(input) {
             createdAtRaw,
             noteTags,
             taskItems: extractNestedTasks(item.content),
+            preorderState,
             depth: depth + 1,
         });
         result.push({
@@ -302,18 +305,18 @@ function resolveTaskDateRange(taskDateRange) {
     if (!taskDateRange) {
         return null;
     }
-    const startSource = taskDateRange.startDate ?? taskDateRange.endDate;
-    const endSource = taskDateRange.endDate ?? taskDateRange.startDate;
-    if (!startSource || !endSource) {
+    if (!taskDateRange.startDate && !taskDateRange.endDate) {
         return null;
     }
-    const start = new Date(startSource);
-    const end = new Date(endSource);
+    const start = taskDateRange.startDate
+        ? new Date(taskDateRange.startDate)
+        : new Date(-8_640_000_000_000_000);
+    const end = taskDateRange.endDate
+        ? new Date(taskDateRange.endDate)
+        : new Date(8_640_000_000_000_000);
     if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
         return null;
     }
-    start.setHours(0, 0, 0, 0);
-    end.setHours(23, 59, 59, 999);
     return {
         startMs: Math.min(start.getTime(), end.getTime()),
         endMs: Math.max(start.getTime(), end.getTime()),
@@ -321,12 +324,12 @@ function resolveTaskDateRange(taskDateRange) {
 }
 function isTaskInDateRange(task, range) {
     const dueMs = parseTaskPointMs(task.dueTime);
-    if (dueMs !== null && dueMs >= range.startMs && dueMs <= range.endMs) {
-        return true;
+    if (dueMs !== null) {
+        return dueMs >= range.startMs && dueMs <= range.endMs;
     }
     const startMs = parseTaskPointMs(task.startTime);
-    if (startMs !== null && startMs >= range.startMs && startMs <= range.endMs) {
-        return true;
+    if (startMs !== null) {
+        return startMs >= range.startMs && startMs <= range.endMs;
     }
     const createdAtMs = task.createdAt.getTime();
     if (!Number.isNaN(createdAtMs) && createdAtMs >= range.startMs && createdAtMs <= range.endMs) {
@@ -347,3 +350,10 @@ function normalizeString(value) {
     }
     return value.trim();
 }
+function normalizeTaskChecked(value) {
+    if (value === true || value === 'true')
+        return true;
+    if (value === false || value === 'false')
+        return false;
+    return undefined;
+}

package/dist/commands/update.d.ts

@@ -4,10 +4,22 @@ type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
 type LogFn = (...parts: unknown[]) => void;
 type UpdateCommandDeps = {
     detectPackageManager: () => PackageManager;
-    runUpdate: (pm: PackageManager) => Promise<void>;
+    runUpdate: (pm: PackageManager, options: {
+        structuredOutput: boolean;
+    }) => Promise<void>;
     getVersion: () => string;
     log: LogFn;
 };
+export declare function detectPackageManager(input?: {
+    env?: NodeJS.ProcessEnv;
+    scriptPath?: string;
+}): PackageManager;
+type UpdateSpawnSpec = {
+    command: string;
+    args: string[];
+    shell: boolean;
+};
+export declare function resolveUpdateSpawnSpec(pm: PackageManager, platform?: NodeJS.Platform): UpdateSpawnSpec;
 export declare function createUpdateCommandDescriptor(overrides?: Partial<UpdateCommandDeps>): CommandDescriptor;
 export declare const updateCommandDescriptor: CommandDescriptor;
 export declare function registerUpdateCommand(program: Command, overrides?: Partial<UpdateCommandDeps>): void;