@dinoxx/dinox-cli 1.0.12 → 1.0.14

package/dist/commands/todo/repo.js

@@ -0,0 +1,286 @@
+import { createNote } from '../notes/repo.js';
+import { DinoxError } from '../../utils/errors.js';
+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';
+export { normalizeTaskTexts } from './contentModel.js';
+export async function searchTodoTasks(db, query, options) {
+    const noteRows = await loadTodoNoteRows(db, options.includeDeleted, options.scanLimit);
+    const allTasks = extractFlattenedTasks(noteRows);
+    const filteredTasks = filterTasksForTodoList(allTasks, query, options.taskStatus, options.taskTagFilter, options.taskDateRange);
+    const visibleTasks = filteredTasks.slice(0, options.limit);
+    const tasks = visibleTasks.map((task) => ({
+        task_key: buildTaskKey(task.noteId, task.taskId),
+        note_id: task.noteId,
+        note_title: task.noteTitle,
+        task_id: task.taskId,
+        text: task.text,
+        checked: task.checked,
+        status: task.checked ? 'completed' : 'uncompleted',
+        created_at: task.createdAtRaw,
+        depth: task.depth,
+        has_children: task.hasChildren,
+        parent_id: task.parentId,
+        tags: task.tags ?? [],
+        note_tags: task.noteTags ?? [],
+        start_time: task.startTime,
+        due_time: task.dueTime,
+    }));
+    return {
+        meta: {
+            query: query.trim(),
+            returned_count: tasks.length,
+            total_count: filteredTasks.length,
+            matched_note_count: new Set(tasks.map((task) => task.note_id)).size,
+            limit: options.limit,
+            scan_limit: options.scanLimit,
+            truncated: filteredTasks.length > tasks.length,
+            applied_filters: {
+                status: options.taskStatus,
+                tags: [...options.taskTagFilter],
+                include_deleted: options.includeDeleted,
+                date_range: serializeTaskDateRange(options.taskDateRange),
+            },
+        },
+        tasks,
+    };
+}
+export async function appendTodoTasks(db, options) {
+    const taskTexts = normalizeTaskTexts(options.taskTexts);
+    const explicitNoteId = typeof options.noteId === 'string' ? options.noteId.trim() : '';
+    const source = explicitNoteId ? 'explicit' : 'latest_non_empty_image_detail';
+    const target = explicitNoteId
+        ? await getTodoAppendTargetById(db, explicitNoteId)
+        : await getLatestTodoAppendTarget(db);
+    if (!target) {
+        if (explicitNoteId) {
+            throw new DinoxError(`Note not found: ${explicitNoteId}`);
+        }
+        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 nextDoc = appendTasksToDoc(currentDoc, taskTexts);
+    const imageDetail = deriveImageDetailFromContentJson(nextDoc);
+    const contentMd = buildAppendMarkdown(target.content_md, taskTexts);
+    const contentText = buildContentTextPreview(contentMd);
+    const now = nowIsoUtc();
+    await db.execute(`
+    UPDATE c_note
+    SET
+      content_json = ?,
+      image_detail = ?,
+      content_md = ?,
+      content_text = ?,
+      updated_at = ?,
+      version = COALESCE(version, 0) + 1
+    WHERE id = ?
+      AND (is_del IS NULL OR is_del = 0)
+    `, [
+        JSON.stringify(nextDoc),
+        JSON.stringify(imageDetail),
+        contentMd,
+        contentText,
+        now,
+        target.id,
+    ]);
+    return {
+        note_id: target.id,
+        title: (target.title ?? '').trim(),
+        appended_count: taskTexts.length,
+        source,
+    };
+}
+export async function createTodoNote(db, options) {
+    const taskTexts = normalizeTaskTexts(options.taskTexts);
+    const title = options.title?.trim() || buildSummaryTitle(taskTexts);
+    const contentJson = createTodoDocFromTasks(taskTexts);
+    const imageDetail = deriveImageDetailFromContentJson(contentJson);
+    const contentMd = buildCreateMarkdown(taskTexts);
+    const contentText = buildContentTextPreview(contentMd);
+    const created = await createNote(db, {
+        id: generateId(),
+        title,
+        noteType: 'note',
+        contentMd,
+        contentJson,
+        contentText,
+        tags: [],
+        zettelBoxIds: [],
+        userId: options.userId,
+        imageDetail,
+    });
+    return {
+        note_id: created.id,
+        title,
+        created_count: taskTexts.length,
+    };
+}
+export async function updateTodoTaskStatus(db, options) {
+    const taskId = options.taskId.trim();
+    if (!taskId) {
+        throw new DinoxError('taskId is required');
+    }
+    const candidates = await loadTodoTaskCandidatesByTaskId(db, taskId);
+    const matches = candidates.flatMap((candidate) => {
+        try {
+            const doc = parseTiptapDocFromDb(candidate.content_json);
+            const applied = applyTaskCheckedStatus(doc, taskId, options.checked);
+            if (applied.matchedIndices.length === 0) {
+                return [];
+            }
+            return [{ candidate, applied }];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (matches.length === 0) {
+        throw new DinoxError(`Task not found: ${taskId}`);
+    }
+    if (matches.length > 1) {
+        const noteIds = matches
+            .map((entry) => entry.candidate.id?.trim())
+            .filter((value) => Boolean(value));
+        throw new DinoxError(`Task id is not unique; found in multiple notes: ${noteIds.join(', ')}`);
+    }
+    const match = matches[0];
+    const noteId = (match.candidate.id ?? '').trim();
+    if (!noteId) {
+        throw new DinoxError('Note id is required');
+    }
+    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 hasMarkdownChanged = nextContentMd !== (match.candidate.content_md ?? '');
+    const hasContentJsonChanged = match.applied.changedCount > 0;
+    if (!hasContentJsonChanged && !hasMarkdownChanged) {
+        return {
+            note_id: noteId,
+            task_id: taskId,
+            checked: options.checked,
+            updated: false,
+            title: (match.candidate.title ?? '').trim(),
+        };
+    }
+    await db.execute(`
+    UPDATE c_note
+    SET
+      content_json = ?,
+      image_detail = ?,
+      content_md = ?,
+      content_text = ?,
+      updated_at = ?,
+      version = COALESCE(version, 0) + 1
+    WHERE id = ?
+      AND (is_del IS NULL OR is_del = 0)
+    `, [
+        JSON.stringify(match.applied.nextDoc),
+        JSON.stringify(nextImageDetail),
+        nextContentMd,
+        nextContentText,
+        nowIsoUtc(),
+        noteId,
+    ]);
+    return {
+        note_id: noteId,
+        task_id: taskId,
+        checked: options.checked,
+        updated: true,
+        title: (match.candidate.title ?? '').trim(),
+    };
+}
+async function loadTodoNoteRows(db, includeDeleted, scanLimit) {
+    const whereClauses = [
+        includeDeleted ? '1 = 1' : '(n.is_del IS NULL OR n.is_del = 0)',
+        'n.image_detail IS NOT NULL',
+        "LENGTH(TRIM(n.image_detail)) > 0",
+        "TRIM(n.image_detail) <> '[]'",
+    ];
+    return db.getAll(`
+    SELECT
+      n.id,
+      n.title,
+      n.image_detail,
+      n.tags,
+      n.created_at,
+      n.updated_at
+    FROM c_note n
+    WHERE ${whereClauses.join('\n      AND ')}
+    ORDER BY COALESCE(n.created_at, n.updated_at) DESC
+    LIMIT ?
+    `, [scanLimit]);
+}
+async function getTodoAppendTargetById(db, noteId) {
+    return db.getOptional(`
+    SELECT
+      n.id,
+      n.title,
+      n.content_json,
+      n.content_md,
+      n.is_del
+    FROM c_note n
+    WHERE n.id = ?
+    `, [noteId]);
+}
+async function getLatestTodoAppendTarget(db) {
+    return db.getOptional(`
+    SELECT
+      n.id,
+      n.title,
+      n.content_json,
+      n.content_md,
+      n.is_del
+    FROM c_note n
+    WHERE (n.is_del IS NULL OR n.is_del = 0)
+      AND n.image_detail IS NOT NULL
+      AND LENGTH(TRIM(n.image_detail)) > 0
+      AND TRIM(n.image_detail) <> '[]'
+    ORDER BY n.created_at DESC
+    LIMIT 1
+    `, []);
+}
+async function loadTodoTaskCandidatesByTaskId(db, taskId) {
+    const escapedTaskId = escapeLikePattern(taskId);
+    return db.getAll(`
+    SELECT
+      n.id,
+      n.title,
+      n.content_json,
+      n.content_md,
+      n.is_del,
+      n.created_at
+    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}%`]);
+}
+function escapeLikePattern(value) {
+    return value.replace(/[\\%_]/g, (token) => `\\${token}`);
+}
+function serializeTaskDateRange(value) {
+    if (!value) {
+        return null;
+    }
+    const from = value.startDate ? new Date(value.startDate).toISOString() : null;
+    const to = value.endDate ? new Date(value.endDate).toISOString() : null;
+    if (!from && !to) {
+        return null;
+    }
+    return { from, to };
+}

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

@@ -0,0 +1,37 @@
+export type TaskStatusFilter = 'all' | 'completed' | 'uncompleted';
+export type TaskTimeDisplayFormat = 'date' | 'datetime' | 'datetime-seconds' | 'time';
+export type TaskTimePoint = {
+    iso: string;
+    displayFormat: TaskTimeDisplayFormat;
+};
+export type TaskDateRangeFilter = {
+    startDate?: Date;
+    endDate?: Date;
+};
+export type TodoTaskSourceRow = {
+    id: string | null;
+    title?: string | null;
+    image_detail: unknown;
+    tags: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+};
+export type FlattenedTask = {
+    noteId: string;
+    noteTitle: string;
+    taskId: string;
+    text: string;
+    checked: boolean;
+    createdAt: Date;
+    createdAtRaw: string | null;
+    startTime?: TaskTimePoint;
+    dueTime?: TaskTimePoint;
+    tags?: string[];
+    noteTags?: string[];
+    depth: number;
+    hasChildren: boolean;
+    parentId: string | null;
+};
+export declare function buildTaskKey(noteId: string, taskId: string): string;
+export declare function extractFlattenedTasks(rows: TodoTaskSourceRow[]): FlattenedTask[];
+export declare function filterTasksForTodoList(allTasks: FlattenedTask[], query: string, taskStatus: TaskStatusFilter, taskTagFilter: string[], taskDateRange?: TaskDateRangeFilter): FlattenedTask[];

package/dist/commands/todo/taskModel.js

@@ -0,0 +1,349 @@
+const DEFAULT_TASK_TIME_DISPLAY_FORMAT = 'datetime';
+export function buildTaskKey(noteId, taskId) {
+    return `${noteId}:${taskId}`;
+}
+export function extractFlattenedTasks(rows) {
+    const extracted = [];
+    for (const row of rows) {
+        const noteId = normalizeString(row.id);
+        if (!noteId) {
+            continue;
+        }
+        const taskItems = parseImageDetailTaskItems(row.image_detail);
+        if (taskItems.length === 0) {
+            continue;
+        }
+        const { createdAt, createdAtRaw } = parseCreatedAt(row.created_at, row.updated_at);
+        extracted.push(...extractTasksFromDetailWithHierarchy({
+            noteId,
+            noteTitle: normalizeString(row.title),
+            createdAt,
+            createdAtRaw,
+            noteTags: parseNoteTags(row.tags),
+            taskItems,
+        }));
+    }
+    extracted.sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime());
+    return flattenTasks(extracted);
+}
+export function filterTasksForTodoList(allTasks, query, taskStatus, taskTagFilter, taskDateRange) {
+    let filteredTasks = allTasks;
+    const normalizedQuery = query.trim().toLocaleLowerCase();
+    if (normalizedQuery) {
+        filteredTasks = filteredTasks.filter((task) => task.text.toLocaleLowerCase().includes(normalizedQuery));
+    }
+    if (taskStatus === 'completed') {
+        filteredTasks = filteredTasks.filter((task) => task.checked);
+    }
+    else if (taskStatus === 'uncompleted') {
+        filteredTasks = filteredTasks.filter((task) => !task.checked);
+    }
+    if (taskTagFilter.length > 0) {
+        filteredTasks = filteredTasks.filter((task) => taskTagFilter.every((tag) => task.tags?.some((taskTag) => taskTag.trim() === tag)));
+    }
+    const range = resolveTaskDateRange(taskDateRange);
+    if (range) {
+        filteredTasks = filteredTasks.filter((task) => isTaskInDateRange(task, range));
+    }
+    return filteredTasks;
+}
+function parseImageDetailTaskItems(raw) {
+    if (Array.isArray(raw)) {
+        return pickTaskItems(raw);
+    }
+    if (typeof raw !== 'string') {
+        return [];
+    }
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return pickTaskItems(parsed);
+    }
+    catch {
+        return [];
+    }
+}
+function pickTaskItems(values) {
+    const result = [];
+    for (const value of values) {
+        if (!value || typeof value !== 'object') {
+            continue;
+        }
+        const node = value;
+        if (node.type !== 'taskItem') {
+            continue;
+        }
+        result.push(node);
+    }
+    return result;
+}
+function parseCreatedAt(createdAtRaw, updatedAtRaw) {
+    const createdAtValue = normalizeString(createdAtRaw) || null;
+    const fallback = normalizeString(updatedAtRaw) || null;
+    const source = createdAtValue ?? fallback;
+    if (!source) {
+        return { createdAt: new Date(0), createdAtRaw: createdAtValue };
+    }
+    const parsed = new Date(source);
+    if (Number.isNaN(parsed.getTime())) {
+        return { createdAt: new Date(0), createdAtRaw: createdAtValue };
+    }
+    return { createdAt: parsed, createdAtRaw: createdAtValue };
+}
+function parseNoteTags(raw) {
+    const value = normalizeString(raw);
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return undefined;
+        }
+        const tags = uniqueTrimmedStrings(parsed);
+        return tags.length > 0 ? tags : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function uniqueTrimmedStrings(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = normalizeString(String(value));
+        if (!normalized || seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
+function normalizeTaskTimeDisplayFormat(value) {
+    if (value === 'date')
+        return 'date';
+    if (value === 'datetime')
+        return 'datetime';
+    if (value === 'datetime-seconds')
+        return 'datetime-seconds';
+    if (value === 'time')
+        return 'time';
+    return DEFAULT_TASK_TIME_DISPLAY_FORMAT;
+}
+function getTaskText(node) {
+    if (!node || typeof node !== 'object')
+        return '';
+    const taskNode = node;
+    if (typeof taskNode.text === 'string') {
+        return (taskNode.text ?? '').trim();
+    }
+    if (taskNode.type === 'taskList') {
+        return '';
+    }
+    if (!Array.isArray(taskNode.content)) {
+        return '';
+    }
+    return taskNode.content.map((child) => getTaskText(child)).join('');
+}
+function getTaskTags(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const taskNode = node;
+    if (taskNode.type === 'hashtag') {
+        const label = normalizeString(taskNode.attrs?.label);
+        return label ? [label] : [];
+    }
+    if (taskNode.type === 'taskList') {
+        return [];
+    }
+    if (!Array.isArray(taskNode.content)) {
+        return [];
+    }
+    return taskNode.content.flatMap((child) => getTaskTags(child));
+}
+function collectTaskTimeNodes(node, out) {
+    if (!node || typeof node !== 'object' || out.length >= 2) {
+        return;
+    }
+    const taskNode = node;
+    if (taskNode.type === 'taskList') {
+        return;
+    }
+    if (taskNode.type === 'time' || taskNode.type === 'timeblock') {
+        const iso = normalizeString(taskNode.attrs?.iso);
+        if (iso) {
+            out.push({
+                iso,
+                displayFormat: normalizeTaskTimeDisplayFormat(taskNode.attrs?.displayFormat),
+            });
+            if (out.length >= 2) {
+                return;
+            }
+        }
+    }
+    if (!Array.isArray(taskNode.content)) {
+        return;
+    }
+    for (const child of taskNode.content) {
+        collectTaskTimeNodes(child, out);
+        if (out.length >= 2) {
+            return;
+        }
+    }
+}
+function getTaskTimeRange(node) {
+    const points = [];
+    collectTaskTimeNodes(node, points);
+    if (points.length === 0) {
+        return {};
+    }
+    if (points.length === 1) {
+        return { dueTime: points[0] };
+    }
+    return {
+        startTime: points[0],
+        dueTime: points[1],
+    };
+}
+function extractNestedTasks(content) {
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const nested = [];
+    for (const value of content) {
+        if (!value || typeof value !== 'object') {
+            continue;
+        }
+        const node = value;
+        if (node.type === 'taskList' && Array.isArray(node.content)) {
+            nested.push(...pickTaskItems(node.content));
+            continue;
+        }
+        if (node.type === 'taskItem') {
+            nested.push(node);
+        }
+    }
+    return nested;
+}
+function extractTasksFromDetailWithHierarchy(input) {
+    const { noteId, noteTitle, createdAt, createdAtRaw, noteTags, taskItems, depth = 0 } = input;
+    const result = [];
+    for (const item of taskItems) {
+        const taskId = normalizeString(item.id) ||
+            normalizeString(item.attrs?.id) ||
+            '';
+        if (!taskId) {
+            continue;
+        }
+        const checked = item.checked === true || item.checked === 'true' || item.attrs?.checked === true;
+        const text = getTaskText(item).trim();
+        const tags = getTaskTags(item);
+        const { startTime, dueTime } = getTaskTimeRange(item);
+        const children = extractTasksFromDetailWithHierarchy({
+            noteId,
+            noteTitle,
+            createdAt,
+            createdAtRaw,
+            noteTags,
+            taskItems: extractNestedTasks(item.content),
+            depth: depth + 1,
+        });
+        result.push({
+            noteId,
+            noteTitle,
+            taskId,
+            text,
+            checked,
+            createdAt,
+            createdAtRaw,
+            startTime,
+            dueTime,
+            tags: tags.length > 0 ? tags : undefined,
+            noteTags,
+            children,
+            depth,
+        });
+    }
+    return result;
+}
+function flattenTasks(tasks, parentId = null) {
+    const result = [];
+    for (const task of tasks) {
+        result.push({
+            noteId: task.noteId,
+            noteTitle: task.noteTitle,
+            taskId: task.taskId,
+            text: task.text,
+            checked: task.checked,
+            createdAt: task.createdAt,
+            createdAtRaw: task.createdAtRaw,
+            startTime: task.startTime,
+            dueTime: task.dueTime,
+            tags: task.tags,
+            noteTags: task.noteTags,
+            depth: task.depth,
+            hasChildren: task.children.length > 0,
+            parentId,
+        });
+        if (task.children.length > 0) {
+            result.push(...flattenTasks(task.children, task.taskId));
+        }
+    }
+    return result;
+}
+function resolveTaskDateRange(taskDateRange) {
+    if (!taskDateRange) {
+        return null;
+    }
+    const startSource = taskDateRange.startDate ?? taskDateRange.endDate;
+    const endSource = taskDateRange.endDate ?? taskDateRange.startDate;
+    if (!startSource || !endSource) {
+        return null;
+    }
+    const start = new Date(startSource);
+    const end = new Date(endSource);
+    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()),
+    };
+}
+function isTaskInDateRange(task, range) {
+    const dueMs = parseTaskPointMs(task.dueTime);
+    if (dueMs !== null && dueMs >= range.startMs && dueMs <= range.endMs) {
+        return true;
+    }
+    const startMs = parseTaskPointMs(task.startTime);
+    if (startMs !== null && startMs >= range.startMs && startMs <= range.endMs) {
+        return true;
+    }
+    const createdAtMs = task.createdAt.getTime();
+    if (!Number.isNaN(createdAtMs) && createdAtMs >= range.startMs && createdAtMs <= range.endMs) {
+        return true;
+    }
+    return false;
+}
+function parseTaskPointMs(point) {
+    if (!point?.iso) {
+        return null;
+    }
+    const timestamp = Date.parse(point.iso);
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
+function normalizeString(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+}

package/dist/commands/update.d.ts

@@ -1,2 +1,11 @@
 import { Command } from 'commander';
-export declare function registerUpdateCommand(program: Command): void;
+type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+type LogFn = (...parts: unknown[]) => void;
+type UpdateCommandDeps = {
+    detectPackageManager: () => PackageManager;
+    runUpdate: (pm: PackageManager) => Promise<void>;
+    getVersion: () => string;
+    log: LogFn;
+};
+export declare function registerUpdateCommand(program: Command, overrides?: Partial<UpdateCommandDeps>): void;
+export {};