@dinoxx/dinox-cli 1.0.11 → 1.0.13

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

@@ -0,0 +1,85 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type TaskDateRangeFilter, type TaskStatusFilter, type TaskTimePoint } from './taskModel.js';
+export type SearchTodoOptions = {
+    includeDeleted: boolean;
+    taskStatus: TaskStatusFilter;
+    taskTagFilter: string[];
+    taskDateRange?: TaskDateRangeFilter;
+    limit: number;
+    scanLimit: number;
+};
+export type AppendTodoTasksOptions = {
+    noteId?: string;
+    taskTexts: string[];
+};
+export type AppendTodoTasksResult = {
+    note_id: string;
+    title: string;
+    appended_count: number;
+    source: 'explicit' | 'latest_non_empty_image_detail';
+};
+export type CreateTodoNoteOptions = {
+    title?: string;
+    taskTexts: string[];
+    userId: string;
+};
+export type CreateTodoNoteResult = {
+    note_id: string;
+    title: string;
+    created_count: number;
+};
+export type UpdateTodoTaskStatusOptions = {
+    taskId: string;
+    checked: boolean;
+};
+export type UpdateTodoTaskStatusResult = {
+    note_id: string;
+    task_id: string;
+    checked: boolean;
+    updated: boolean;
+    title: string;
+};
+export type SearchedTodo = {
+    task_key: string;
+    note_id: string;
+    note_title: string;
+    task_id: string;
+    text: string;
+    checked: boolean;
+    status: 'completed' | 'uncompleted';
+    created_at: string | null;
+    depth: number;
+    has_children: boolean;
+    parent_id: string | null;
+    tags: string[];
+    note_tags: string[];
+    start_time?: TaskTimePoint;
+    due_time?: TaskTimePoint;
+};
+export type SearchedTodoResponse = {
+    meta: {
+        query: string;
+        returned_count: number;
+        total_count: number;
+        matched_note_count: number;
+        limit: number;
+        scan_limit: number;
+        truncated: boolean;
+        applied_filters: {
+            status: TaskStatusFilter;
+            tags: string[];
+            include_deleted: boolean;
+            date_range: {
+                from: string | null;
+                to: string | null;
+            } | null;
+        };
+    };
+    tasks: SearchedTodo[];
+};
+export type { TaskDateRangeFilter, TaskStatusFilter } from './taskModel.js';
+export { normalizeTaskTexts } from './contentModel.js';
+export declare function searchTodoTasks(db: AbstractPowerSyncDatabase, query: string, options: SearchTodoOptions): Promise<SearchedTodoResponse>;
+export declare function appendTodoTasks(db: AbstractPowerSyncDatabase, options: AppendTodoTasksOptions): Promise<AppendTodoTasksResult>;
+export declare function createTodoNote(db: AbstractPowerSyncDatabase, options: CreateTodoNoteOptions): Promise<CreateTodoNoteResult>;
+export declare function updateTodoTaskStatus(db: AbstractPowerSyncDatabase, options: UpdateTodoTaskStatusOptions): Promise<UpdateTodoTaskStatusResult>;

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[];