@dinoxx/dinox-cli 1.0.17 → 1.0.19

package/dist/commands/notes/repo.js

@@ -5,10 +5,20 @@ import { listBoxes } from '../boxes/repo.js';
 import { listTags } from '../tags/repo.js';
 import { buildNoteSearchSqlFilter } from './searchSql.js';
 const MAX_SEARCH_SUMMARY_CHARS = 200;
+function normalizeStoredStarred(value) {
+    if (typeof value === 'number') {
+        return value === 1;
+    }
+    if (typeof value === 'string') {
+        return value.trim() === '1';
+    }
+    return false;
+}
 export async function searchNotes(db, query, options) {
     const normalizedQuery = query.trim();
     const tagFilter = buildTagFilter(options.tagsExpression, 'n');
     const createdAtFilter = buildCreatedAtFilter(options.createdAtFrom, options.createdAtTo, 'n');
+    const starredFilter = buildStarredFilter(options.starred, 'n');
     const zettelBoxFilter = buildZettelBoxFilter(options.zettelBoxIds, options.matchEmptyZettelBoxes, 'n');
     const sqlFilter = await buildNoteSearchSqlFilter({
         expression: options.sqlExpression,
@@ -20,7 +30,7 @@ export async function searchNotes(db, query, options) {
         const ftsMatch = buildFtsMatchQuery(normalizedQuery);
         if (ftsMatch) {
             try {
-                rows = await searchNotesWithFts(db, ftsMatch, tagFilter, createdAtFilter, zettelBoxFilter, sqlFilter);
+                rows = await searchNotesWithFts(db, ftsMatch, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter);
                 return enrichSearchRows(db, rows);
             }
             catch (error) {
@@ -61,6 +71,10 @@ export async function searchNotes(db, query, options) {
         whereClauses.push(createdAtFilter.sql);
         params.push(...createdAtFilter.params);
     }
+    if (starredFilter) {
+        whereClauses.push(starredFilter.sql);
+        params.push(...starredFilter.params);
+    }
     if (zettelBoxFilter) {
         whereClauses.push(zettelBoxFilter.sql);
         params.push(...zettelBoxFilter.params);
@@ -77,14 +91,15 @@ export async function searchNotes(db, query, options) {
       n.content_text,
       n.tags,
       n.zettel_boxes,
-      n.created_at
+      n.created_at,
+      n.is_starred
     FROM c_note n
     WHERE ${whereClauses.join('\n      AND ')}
     ORDER BY COALESCE(n.updated_at, n.created_at) DESC
     `, params);
     return enrichSearchRows(db, rows);
 }
-async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, zettelBoxFilter, sqlFilter) {
+async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter) {
     const whereClauses = ['(n.is_del IS NULL OR n.is_del = 0)', 'note_local_fts MATCH ?'];
     const params = [matchQuery];
     if (tagFilter) {
@@ -95,6 +110,10 @@ async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, ze
         whereClauses.push(createdAtFilter.sql);
         params.push(...createdAtFilter.params);
     }
+    if (starredFilter) {
+        whereClauses.push(starredFilter.sql);
+        params.push(...starredFilter.params);
+    }
     if (zettelBoxFilter) {
         whereClauses.push(zettelBoxFilter.sql);
         params.push(...zettelBoxFilter.params);
@@ -111,7 +130,8 @@ async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, ze
       n.content_text,
       n.tags,
       n.zettel_boxes,
-      n.created_at
+      n.created_at,
+      n.is_starred
     FROM note_local_fts f
     JOIN c_note n ON n.id = f.note_id
     WHERE ${whereClauses.join('\n      AND ')}
@@ -132,6 +152,7 @@ async function enrichSearchRows(db, rows) {
             summary,
             tags: parseStoredTags(row.tags),
             created_at: row.created_at,
+            is_starred: normalizeStoredStarred(row.is_starred),
             zettel_boxes: zettelBoxes,
         };
     });
@@ -150,7 +171,7 @@ function truncateSearchSummary(value) {
     }
     return chars.slice(0, MAX_SEARCH_SUMMARY_CHARS).join('');
 }
-function parseZettelBoxIds(raw) {
+export function parseZettelBoxIds(raw) {
     const value = raw?.trim();
     if (!value) {
         return [];
@@ -248,6 +269,15 @@ function buildCreatedAtFilter(createdAtFrom, createdAtTo, noteAlias) {
         params,
     };
 }
+function buildStarredFilter(starred, noteAlias) {
+    if (typeof starred !== 'boolean') {
+        return null;
+    }
+    return {
+        sql: `(${noteAlias}.is_starred = ?)`,
+        params: [starred ? '1' : '0'],
+    };
+}
 function buildZettelBoxFilter(zettelBoxIds, matchEmptyZettelBoxes, noteAlias) {
     const normalizedIds = Array.from(new Set((zettelBoxIds ?? [])
         .map((id) => id.trim())
@@ -490,6 +520,7 @@ export async function getNote(db, id) {
       created_at,
       updated_at,
       is_del,
+      is_starred,
       version
     FROM c_note
     WHERE id = ?
@@ -539,6 +570,7 @@ export async function getNoteContext(db, id) {
       n.created_at,
       n.updated_at,
       n.is_del,
+      n.is_starred,
       n.zettel_boxes AS zettel_boxes_raw
     FROM c_note n
     WHERE n.id = ?
@@ -560,6 +592,7 @@ export async function getNoteContext(db, id) {
         created_at: row.created_at,
         updated_at: row.updated_at,
         is_del: row.is_del,
+        is_starred: normalizeStoredStarred(row.is_starred),
         zettel_boxes: boxIds
             .map((boxId) => boxNameMap.get(boxId))
             .filter((name) => typeof name === 'string' && name.length > 0),
@@ -607,6 +640,7 @@ function mapNoteDetailRow(note, boxNameMap) {
         source: note.source,
         tags: note.tags,
         is_del: note.is_del,
+        is_starred: normalizeStoredStarred(note.is_starred),
         content_md: note.content_md,
         zettel_boxes: zettelBoxes,
     };
@@ -632,6 +666,7 @@ export async function getNoteDetails(db, ids) {
         source,
         tags,
         is_del,
+        is_starred,
         content_md,
         zettel_boxes AS zettel_boxes_raw
       FROM c_note
@@ -735,6 +770,7 @@ export async function createNote(db, input) {
         ['extra_data', '{}'],
         ['format_type', ''],
         ['comments', '[]'],
+        ['is_starred', 0],
         ['is_top', 0],
         ['pinned_at', '1997-01-01T00:00:00.000Z'],
         ['chat_context', '{}'],
@@ -813,7 +849,7 @@ async function validateTagsForWrite(db, requestedTags, retryCommand) {
     }
     return resolved;
 }
-function parseStoredTags(raw) {
+export function parseStoredTags(raw) {
     if (!raw) {
         return [];
     }
@@ -867,11 +903,12 @@ export async function updateNote(db, input) {
     }
     const shouldUpdateTags = Array.isArray(input.tags);
     const shouldUpdateBoxes = Array.isArray(input.zettelBoxIds);
-    if (!shouldUpdateTags && !shouldUpdateBoxes) {
-        throw new DinoxError('At least one field is required: tags or boxes');
+    const shouldUpdateStarred = typeof input.starred === 'boolean';
+    if (!shouldUpdateTags && !shouldUpdateBoxes && !shouldUpdateStarred) {
+        throw new DinoxError('At least one field is required: tags, boxes, or starred');
     }
     const existing = await db.getOptional(`
-    SELECT id, tags, zettel_boxes, is_del
+    SELECT id, tags, zettel_boxes, is_del, is_starred
     FROM c_note
     WHERE id = ?
     `, [id]);
@@ -883,16 +920,20 @@ export async function updateNote(db, input) {
     }
     const currentTags = parseStoredTags(existing.tags);
     const currentZettelBoxIds = parseZettelBoxIds(existing.zettel_boxes);
+    const currentStarred = normalizeStoredStarred(existing.is_starred);
     const nextTags = shouldUpdateTags ? normalizeDistinctStrings(input.tags) : currentTags;
     const nextZettelBoxIds = shouldUpdateBoxes ? normalizeDistinctStrings(input.zettelBoxIds) : currentZettelBoxIds;
+    const nextStarred = shouldUpdateStarred ? input.starred : currentStarred;
     const tagsChanged = shouldUpdateTags && !sameTagSet(currentTags, nextTags);
     const boxesChanged = shouldUpdateBoxes && !sameStringSet(currentZettelBoxIds, nextZettelBoxIds);
-    if (!tagsChanged && !boxesChanged) {
+    const starredChanged = shouldUpdateStarred && currentStarred !== nextStarred;
+    if (!tagsChanged && !boxesChanged && !starredChanged) {
         return {
             id,
             updated: false,
             tags: currentTags,
             zettelBoxIds: currentZettelBoxIds,
+            is_starred: currentStarred,
         };
     }
     const setParts = [];
@@ -905,6 +946,10 @@ export async function updateNote(db, input) {
         setParts.push('zettel_boxes = ?');
         params.push(JSON.stringify(nextZettelBoxIds));
     }
+    if (starredChanged) {
+        setParts.push('is_starred = ?');
+        params.push(nextStarred ? 1 : 0);
+    }
     setParts.push('updated_at = ?');
     params.push(nowIsoUtc());
     setParts.push('version = COALESCE(version, 0) + 1');
@@ -919,6 +964,7 @@ export async function updateNote(db, input) {
         updated: true,
         tags: nextTags,
         zettelBoxIds: nextZettelBoxIds,
+        is_starred: nextStarred,
     };
 }
 export async function assertNotesUpdatable(db, noteIds) {

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

@@ -0,0 +1,28 @@
+import type { Command } from 'commander';
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+export type NoteCommandRuntime = {
+    db: AbstractPowerSyncDatabase;
+    config: ReturnType<typeof resolveConfig>;
+    rawConfig: Awaited<ReturnType<typeof loadConfig>>;
+    offline: boolean;
+    timeoutMs: number;
+    stale: boolean;
+};
+export declare function parseNoteType(value: unknown): 'note' | 'crawl';
+export declare function parseSearchLimit(value: unknown): number;
+export declare function parseSearchOffset(value: unknown): number;
+export declare function parsePreviewLineCount(value: unknown): number;
+export declare function parseStarredOption(value: unknown, optionName: string): boolean;
+export declare function parseStringInput(value: string): Promise<string>;
+export declare function parseListInput(raw: string, optionName: string): string[];
+export declare function parseStringListInput(value: string, optionName: string): Promise<string[]>;
+export type ParsedSearchListInput = {
+    values: string[];
+    isExplicitEmptyArray: boolean;
+};
+export declare function parseSearchListInput(value: string, optionName: string): Promise<ParsedSearchListInput>;
+export declare function parseTargetNoteIds(idArg: string | undefined, idsOption: string | undefined, commandName: 'detail' | 'update'): Promise<string[]>;
+export declare function syncBeforeNoteCommand(db: AbstractPowerSyncDatabase, offline: boolean, timeoutMs: number): Promise<void>;
+export declare function withNoteDatabase(command: Command, run: (runtime: NoteCommandRuntime) => Promise<void>): Promise<void>;

package/dist/commands/notes/runtime.js

@@ -0,0 +1,185 @@
+import { loadConfig } from '../../config/store.js';
+import { resolveConfig } from '../../config/resolve.js';
+import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
+import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
+import { readStringOrFile } from '../../utils/argValue.js';
+import { DinoxError } from '../../utils/errors.js';
+import { parseSyncTimeoutMs } from '../../utils/syncTimeout.js';
+const DEFAULT_NOTE_SEARCH_LIMIT = 50;
+const MAX_NOTE_SEARCH_LIMIT = 500;
+export 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');
+}
+export 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);
+}
+export 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);
+}
+export 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);
+}
+export function parseStarredOption(value, optionName) {
+    if (typeof value !== 'string') {
+        throw new DinoxError(`${optionName} must be one of: true, false, 1, 0, yes, no`);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'yes') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'no') {
+        return false;
+    }
+    throw new DinoxError(`${optionName} must be one of: true, false, 1, 0, yes, no`);
+}
+export async function parseStringInput(value) {
+    return readStringOrFile(value);
+}
+export 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)));
+}
+export async function parseStringListInput(value, optionName) {
+    const raw = await readStringOrFile(value);
+    return parseListInput(raw, optionName);
+}
+export 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;
+    }
+}
+export 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;
+}
+export async function syncBeforeNoteCommand(db, offline, timeoutMs) {
+    if (offline) {
+        return;
+    }
+    await waitForIdleDataFlow(db, Math.min(timeoutMs, 10_000));
+    await syncNoteTokenIndex(db);
+}
+export async function withNoteDatabase(command, run) {
+    const globals = command.optsWithGlobals?.() ?? {};
+    const rawConfig = await loadConfig();
+    const config = resolveConfig(rawConfig);
+    const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+    const offline = Boolean(globals.offline);
+    const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+    try {
+        await run({
+            db,
+            config,
+            rawConfig,
+            offline,
+            timeoutMs,
+            stale,
+        });
+    }
+    finally {
+        await db.close().catch(() => undefined);
+    }
+}

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

@@ -1,6 +1,14 @@
 import type { SearchedNote } from './repo.js';
-export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "zettel_boxes"];
+export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "boxes", "is_starred"];
 export type NoteSearchField = (typeof NOTE_SEARCH_FIELDS)[number];
-export type NoteSearchResultItem = Partial<SearchedNote>;
+export type NoteSearchResultItem = {
+    id?: string;
+    title?: string;
+    summary?: string;
+    tags?: string[];
+    created_at?: string | null;
+    is_starred?: boolean;
+    boxes?: string[];
+};
 export declare function parseNoteSearchFields(value: unknown, optionName: string): NoteSearchField[] | undefined;
 export declare function projectNoteSearchFields(notes: SearchedNote[], fields: NoteSearchField[] | undefined): NoteSearchResultItem[];

package/dist/commands/notes/searchOutput.js

@@ -1,5 +1,5 @@
 import { DinoxError } from '../../utils/errors.js';
-export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'zettel_boxes'];
+export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'];
 const NOTE_SEARCH_FIELD_SET = new Set(NOTE_SEARCH_FIELDS);
 export function parseNoteSearchFields(value, optionName) {
     if (value === undefined || value === null || value === '') {
@@ -29,11 +29,23 @@ export function parseNoteSearchFields(value, optionName) {
 }
 export function projectNoteSearchFields(notes, fields) {
     if (!fields || fields.length === 0) {
-        return notes.map((note) => ({ ...note }));
+        return notes.map((note) => ({
+            id: note.id,
+            title: note.title,
+            summary: note.summary,
+            tags: note.tags,
+            created_at: note.created_at,
+            is_starred: note.is_starred,
+            boxes: note.zettel_boxes,
+        }));
     }
     return notes.map((note) => {
         const item = {};
         for (const field of fields) {
+            if (field === 'boxes') {
+                item.boxes = note.zettel_boxes;
+                continue;
+            }
             item[field] = note[field];
         }
         return item;

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

@@ -0,0 +1,51 @@
+import type { NoteSearchField, NoteSearchResultItem } from './searchOutput.js';
+export type NoteSearchResponse = {
+    meta: {
+        query: string;
+        returned_count: number;
+        total_count: number;
+        stale: boolean;
+        pagination: {
+            limit: number | null;
+            offset: number;
+            has_more: boolean;
+        };
+        fields: NoteSearchField[] | null;
+        applied_filters: {
+            include_deleted: boolean;
+            tags_expression: string | null;
+            created_at_range: {
+                from: string | null;
+                to: string | null;
+            } | null;
+            days: number | null;
+            starred: boolean | null;
+            box_names: string[];
+            box_ids: string[];
+            match_empty_boxes: boolean;
+            sql_expression: string | null;
+        };
+    };
+    notes: NoteSearchResultItem[];
+};
+export type BuildNoteSearchResponseInput = {
+    query: string;
+    notes: NoteSearchResultItem[];
+    totalCount: number;
+    stale: boolean;
+    includeDeleted: boolean;
+    limit?: number;
+    offset?: number;
+    fields?: NoteSearchField[];
+    tagsExpression?: string;
+    createdAtFrom?: string;
+    createdAtTo?: string;
+    days?: number;
+    starred?: boolean;
+    boxNames: string[];
+    boxIds: string[];
+    matchEmptyBoxes: boolean;
+    sqlExpression?: string;
+};
+export declare function normalizeDaysForMeta(value: unknown): number | undefined;
+export declare function buildNoteSearchResponse(input: BuildNoteSearchResponseInput): NoteSearchResponse;

package/dist/commands/notes/searchResponse.js

@@ -0,0 +1,56 @@
+export 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,
+                starred: typeof input.starred === 'boolean' ? input.starred : null,
+                sql_expression: sqlExpression || null,
+            },
+        },
+        notes: input.notes,
+    };
+}

package/dist/commands/notes/searchSql.js

@@ -7,6 +7,7 @@ const SEARCH_FIELDS = new Set([
     'zettel_boxes',
     'created_at',
     'type',
+    'is_starred',
 ]);
 const FORBIDDEN_SQL_KEYWORDS = [
     'insert',
@@ -31,6 +32,7 @@ const SCALAR_FIELD_COLUMNS = {
     summary: 'summary',
     created_at: 'created_at',
     type: 'type',
+    is_starred: 'is_starred',
 };
 export async function buildNoteSearchSqlFilter(options) {
     const expression = options.expression?.trim() ?? '';

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

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const promptCommandGroup: CommandGroupDescriptor;
 export declare function registerPromptCommands(program: Command): void;