@dinoxx/dinox-cli 1.0.17 → 1.0.19

package/dist/commands/notes/index.js

@@ -1,581 +1,2 @@
-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 { generateId } from '../../utils/id.js';
-import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
-import { printYaml } from '../../utils/output.js';
-import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
-import { resolveAuthIdentity } from '../../auth/userInfo.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
-import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
-import { createNote, getNote, getNoteContext, getNoteDetails, getNotePreview, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
-import { parseNoteSearchFields, projectNoteSearchFields, } from './searchOutput.js';
-import { parseCreatedAtRange } from './searchTime.js';
-const DEFAULT_NOTE_SEARCH_LIMIT = 50;
-const MAX_NOTE_SEARCH_LIMIT = 500;
-function parseNoteType(value) {
-    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
-    if (normalized === 'note' || normalized === 'crawl') {
-        return normalized;
-    }
-    throw new DinoxError('--type must be one of: note, crawl');
-}
-function parseSearchLimit(value) {
-    if (value === undefined || value === null || value === '') {
-        return DEFAULT_NOTE_SEARCH_LIMIT;
-    }
-    if (typeof value !== 'string') {
-        throw new DinoxError('--limit must be a positive integer');
-    }
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-        throw new DinoxError('--limit must be a positive integer');
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new DinoxError('--limit must be a positive integer');
-    }
-    if (parsed > MAX_NOTE_SEARCH_LIMIT) {
-        throw new DinoxError(`--limit cannot be greater than ${MAX_NOTE_SEARCH_LIMIT}`);
-    }
-    return Math.trunc(parsed);
-}
-function parseSearchOffset(value) {
-    if (value === undefined || value === null || value === '') {
-        return 0;
-    }
-    if (typeof value !== 'string') {
-        throw new DinoxError('--offset must be a non-negative integer');
-    }
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-        throw new DinoxError('--offset must be a non-negative integer');
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed) || parsed < 0) {
-        throw new DinoxError('--offset must be a non-negative integer');
-    }
-    return Math.trunc(parsed);
-}
-function parsePreviewLineCount(value) {
-    if (value === undefined || value === null || value === '') {
-        return 10;
-    }
-    if (typeof value !== 'string') {
-        throw new DinoxError('--lines must be a positive integer');
-    }
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-        throw new DinoxError('--lines must be a positive integer');
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new DinoxError('--lines must be a positive integer');
-    }
-    if (parsed > 500) {
-        throw new DinoxError('--lines cannot be greater than 500');
-    }
-    return Math.trunc(parsed);
-}
-async function parseStringInput(value) {
-    return readStringOrFile(value);
-}
-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 parseStringListInput(value, optionName) {
-    const raw = await readStringOrFile(value);
-    return parseListInput(raw, optionName);
-}
-async function parseSearchListInput(value, optionName) {
-    const raw = await readStringOrFile(value);
-    return {
-        values: parseListInput(raw, optionName),
-        isExplicitEmptyArray: isExplicitEmptyArrayLiteral(raw),
-    };
-}
-function isExplicitEmptyArrayLiteral(value) {
-    const normalized = value.trim();
-    if (!normalized.startsWith('[')) {
-        return false;
-    }
-    try {
-        const parsed = JSON.parse(normalized);
-        return Array.isArray(parsed) && parsed.length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-async function parseTargetNoteIds(idArg, idsOption, commandName) {
-    const merged = [];
-    const idFromArg = typeof idArg === 'string' ? idArg.trim() : '';
-    if (idFromArg) {
-        merged.push(idFromArg);
-    }
-    if (typeof idsOption === 'string') {
-        merged.push(...(await parseStringListInput(idsOption, '--ids')));
-    }
-    const ids = Array.from(new Set(merged
-        .map((id) => id.trim())
-        .filter((id) => id.length > 0)));
-    if (ids.length === 0) {
-        throw new DinoxError(`Provide <id> or --ids for ${commandName}`);
-    }
-    return ids;
-}
-async function syncBeforeNoteCommand(db, offline, timeoutMs) {
-    if (offline) {
-        return;
-    }
-    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
-    await syncNoteTokenIndex(db);
-}
-function normalizeDaysForMeta(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-        return undefined;
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return undefined;
-    }
-    return Math.trunc(parsed);
-}
-export function buildNoteSearchResponse(input) {
-    const query = input.query.trim();
-    const tagsExpression = input.tagsExpression?.trim() ?? '';
-    const sqlExpression = input.sqlExpression?.trim() ?? '';
-    const hasCreatedAtRange = Boolean(input.createdAtFrom || input.createdAtTo);
-    const offset = input.offset ?? 0;
-    const limit = input.limit ?? null;
-    const returnedCount = input.notes.length;
-    const totalCount = input.totalCount;
-    const hasMore = offset + returnedCount < totalCount;
-    return {
-        meta: {
-            query,
-            returned_count: returnedCount,
-            total_count: totalCount,
-            stale: input.stale,
-            pagination: {
-                limit,
-                offset,
-                has_more: hasMore,
-            },
-            fields: input.fields && input.fields.length > 0 ? [...input.fields] : null,
-            applied_filters: {
-                include_deleted: input.includeDeleted,
-                tags_expression: tagsExpression || null,
-                created_at_range: hasCreatedAtRange
-                    ? {
-                        from: input.createdAtFrom ?? null,
-                        to: input.createdAtTo ?? null,
-                    }
-                    : null,
-                days: input.days ?? null,
-                box_names: [...input.boxNames],
-                box_ids: [...input.boxIds],
-                match_empty_boxes: input.matchEmptyBoxes,
-                sql_expression: sqlExpression || null,
-            },
-        },
-        notes: input.notes,
-    };
-}
-export function registerNoteCommands(program) {
-    const note = program.command('note').description('Manage notes');
-    note
-        .command('search')
-        .description('Search notes and return note list for AI agents')
-        .argument('[query]', 'search query')
-        .option('--tags <expr>', 'tag expression with AND/OR/NOT, or [] for empty tags')
-        .option('--from <date>', 'created_at start (YYYY-MM-DD or ISO datetime)')
-        .option('--to <date>', 'created_at end (YYYY-MM-DD or ISO datetime)')
-        .option('--days <n>', 'recent N days by created_at (cannot be used with --from/--to)')
-        .option('--box <string|@file>', 'zettel box names (JSON array/comma list), or [] for empty boxes')
-        .option('--sql <expr>', 'SQL-like expression over id/content_md/summary/tags/zettel_boxes/created_at/type')
-        .option('--limit <n>', `maximum returned notes (default: ${DEFAULT_NOTE_SEARCH_LIMIT}, max: ${MAX_NOTE_SEARCH_LIMIT})`)
-        .option('--offset <n>', 'result offset for pagination (default: 0)')
-        .option('--fields <list>', 'comma-separated fields: id,title,summary,tags,created_at,zettel_boxes')
-        .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, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeNoteCommand(db, offline, timeoutMs);
-            const keyword = query?.trim() ?? '';
-            const tagsExpression = typeof options.tags === 'string' ? options.tags.trim() : '';
-            const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
-                from: options.from,
-                to: options.to,
-                days: options.days,
-            });
-            const boxInput = typeof options.box === 'string' ? options.box : '';
-            const parsedBoxInput = boxInput
-                ? await parseSearchListInput(boxInput, '--box')
-                : { values: [], isExplicitEmptyArray: false };
-            const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, parsedBoxInput.values);
-            const sqlExpression = typeof options.sql === 'string' ? options.sql.trim() : '';
-            const limit = parseSearchLimit(options.limit);
-            const offset = parseSearchOffset(options.offset);
-            const fields = parseNoteSearchFields(options.fields, '--fields');
-            const rows = await searchNotes(db, keyword, {
-                includeDeleted: Boolean(options.includeDeleted),
-                tagsExpression: tagsExpression || undefined,
-                createdAtFrom,
-                createdAtTo,
-                zettelBoxIds,
-                matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
-                sqlExpression: sqlExpression || undefined,
-            });
-            const totalCount = rows.length;
-            const pagedRows = rows.slice(offset, offset + limit);
-            const projectedRows = projectNoteSearchFields(pagedRows, fields);
-            const response = buildNoteSearchResponse({
-                query: keyword,
-                notes: projectedRows,
-                totalCount,
-                stale: offline ? true : stale,
-                includeDeleted: Boolean(options.includeDeleted),
-                limit,
-                offset,
-                fields,
-                tagsExpression: tagsExpression || undefined,
-                createdAtFrom,
-                createdAtTo,
-                days: normalizeDaysForMeta(options.days),
-                boxNames: parsedBoxInput.values,
-                boxIds: zettelBoxIds,
-                matchEmptyBoxes: parsedBoxInput.isExplicitEmptyArray,
-                sqlExpression: sqlExpression || undefined,
-            });
-            printYaml(response);
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-    note
-        .command('get')
-        .description('Get note by id')
-        .argument('<id>', 'note id')
-        .option('--context-only', 'return lightweight note context (title/tags/summary/links)')
-        .action(async (id, options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        const jsonOutput = Boolean(globals.json);
-        const config = resolveConfig(await loadConfig());
-        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeNoteCommand(db, offline, timeoutMs);
-            if (options.contextOnly) {
-                const context = await getNoteContext(db, id);
-                if (!context) {
-                    throw new DinoxError(`Note not found: ${id}`, {
-                        code: 'NOTE_NOT_FOUND',
-                        suggestion: "Run 'dino note search <keyword>' to locate the note id.",
-                        recoverable: true,
-                    });
-                }
-                printYaml({ stale: offline ? true : stale, note: context });
-                return;
-            }
-            const note = await getNote(db, id);
-            if (!note) {
-                throw new DinoxError(`Note not found: ${id}`, {
-                    code: 'NOTE_NOT_FOUND',
-                    suggestion: "Run 'dino note search <keyword>' to locate the note id.",
-                    recoverable: true,
-                });
-            }
-            if (jsonOutput) {
-                printYaml({ stale, note });
-                return;
-            }
-            if (stale && !offline) {
-                console.log('warning: sync timed out; result may be stale');
-            }
-            console.log(`${note.id}`);
-            console.log(`title: ${note.title ?? ''}`);
-            if (note.updated_at) {
-                console.log(`updated_at: ${note.updated_at}`);
-            }
-            if (note.is_del) {
-                console.log('is_del: 1');
-            }
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-    note
-        .command('preview')
-        .description('Preview the first N lines of note markdown')
-        .argument('<id>', 'note id')
-        .option('--lines <n>', 'number of lines to return (default: 10)')
-        .action(async (id, 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 lines = parsePreviewLineCount(options.lines);
-        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeNoteCommand(db, offline, timeoutMs);
-            const preview = await getNotePreview(db, id, lines);
-            if (!preview) {
-                throw new DinoxError(`Note not found: ${id}`, {
-                    code: 'NOTE_NOT_FOUND',
-                    suggestion: "Run 'dino note search <keyword>' to locate the note id.",
-                    recoverable: true,
-                });
-            }
-            printYaml({ stale: offline ? true : stale, note: preview });
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-    note
-        .command('detail')
-        .description('Get full note details by id')
-        .argument('[id]', 'note id')
-        .option('--ids <string|@file>', 'note ids (JSON array or comma/newline-separated) for batch read')
-        .action(async (id, 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 syncBeforeNoteCommand(db, offline, timeoutMs);
-            const ids = await parseTargetNoteIds(id, options.ids, 'detail');
-            const notes = await getNoteDetails(db, ids);
-            const foundIds = new Set(notes.map((note) => note.id));
-            const missing = ids.filter((noteId) => !foundIds.has(noteId));
-            if (missing.length > 0) {
-                if (ids.length === 1) {
-                    throw new DinoxError(`Note not found: ${missing[0]}`);
-                }
-                throw new DinoxError(`Notes not found: ${missing.join(', ')}`);
-            }
-            if (notes.length === 1) {
-                printYaml(notes[0]);
-            }
-            else {
-                printYaml(notes);
-            }
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-    note
-        .command('create')
-        .description('Create a new note')
-        .requiredOption('--title <string>', 'note title')
-        .requiredOption('--content <string|@file>', 'markdown content')
-        .option('--type <note|crawl>', 'note type: note or crawl', 'crawl')
-        .option('--tags <string|@file>', 'tag list (JSON array or comma/newline-separated)')
-        .option('--zettel_boxes <string|@file>', 'zettel box names (JSON array or comma/newline-separated)')
-        .action(async (options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        const jsonOutput = Boolean(globals.json);
-        const rawConfig = await loadConfig();
-        const config = resolveConfig(rawConfig);
-        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-        const identity = await resolveAuthIdentity(rawConfig, config);
-        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeNoteCommand(db, offline, timeoutMs);
-            const contentMd = await parseStringInput(options.content);
-            const { contentJson, contentText } = convertMarkdownToNoteContent(contentMd);
-            const tagsInput = typeof options.tags === 'string'
-                ? await parseStringListInput(options.tags, '--tags')
-                : [];
-            const tags = await validateTagsForCreate(db, tagsInput);
-            const zettelBoxesOption = typeof options.zettel_boxes === 'string'
-                ? options.zettel_boxes
-                : typeof options.zettelBoxes === 'string'
-                    ? options.zettelBoxes
-                    : undefined;
-            const zettelBoxNames = zettelBoxesOption
-                ? await parseStringListInput(zettelBoxesOption, '--zettel_boxes')
-                : [];
-            const zettelBoxIds = await resolveZettelBoxIdsForCreate(db, zettelBoxNames);
-            const noteType = parseNoteType(options.type);
-            const id = generateId();
-            await createNote(db, {
-                id,
-                title: String(options.title),
-                noteType,
-                contentMd,
-                contentJson,
-                contentText,
-                tags,
-                zettelBoxIds,
-                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));
-            }
-            const payload = { ok: true, id, stale: offline ? true : stale };
-            if (jsonOutput) {
-                printYaml(payload);
-            }
-            else {
-                console.log(id);
-                if (stale && !offline) {
-                    console.log('warning: sync timed out; local cache may be stale');
-                }
-            }
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-    note
-        .command('delete')
-        .description('Soft-delete a note (is_del=1)')
-        .argument('<id>', 'note id')
-        .action(async (id, _options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        const jsonOutput = Boolean(globals.json);
-        const config = resolveConfig(await loadConfig());
-        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeNoteCommand(db, offline, timeoutMs);
-            await softDeleteNote(db, id);
-            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));
-            }
-            const payload = { ok: true, id, stale: offline ? true : stale };
-            if (jsonOutput) {
-                printYaml(payload);
-            }
-            else {
-                console.log('OK');
-                if (stale && !offline) {
-                    console.log('warning: sync timed out; local cache may be stale');
-                }
-            }
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-    note
-        .command('update')
-        .description('Update note tags/boxes by id')
-        .argument('[id]', 'note id')
-        .option('--ids <string|@file>', 'note ids (JSON array or comma/newline-separated) for batch update')
-        .option('--tags <string|@file>', 'tag list (JSON array or comma/newline-separated)')
-        .option('--boxes <string|@file>', 'zettel box names (JSON array or comma/newline-separated)')
-        .action(async (id, options, command) => {
-        const globals = command.optsWithGlobals?.() ?? {};
-        const offline = Boolean(globals.offline);
-        const jsonOutput = Boolean(globals.json);
-        const config = resolveConfig(await loadConfig());
-        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
-        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
-        try {
-            await syncBeforeNoteCommand(db, offline, timeoutMs);
-            const ids = await parseTargetNoteIds(id, options.ids, 'update');
-            const hasTags = typeof options.tags === 'string';
-            const hasBoxes = typeof options.boxes === 'string';
-            if (!hasTags && !hasBoxes) {
-                throw new DinoxError('At least one option is required: --tags or --boxes');
-            }
-            const tags = hasTags
-                ? await validateTagsForUpdate(db, await parseStringListInput(options.tags, '--tags'))
-                : undefined;
-            const zettelBoxIds = hasBoxes
-                ? await resolveZettelBoxIdsForUpdate(db, await parseStringListInput(options.boxes, '--boxes'))
-                : undefined;
-            await assertNotesUpdatable(db, ids);
-            const results = [];
-            for (const targetId of ids) {
-                const result = await updateNote(db, { id: targetId, tags, zettelBoxIds });
-                results.push(result);
-            }
-            const updatedCount = results.filter((item) => item.updated).length;
-            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));
-            }
-            const payload = {
-                ok: true,
-                total: results.length,
-                updatedCount,
-                results: results.map((item) => ({
-                    id: item.id,
-                    updated: item.updated,
-                    tags: item.tags,
-                    boxes: item.zettelBoxIds,
-                })),
-                stale: offline ? true : stale,
-            };
-            if (jsonOutput) {
-                printYaml(payload);
-            }
-            else {
-                if (results.length === 1) {
-                    console.log(results[0].updated ? 'OK' : 'No changes');
-                }
-                else {
-                    console.log(`Updated ${updatedCount}/${results.length} notes`);
-                }
-                if (stale && !offline) {
-                    console.log('warning: sync timed out; local cache may be stale');
-                }
-            }
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
-    });
-}
+export { buildNoteSearchResponse, } from './searchResponse.js';
+export { noteCommandGroup, registerNoteCommands } from './descriptors.js';

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

@@ -11,10 +11,12 @@ export type NoteRow = {
     created_at: string | null;
     updated_at: string | null;
     is_del: number | null;
+    is_starred: number | null;
     version: number | null;
 };
 type SearchNotesOptions = {
     includeDeleted: boolean;
+    starred?: boolean;
     tagsExpression?: string;
     createdAtFrom?: string;
     createdAtTo?: string;
@@ -28,6 +30,7 @@ export type SearchedNote = {
     summary: string;
     tags: string[];
     created_at: string | null;
+    is_starred: boolean;
     zettel_boxes: string[];
 };
 export type NoteDetail = {
@@ -38,6 +41,7 @@ export type NoteDetail = {
     source: string | null;
     tags: string | null;
     is_del: number | null;
+    is_starred: boolean;
     content_md: string | null;
     zettel_boxes: string[];
 };
@@ -49,6 +53,7 @@ export type NoteContext = {
     created_at: string | null;
     updated_at: string | null;
     is_del: number | null;
+    is_starred: boolean;
     zettel_boxes: string[];
     links: {
         backlinks: number;
@@ -70,8 +75,10 @@ export type UpdateNoteResult = {
     updated: boolean;
     tags: string[];
     zettelBoxIds: string[];
+    is_starred: boolean;
 };
 export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
+export declare function parseZettelBoxIds(raw: string | null): string[];
 export declare function getNote(db: AbstractPowerSyncDatabase, id: string): Promise<NoteRow | null>;
 export declare function getNoteContext(db: AbstractPowerSyncDatabase, id: string): Promise<NoteContext | null>;
 export declare function getNotePreview(db: AbstractPowerSyncDatabase, id: string, requestedLines: number): Promise<NotePreview | null>;
@@ -93,10 +100,12 @@ export declare function createNote(db: AbstractPowerSyncDatabase, input: {
 }>;
 export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
 export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
+export declare function parseStoredTags(raw: string | null): string[];
 export declare function updateNote(db: AbstractPowerSyncDatabase, input: {
     id: string;
     tags?: string[];
     zettelBoxIds?: string[];
+    starred?: boolean;
 }): Promise<UpdateNoteResult>;
 export declare function assertNotesUpdatable(db: AbstractPowerSyncDatabase, noteIds: string[]): Promise<void>;
 export declare function resolveZettelBoxIdsForCreate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;