@dinoxx/dinox-cli 1.0.11 → 1.0.13

package/dist/commands/todo/contentModel.js

@@ -0,0 +1,325 @@
+import { DinoxError } from '../../utils/errors.js';
+import { generateId } from '../../utils/id.js';
+import { stripMarkdown } from '../../utils/text.js';
+const CONTENT_TEXT_PREVIEW_LIMIT = 300;
+const DEFAULT_TITLE_PREFIX = '待办清单';
+export function parseTiptapDocFromDb(rawContentJson) {
+    const raw = (rawContentJson ?? '').trim();
+    if (!raw) {
+        throw new DinoxError('Invalid note content_json: empty value');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new DinoxError('Invalid note content_json: malformed JSON', { cause: error });
+    }
+    return assertTiptapDoc(parsed);
+}
+export function createTodoDocFromTasks(taskTexts) {
+    const tasks = buildTaskItemNodes(taskTexts);
+    return {
+        type: 'doc',
+        content: [
+            {
+                type: 'taskList',
+                content: tasks,
+            },
+        ],
+    };
+}
+export function appendTasksToDoc(doc, taskTexts) {
+    const nextDoc = cloneJson(doc);
+    const tasks = buildTaskItemNodes(taskTexts);
+    const content = ensureDocContentArray(nextDoc);
+    const lastIndex = content.length - 1;
+    const lastNode = lastIndex >= 0 ? content[lastIndex] : null;
+    if (isTaskListNode(lastNode)) {
+        const listContent = ensureNodeContentArray(lastNode);
+        listContent.push(...tasks);
+        return nextDoc;
+    }
+    content.push({
+        type: 'taskList',
+        content: tasks,
+    });
+    return nextDoc;
+}
+export function deriveImageDetailFromContentJson(doc) {
+    const root = assertTiptapDoc(doc);
+    const rootContent = ensureNodeContentArray(root);
+    const result = [];
+    const nodeStack = [];
+    const insideTaskStack = [];
+    for (let index = rootContent.length - 1; index >= 0; index -= 1) {
+        nodeStack.push(rootContent[index]);
+        insideTaskStack.push(false);
+    }
+    while (nodeStack.length > 0) {
+        const current = nodeStack.pop();
+        const insideTaskItem = insideTaskStack.pop() ?? false;
+        if (!current || typeof current !== 'object') {
+            continue;
+        }
+        const node = current;
+        const type = typeof node.type === 'string' ? node.type : '';
+        const content = Array.isArray(node.content) ? node.content : [];
+        if (type === 'taskItem' && !insideTaskItem) {
+            result.push(normalizeTaskItemNode(node));
+        }
+        const nextInsideTaskItem = insideTaskItem || type === 'taskItem';
+        for (let index = content.length - 1; index >= 0; index -= 1) {
+            nodeStack.push(content[index]);
+            insideTaskStack.push(nextInsideTaskItem);
+        }
+    }
+    return result;
+}
+export function buildAppendMarkdown(existingMarkdown, taskTexts) {
+    const trimmed = (existingMarkdown ?? '').trimEnd();
+    const taskBlock = buildTaskMarkdown(taskTexts);
+    if (!trimmed) {
+        return taskBlock;
+    }
+    return `${trimmed}\n\n${taskBlock}`;
+}
+export function buildCreateMarkdown(taskTexts) {
+    return buildTaskMarkdown(taskTexts);
+}
+export function buildContentTextPreview(contentMd) {
+    const plain = stripMarkdown(contentMd);
+    const chars = Array.from(plain);
+    if (chars.length <= CONTENT_TEXT_PREVIEW_LIMIT) {
+        return plain;
+    }
+    return chars.slice(0, CONTENT_TEXT_PREVIEW_LIMIT).join('');
+}
+export function buildSummaryTitle(taskTexts) {
+    const count = taskTexts.length;
+    const keywords = taskTexts
+        .slice(0, 2)
+        .map((task) => task.trim())
+        .filter(Boolean)
+        .map((task) => truncateChars(task, 12))
+        .join('、');
+    if (!keywords) {
+        return `${DEFAULT_TITLE_PREFIX}（${count}项）`;
+    }
+    const base = `${DEFAULT_TITLE_PREFIX}（${count}项）：${keywords}`;
+    return truncateChars(base, 60);
+}
+export function normalizeTaskTexts(values) {
+    const normalized = values
+        .map((value) => value.replace(/\s+/g, ' ').trim())
+        .filter((value) => value.length > 0);
+    if (normalized.length === 0) {
+        throw new DinoxError('At least one non-empty task is required');
+    }
+    return normalized;
+}
+export function applyTaskCheckedStatus(doc, taskId, checked) {
+    const normalizedTaskId = taskId.trim();
+    if (!normalizedTaskId) {
+        throw new DinoxError('taskId is required');
+    }
+    const nextDoc = cloneJson(assertTiptapDoc(doc));
+    const taskOrder = [];
+    const matchedIndices = [];
+    let changedCount = 0;
+    const visitNode = (value) => {
+        if (!value || typeof value !== 'object') {
+            return;
+        }
+        const node = value;
+        const type = typeof node.type === 'string' ? node.type : '';
+        if (type === 'taskItem') {
+            const currentTaskId = resolveTaskId(node);
+            if (currentTaskId) {
+                const currentIndex = taskOrder.length;
+                taskOrder.push(currentTaskId);
+                if (currentTaskId === normalizedTaskId) {
+                    matchedIndices.push(currentIndex);
+                    const attrs = ensureNodeAttrs(node);
+                    const previousChecked = normalizeChecked(node.checked) ?? normalizeChecked(attrs.checked) ?? false;
+                    if (previousChecked !== checked) {
+                        changedCount += 1;
+                    }
+                    node.id = currentTaskId;
+                    node.checked = checked;
+                    attrs.id = currentTaskId;
+                    attrs.checked = checked;
+                }
+            }
+        }
+        const content = Array.isArray(node.content) ? node.content : [];
+        for (const child of content) {
+            visitNode(child);
+        }
+    };
+    visitNode(nextDoc);
+    return {
+        nextDoc,
+        taskOrder,
+        matchedIndices,
+        changedCount,
+    };
+}
+export function patchTaskMarkdownByOrder(contentMd, taskOrder, matchedIndices, checked) {
+    if (taskOrder.length === 0 || matchedIndices.length === 0) {
+        return contentMd ?? '';
+    }
+    const markdown = contentMd ?? '';
+    if (!markdown.trim()) {
+        throw new DinoxError('Cannot update task markdown: note has task entries in content_json but empty content_md.');
+    }
+    const lines = markdown.split('\n');
+    const checklistLineIndexes = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (TASK_MARKDOWN_LINE_RE.test(lines[index] ?? '')) {
+            checklistLineIndexes.push(index);
+        }
+    }
+    if (checklistLineIndexes.length !== taskOrder.length) {
+        throw new DinoxError(`Cannot update task markdown: checklist line count (${checklistLineIndexes.length}) does not match content_json task count (${taskOrder.length}).`);
+    }
+    for (const matchedIndex of matchedIndices) {
+        const lineIndex = checklistLineIndexes[matchedIndex];
+        if (lineIndex === undefined) {
+            throw new DinoxError('Cannot update task markdown: task index is out of range.');
+        }
+        lines[lineIndex] = patchChecklistLine(lines[lineIndex] ?? '', checked);
+    }
+    return lines.join('\n');
+}
+function buildTaskItemNodes(taskTexts) {
+    const normalizedTasks = normalizeTaskTexts(taskTexts);
+    return normalizedTasks.map((text) => {
+        const taskId = generateId();
+        return {
+            type: 'taskItem',
+            id: taskId,
+            checked: false,
+            attrs: {
+                id: taskId,
+                checked: false,
+            },
+            content: [
+                {
+                    type: 'paragraph',
+                    content: [
+                        {
+                            type: 'text',
+                            text,
+                        },
+                    ],
+                },
+            ],
+        };
+    });
+}
+function buildTaskMarkdown(taskTexts) {
+    const normalizedTasks = normalizeTaskTexts(taskTexts);
+    return normalizedTasks.map((task) => `- [ ] ${task}`).join('\n');
+}
+function assertTiptapDoc(value) {
+    if (!value || typeof value !== 'object') {
+        throw new DinoxError('Invalid note content_json: expected object');
+    }
+    const doc = value;
+    if (doc.type !== 'doc') {
+        throw new DinoxError('Invalid note content_json: root.type must be "doc"');
+    }
+    if (!Array.isArray(doc.content)) {
+        throw new DinoxError('Invalid note content_json: root.content must be an array');
+    }
+    return doc;
+}
+function ensureDocContentArray(doc) {
+    const content = doc.content;
+    if (Array.isArray(content)) {
+        return content;
+    }
+    doc.content = [];
+    return doc.content;
+}
+function ensureNodeContentArray(node) {
+    const content = node.content;
+    if (Array.isArray(content)) {
+        return content;
+    }
+    node.content = [];
+    return node.content;
+}
+function isTaskListNode(node) {
+    return Boolean(node && typeof node === 'object' && node.type === 'taskList');
+}
+function ensureNodeAttrs(node) {
+    if (!isObject(node.attrs)) {
+        node.attrs = {};
+    }
+    return node.attrs;
+}
+function resolveTaskId(node) {
+    const nodeId = normalizeString(node.id);
+    if (nodeId) {
+        return nodeId;
+    }
+    const attrs = isObject(node.attrs) ? node.attrs : null;
+    const attrsId = normalizeString(attrs?.id);
+    return attrsId;
+}
+function normalizeTaskItemNode(node) {
+    const attrsSource = isObject(node.attrs) ? node.attrs : {};
+    const nodeId = normalizeString(node.id);
+    const attrsId = normalizeString(attrsSource.id);
+    const taskId = nodeId || attrsId || generateId();
+    const checked = normalizeChecked(node.checked) ?? normalizeChecked(attrsSource.checked) ?? false;
+    return {
+        type: 'taskItem',
+        id: taskId,
+        checked,
+        attrs: {
+            ...attrsSource,
+            id: taskId,
+            checked,
+        },
+        content: Array.isArray(node.content) ? cloneJson(node.content) : [],
+    };
+}
+function normalizeChecked(value) {
+    if (value === true)
+        return true;
+    if (value === false)
+        return false;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return undefined;
+}
+function normalizeString(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+}
+function truncateChars(value, limit) {
+    const chars = Array.from(value);
+    if (chars.length <= limit) {
+        return value;
+    }
+    return chars.slice(0, limit).join('');
+}
+function isObject(value) {
+    return Boolean(value && typeof value === 'object');
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function patchChecklistLine(line, checked) {
+    return line.replace(TASK_MARKDOWN_LINE_RE, (_, prefix, suffix) => {
+        return `${prefix}${checked ? 'x' : ' '}${suffix}`;
+    });
+}
+const TASK_MARKDOWN_LINE_RE = /^(\s*[-*+]\s+\[)[ xX](\].*)$/;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerTodoCommands(program: Command): void;

package/dist/commands/todo/index.js

@@ -0,0 +1,349 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { DinoxError } from '../../utils/errors.js';
+import { readStringOrFile } from '../../utils/argValue.js';
+import { printYaml } from '../../utils/output.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { appendTodoTasks, createTodoNote, normalizeTaskTexts, searchTodoTasks, updateTodoTaskStatus, } from './repo.js';
+const DATE_ONLY_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TASK_LIMIT = 50;
+const DEFAULT_NOTE_SCAN_LIMIT = 200;
+const MAX_TASK_LIMIT = 500;
+const MAX_NOTE_SCAN_LIMIT = 5000;
+function parseSyncTimeoutMs(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--sync-timeout must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+function parseTaskStatus(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'all' || normalized === 'completed' || normalized === 'uncompleted') {
+        return normalized;
+    }
+    throw new DinoxError('--status must be one of: all, completed, uncompleted');
+}
+function parseTaskCheckedStatus(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'completed' || normalized === 'done' || normalized === 'true' || normalized === '1') {
+        return true;
+    }
+    if (normalized === 'uncompleted' ||
+        normalized === 'todo' ||
+        normalized === 'undone' ||
+        normalized === 'false' ||
+        normalized === '0') {
+        return false;
+    }
+    throw new DinoxError('--status must be one of: completed, uncompleted, done, undone, true, false, 1, 0');
+}
+function parsePositiveIntegerOption(value, optionName, fallback, max) {
+    if (value === undefined || value === null || value === '') {
+        return fallback;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError(`${optionName} must be a positive integer`);
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError(`${optionName} must be a positive integer`);
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError(`${optionName} must be a positive integer`);
+    }
+    if (parsed > max) {
+        throw new DinoxError(`${optionName} cannot be greater than ${max}`);
+    }
+    return Math.trunc(parsed);
+}
+function parseLocalDateOnly(value) {
+    const match = value.match(DATE_ONLY_RE);
+    if (!match) {
+        return null;
+    }
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const parsed = new Date(year, month - 1, day, 0, 0, 0, 0);
+    if (parsed.getFullYear() !== year ||
+        parsed.getMonth() !== month - 1 ||
+        parsed.getDate() !== day) {
+        return null;
+    }
+    return parsed;
+}
+function parseDateInput(value, optionName) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const raw = value.trim();
+    if (!raw) {
+        throw new DinoxError(`${optionName} requires a non-empty date value`);
+    }
+    const isDateOnly = DATE_ONLY_RE.test(raw);
+    const dateOnly = parseLocalDateOnly(raw);
+    if (dateOnly) {
+        return dateOnly;
+    }
+    if (isDateOnly) {
+        throw new DinoxError(`${optionName} must be a valid date (YYYY-MM-DD or ISO datetime)`);
+    }
+    const parsed = new Date(raw);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new DinoxError(`${optionName} must be a valid date (YYYY-MM-DD or ISO datetime)`);
+    }
+    return parsed;
+}
+function parseDaysInput(value) {
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new DinoxError('--days must be a positive integer');
+    }
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+        throw new DinoxError('--days must be a positive integer');
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new DinoxError('--days must be a positive integer');
+    }
+    return Math.trunc(parsed);
+}
+function parseTaskDateRange(input, now = new Date()) {
+    const from = parseDateInput(input.from, '--from');
+    const to = parseDateInput(input.to, '--to');
+    const days = parseDaysInput(input.days);
+    if (days !== undefined && (from || to)) {
+        throw new DinoxError('--days cannot be used together with --from/--to');
+    }
+    if (days !== undefined) {
+        const end = new Date(now);
+        const start = new Date(now.getTime() - (days - 1) * DAY_MS);
+        return {
+            startDate: start,
+            endDate: end,
+        };
+    }
+    if (!from && !to) {
+        return undefined;
+    }
+    if (from && to && from.getTime() > to.getTime()) {
+        throw new DinoxError('--from must be earlier than or equal to --to');
+    }
+    return {
+        startDate: from,
+        endDate: to,
+    };
+}
+function parseListInput(raw, optionName) {
+    const value = raw.trim();
+    if (!value) {
+        return [];
+    }
+    if (value.startsWith('[')) {
+        try {
+            const parsed = JSON.parse(value);
+            if (!Array.isArray(parsed)) {
+                throw new DinoxError(`${optionName} must be a JSON array`);
+            }
+            return Array.from(new Set(parsed
+                .map((entry) => String(entry).trim())
+                .filter((entry) => entry.length > 0)));
+        }
+        catch (error) {
+            if (error instanceof DinoxError) {
+                throw error;
+            }
+            throw new DinoxError(`Invalid list for ${optionName}`, { cause: error });
+        }
+    }
+    return Array.from(new Set(value
+        .split(/[\n,，]/g)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)));
+}
+async function parseTagFilterInput(value) {
+    const raw = await readStringOrFile(value);
+    return parseListInput(raw, '--tags');
+}
+async function parseTaskListInput(value) {
+    const raw = await readStringOrFile(value);
+    return parseListInput(raw, '--tasks');
+}
+function collectStringOptionValue(value, previous = []) {
+    return [...previous, value];
+}
+async function parseTaskInput(args) {
+    const merged = [];
+    if (typeof args.positionalTask === 'string') {
+        merged.push(args.positionalTask);
+    }
+    if (Array.isArray(args.taskOptionList)) {
+        merged.push(...args.taskOptionList);
+    }
+    if (typeof args.tasksOption === 'string') {
+        const parsed = await parseTaskListInput(args.tasksOption);
+        merged.push(...parsed);
+    }
+    return normalizeTaskTexts(merged);
+}
+async function syncBeforeTodoCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+}
+export function registerTodoCommands(program) {
+    const todo = program.command('todo').description('Manage todo tasks');
+    todo
+        .command('search')
+        .description('Search tasks from note image_detail')
+        .argument('[query]', 'task text query')
+        .option('--status <status>', 'task status: all | completed | uncompleted', 'all')
+        .option('--tags <string|@file>', 'task tags (JSON array or comma/newline-separated)')
+        .option('--from <date>', 'task date range start (YYYY-MM-DD or ISO datetime)')
+        .option('--to <date>', 'task date range end (YYYY-MM-DD or ISO datetime)')
+        .option('--days <n>', 'recent N days for task date range (cannot be used with --from/--to)')
+        .option('--limit <n>', `maximum returned tasks (default: ${DEFAULT_TASK_LIMIT}, max: ${MAX_TASK_LIMIT})`)
+        .option('--scan-limit <n>', `maximum note rows scanned from c_note (default: ${DEFAULT_NOTE_SCAN_LIMIT}, max: ${MAX_NOTE_SCAN_LIMIT})`)
+        .option('--include-deleted', 'include soft-deleted notes')
+        .action(async (query, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeTodoCommand(db, offline, timeoutMs);
+            const keyword = query?.trim() ?? '';
+            const taskStatus = parseTaskStatus(options.status);
+            const taskTagFilter = typeof options.tags === 'string'
+                ? await parseTagFilterInput(options.tags)
+                : [];
+            const taskDateRange = parseTaskDateRange({
+                from: options.from,
+                to: options.to,
+                days: options.days,
+            });
+            const limit = parsePositiveIntegerOption(options.limit, '--limit', DEFAULT_TASK_LIMIT, MAX_TASK_LIMIT);
+            const scanLimit = parsePositiveIntegerOption(options.scanLimit, '--scan-limit', DEFAULT_NOTE_SCAN_LIMIT, MAX_NOTE_SCAN_LIMIT);
+            const result = await searchTodoTasks(db, keyword, {
+                includeDeleted: Boolean(options.includeDeleted),
+                taskStatus,
+                taskTagFilter,
+                taskDateRange,
+                limit,
+                scanLimit,
+            });
+            printYaml(result);
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    todo
+        .command('append')
+        .description('Append one or more todo items to a note')
+        .argument('[task]', 'single task text')
+        .option('--task <text>', 'task text (repeatable)', collectStringOptionValue, [])
+        .option('--tasks <string|@file>', 'task list (JSON array or comma/newline-separated)')
+        .option('--note-id <id>', 'target note id; defaults to latest note with non-empty image_detail')
+        .action(async (taskArg, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeTodoCommand(db, offline, timeoutMs);
+            const taskTexts = await parseTaskInput({
+                positionalTask: taskArg,
+                tasksOption: typeof options.tasks === 'string' ? options.tasks : undefined,
+                taskOptionList: Array.isArray(options.task) ? options.task : [],
+            });
+            const result = await appendTodoTasks(db, {
+                noteId: typeof options.noteId === 'string' ? options.noteId : undefined,
+                taskTexts,
+            });
+            printYaml({ ok: true, ...result });
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    todo
+        .command('create')
+        .description('Create a new note containing one or more todo items')
+        .argument('[task]', 'single task text')
+        .option('--task <text>', 'task text (repeatable)', collectStringOptionValue, [])
+        .option('--tasks <string|@file>', 'task list (JSON array or comma/newline-separated)')
+        .option('--title <string>', 'optional note title; defaults to an auto-generated summary')
+        .action(async (taskArg, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const rawConfig = await loadConfig();
+        const config = resolveConfig(rawConfig);
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const identity = await resolveAuthIdentity(rawConfig, config);
+        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeTodoCommand(db, offline, timeoutMs);
+            const taskTexts = await parseTaskInput({
+                positionalTask: taskArg,
+                tasksOption: typeof options.tasks === 'string' ? options.tasks : undefined,
+                taskOptionList: Array.isArray(options.task) ? options.task : [],
+            });
+            const result = await createTodoNote(db, {
+                taskTexts,
+                title: typeof options.title === 'string' ? options.title : undefined,
+                userId: identity.userId,
+            });
+            if (!offline && !config.powersync.uploadBaseUrl) {
+                console.log('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
+            }
+            if (!offline) {
+                await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
+            }
+            printYaml({ ok: true, ...result });
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    todo
+        .command('update')
+        .description('Update checked status for a todo task by taskId')
+        .argument('<taskId>', 'task id')
+        .requiredOption('--status <status>', 'target status: completed|uncompleted|done|undone|true|false|1|0')
+        .action(async (taskId, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeTodoCommand(db, offline, timeoutMs);
+            const checked = parseTaskCheckedStatus(options.status);
+            const result = await updateTodoTaskStatus(db, {
+                taskId,
+                checked,
+            });
+            printYaml({ ok: true, ...result });
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
+    todo.action((_options, command) => {
+        command.outputHelp();
+    });
+}