@dinoxx/dinox-cli 1.0.12 → 1.0.14

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();
+    });
+}

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