@dinoxx/dinox-cli 2.0.0 → 2.1.1

package/dist/commands/notes/repo/search.js

@@ -0,0 +1,513 @@
+// Note search: keyword/FTS search, filters (tags, dates, boxes, starred), pagination.
+import { DinoxError } from '../../../utils/errors.js';
+import { tokenizeWithJieba } from '../../../utils/tokenize.js';
+import { buildNoteSearchSqlFilter } from '../searchSql.js';
+import { loadZettelBoxNameMap, normalizeStoredStarred, parseStoredTags, parseZettelBoxIds, resolveSummary, } from './shared.js';
+import { resolveZettelBoxIdsForSearch } from './resolve.js';
+/**
+ * Resolve box names to ids and run the note search. Shared by the local command path and
+ * the daemon RPC handler so both produce identical results from one implementation.
+ */
+export async function executeNoteSearch(db, params) {
+    const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, params.boxValues);
+    const result = await searchNotesPage(db, params.keyword, {
+        includeDeleted: params.includeDeleted,
+        tagsExpression: params.tagsExpression,
+        createdAtFrom: params.createdAtFrom,
+        createdAtTo: params.createdAtTo,
+        starred: params.starred,
+        zettelBoxIds,
+        matchEmptyZettelBoxes: params.matchEmptyZettelBoxes,
+        sqlExpression: params.sqlExpression,
+        limit: params.limit,
+        offset: params.offset,
+    });
+    return { rows: result.rows, totalCount: result.totalCount, zettelBoxIds };
+}
+export async function searchNotes(db, query, options) {
+    return (await searchNotesPage(db, query, options)).rows;
+}
+export async function searchNotesPage(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,
+        noteAlias: 'n',
+        resolveZettelBoxNames: (names) => resolveZettelBoxIdsForSearch(db, names),
+    });
+    let rows = [];
+    if (!options.includeDeleted) {
+        const ftsMatch = buildFtsMatchQuery(normalizedQuery);
+        if (ftsMatch) {
+            try {
+                const ftsResult = await searchNotesWithFts(db, ftsMatch, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter, options.limit, options.offset);
+                return {
+                    rows: await enrichSearchRows(db, ftsResult.rows),
+                    totalCount: ftsResult.totalCount,
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const normalized = message.toLowerCase();
+                // FTS table may not be initialized yet, or query syntax may fail.
+                if (normalized.includes('no such table') ||
+                    normalized.includes('fts5') ||
+                    normalized.includes('malformed match') ||
+                    normalized.includes('syntax error')) {
+                    // Fallback to legacy LIKE search below.
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    const whereClauses = [
+        options.includeDeleted ? '1 = 1' : '(n.is_del IS NULL OR n.is_del = 0)',
+    ];
+    const params = [];
+    if (normalizedQuery.length > 0) {
+        const like = `%${escapeLikePattern(normalizedQuery)}%`;
+        whereClauses.push(`
+      (
+        (n.title IS NOT NULL AND n.title LIKE ? ESCAPE '\\')
+        OR (n.content_text IS NOT NULL AND n.content_text LIKE ? ESCAPE '\\')
+        OR (n.content_md IS NOT NULL AND n.content_md LIKE ? ESCAPE '\\')
+      )
+      `);
+        params.push(like, like, like);
+    }
+    if (tagFilter) {
+        whereClauses.push(tagFilter.sql);
+        params.push(...tagFilter.params);
+    }
+    if (createdAtFilter) {
+        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);
+    }
+    if (sqlFilter) {
+        whereClauses.push(sqlFilter.sql);
+        params.push(...sqlFilter.params);
+    }
+    const baseFromWhere = `
+    FROM c_note n
+    WHERE ${whereClauses.join('\n      AND ')}
+  `;
+    const paginated = typeof options.limit === 'number';
+    const totalCount = paginated ? await countSearchRows(db, baseFromWhere, params) : null;
+    if (totalCount === 0) {
+        return { rows: [], totalCount };
+    }
+    rows = await db.getAll(`
+    SELECT
+      n.id,
+      n.title,
+      n.summary,
+      n.content_text,
+      n.tags,
+      n.zettel_boxes,
+      n.created_at,
+      n.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred
+    ${baseFromWhere}
+    ORDER BY COALESCE(n.updated_at, n.created_at) DESC, n.id DESC
+    ${buildPaginationSql(options.limit, options.offset)}
+    `, appendPaginationParams(params, options.limit, options.offset));
+    return { rows: await enrichSearchRows(db, rows), totalCount: totalCount ?? rows.length };
+}
+async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, starredFilter, zettelBoxFilter, sqlFilter, limit, offset) {
+    const whereClauses = ['(n.is_del IS NULL OR n.is_del = 0)', 'note_local_fts MATCH ?'];
+    const params = [matchQuery];
+    if (tagFilter) {
+        whereClauses.push(tagFilter.sql);
+        params.push(...tagFilter.params);
+    }
+    if (createdAtFilter) {
+        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);
+    }
+    if (sqlFilter) {
+        whereClauses.push(sqlFilter.sql);
+        params.push(...sqlFilter.params);
+    }
+    const baseFromWhere = `
+    FROM note_local_fts f
+    JOIN c_note n ON n.id = f.note_id
+    WHERE ${whereClauses.join('\n      AND ')}
+  `;
+    const paginated = typeof limit === 'number';
+    const totalCount = paginated ? await countSearchRows(db, baseFromWhere, params) : null;
+    if (totalCount === 0) {
+        return { rows: [], totalCount };
+    }
+    const rows = await db.getAll(`
+    SELECT
+      n.id,
+      n.title,
+      n.summary,
+      n.content_text,
+      n.tags,
+      n.zettel_boxes,
+      n.created_at,
+      n.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred
+    ${baseFromWhere}
+    ORDER BY bm25(note_local_fts, 0.0, 8.0, 4.0, 1.0) ASC, COALESCE(n.updated_at, n.created_at) DESC, n.id DESC
+    ${buildPaginationSql(limit, offset)}
+    `, appendPaginationParams(params, limit, offset));
+    return { rows, totalCount: totalCount ?? rows.length };
+}
+function escapeLikePattern(value) {
+    return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+async function countSearchRows(db, fromWhereSql, params) {
+    const rows = await db.getAll(`
+    SELECT COUNT(*) AS total_count
+    ${fromWhereSql}
+    `, params);
+    const value = Number(rows[0]?.total_count ?? 0);
+    return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
+}
+function buildPaginationSql(limit, offset) {
+    return typeof limit === 'number' ? 'LIMIT ? OFFSET ?' : '';
+}
+function appendPaginationParams(params, limit, offset) {
+    if (typeof limit !== 'number') {
+        return params;
+    }
+    return [...params, limit, offset ?? 0];
+}
+async function enrichSearchRows(db, rows) {
+    const allBoxIds = Array.from(new Set(rows.flatMap((row) => parseZettelBoxIds(row.zettel_boxes))));
+    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
+    return rows.map((row) => {
+        const summary = resolveSummary(row.summary, row.content_text);
+        const zettelBoxes = parseZettelBoxIds(row.zettel_boxes)
+            .map((id) => boxNameMap.get(id))
+            .filter((name) => typeof name === 'string' && name.length > 0);
+        return {
+            id: row.id,
+            title: row.title?.trim() ?? '',
+            summary,
+            tags: parseStoredTags(row.tags),
+            created_at: row.created_at,
+            starred_at: row.starred_at ?? null,
+            is_starred: normalizeStoredStarred(row.is_starred),
+            zettel_boxes: zettelBoxes,
+        };
+    });
+}
+function buildFtsMatchQuery(query) {
+    const tokens = tokenizeWithJieba(query, 32)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        return null;
+    }
+    const unique = Array.from(new Set(tokens));
+    return unique.map((token) => `"${escapeFtsToken(token)}"`).join(' AND ');
+}
+function escapeFtsToken(token) {
+    return token.replace(/"/g, '""');
+}
+function buildTagFilter(tagsExpression, noteAlias) {
+    const expression = tagsExpression?.trim() ?? '';
+    if (!expression) {
+        return null;
+    }
+    if (isExplicitEmptyArrayLiteral(expression)) {
+        return {
+            sql: `NOT (${buildJsonArrayHasValuesSql(noteAlias, 'tags', 'tag_item')})`,
+            params: [],
+        };
+    }
+    let ast;
+    try {
+        ast = parseTagExpression(expression);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new DinoxError(`Invalid --tags expression: ${message}`);
+    }
+    const params = [];
+    const sql = compileTagExpression(ast, noteAlias, params);
+    return { sql: `(${sql})`, params };
+}
+function buildCreatedAtFilter(createdAtFrom, createdAtTo, noteAlias) {
+    const clauses = [];
+    const params = [];
+    if (createdAtFrom) {
+        clauses.push(`(${noteAlias}.created_at IS NOT NULL AND ${noteAlias}.created_at >= ?)`);
+        params.push(createdAtFrom);
+    }
+    if (createdAtTo) {
+        clauses.push(`(${noteAlias}.created_at IS NOT NULL AND ${noteAlias}.created_at <= ?)`);
+        params.push(createdAtTo);
+    }
+    if (clauses.length === 0) {
+        return null;
+    }
+    return {
+        sql: `(${clauses.join(' AND ')})`,
+        params,
+    };
+}
+function buildStarredFilter(starred, noteAlias) {
+    if (typeof starred !== 'boolean') {
+        return null;
+    }
+    return {
+        sql: starred ? `(${noteAlias}.starred_at IS NOT NULL)` : `(${noteAlias}.starred_at IS NULL)`,
+        params: [],
+    };
+}
+function buildZettelBoxFilter(zettelBoxIds, matchEmptyZettelBoxes, noteAlias) {
+    const normalizedIds = Array.from(new Set((zettelBoxIds ?? [])
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    const shouldMatchEmpty = Boolean(matchEmptyZettelBoxes);
+    if (normalizedIds.length === 0 && !shouldMatchEmpty) {
+        return null;
+    }
+    const clauses = [];
+    const params = [];
+    if (normalizedIds.length > 0) {
+        const placeholders = normalizedIds.map(() => '?').join(', ');
+        clauses.push(`
+      EXISTS (
+        SELECT 1
+        FROM json_each(
+          CASE
+            WHEN json_valid(COALESCE(${noteAlias}.zettel_boxes, '')) THEN ${noteAlias}.zettel_boxes
+            ELSE '[]'
+          END
+        ) box_item
+        WHERE TRIM(CAST(box_item.value AS TEXT)) IN (${placeholders})
+      )
+      `);
+        params.push(...normalizedIds);
+    }
+    if (shouldMatchEmpty) {
+        clauses.push(`NOT (${buildJsonArrayHasValuesSql(noteAlias, 'zettel_boxes', 'box_item')})`);
+    }
+    if (clauses.length === 1) {
+        return { sql: clauses[0], params };
+    }
+    return {
+        sql: `(${clauses.join(' OR ')})`,
+        params,
+    };
+}
+function parseTagExpression(expression) {
+    const tokens = tokenizeTagExpression(expression);
+    if (tokens.length === 0) {
+        throw new Error('Expression is empty');
+    }
+    let index = 0;
+    const peek = () => tokens[index] ?? null;
+    const consume = (expected) => {
+        const token = peek();
+        if (!token) {
+            throw new Error('Unexpected end of expression');
+        }
+        if (expected && token.type !== expected) {
+            throw new Error(`Expected ${expected} at position ${token.position + 1}`);
+        }
+        index += 1;
+        return token;
+    };
+    const parsePrimary = () => {
+        const token = peek();
+        if (!token) {
+            throw new Error('Unexpected end of expression');
+        }
+        if (token.type === 'TERM') {
+            consume('TERM');
+            const value = normalizeTagValue(token.value);
+            if (!value) {
+                throw new Error(`Empty tag at position ${token.position + 1}`);
+            }
+            return { kind: 'tag', value };
+        }
+        if (token.type === 'LPAREN') {
+            consume('LPAREN');
+            const node = parseOr();
+            const close = peek();
+            if (!close || close.type !== 'RPAREN') {
+                throw new Error(`Missing ')' for '(' at position ${token.position + 1}`);
+            }
+            consume('RPAREN');
+            return node;
+        }
+        throw new Error(`Unexpected token '${token.value}' at position ${token.position + 1}`);
+    };
+    const parseUnary = () => {
+        const token = peek();
+        if (token?.type === 'NOT') {
+            consume('NOT');
+            return { kind: 'not', child: parseUnary() };
+        }
+        return parsePrimary();
+    };
+    const parseAnd = () => {
+        let node = parseUnary();
+        while (peek()?.type === 'AND') {
+            consume('AND');
+            node = { kind: 'and', left: node, right: parseUnary() };
+        }
+        return node;
+    };
+    const parseOr = () => {
+        let node = parseAnd();
+        while (peek()?.type === 'OR') {
+            consume('OR');
+            node = { kind: 'or', left: node, right: parseAnd() };
+        }
+        return node;
+    };
+    const ast = parseOr();
+    const extra = peek();
+    if (extra) {
+        throw new Error(`Unexpected token '${extra.value}' at position ${extra.position + 1}`);
+    }
+    return ast;
+}
+function tokenizeTagExpression(expression) {
+    const tokens = [];
+    let i = 0;
+    while (i < expression.length) {
+        const ch = expression[i];
+        if (/\s/.test(ch)) {
+            i += 1;
+            continue;
+        }
+        if (ch === '(') {
+            tokens.push({ type: 'LPAREN', value: ch, position: i });
+            i += 1;
+            continue;
+        }
+        if (ch === ')') {
+            tokens.push({ type: 'RPAREN', value: ch, position: i });
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            const quoted = readQuotedToken(expression, i);
+            tokens.push({ type: 'TERM', value: quoted.value, position: i });
+            i = quoted.next;
+            continue;
+        }
+        let j = i;
+        while (j < expression.length) {
+            const next = expression[j];
+            if (/\s/.test(next) || next === '(' || next === ')') {
+                break;
+            }
+            j += 1;
+        }
+        const raw = expression.slice(i, j);
+        const upper = raw.toUpperCase();
+        if (upper === 'AND' || upper === 'OR' || upper === 'NOT') {
+            tokens.push({ type: upper, value: raw, position: i });
+        }
+        else {
+            tokens.push({ type: 'TERM', value: raw, position: i });
+        }
+        i = j;
+    }
+    return tokens;
+}
+function readQuotedToken(expression, start) {
+    const quote = expression[start];
+    let i = start + 1;
+    let value = '';
+    while (i < expression.length) {
+        const ch = expression[i];
+        if (ch === '\\') {
+            if (i + 1 >= expression.length) {
+                throw new Error(`Invalid escape at position ${i + 1}`);
+            }
+            value += expression[i + 1];
+            i += 2;
+            continue;
+        }
+        if (ch === quote) {
+            return { value, next: i + 1 };
+        }
+        value += ch;
+        i += 1;
+    }
+    throw new Error(`Unclosed quote at position ${start + 1}`);
+}
+function compileTagExpression(node, noteAlias, params) {
+    if (node.kind === 'tag') {
+        params.push(node.value);
+        return `
+      EXISTS (
+        SELECT 1
+        FROM json_each(
+          CASE
+            WHEN json_valid(COALESCE(${noteAlias}.tags, '')) THEN ${noteAlias}.tags
+            ELSE '[]'
+          END
+        ) tag_item
+        WHERE LOWER(TRIM(CAST(tag_item.value AS TEXT))) = ?
+      )
+    `;
+    }
+    if (node.kind === 'not') {
+        return `NOT (${compileTagExpression(node.child, noteAlias, params)})`;
+    }
+    if (node.kind === 'and') {
+        return `(${compileTagExpression(node.left, noteAlias, params)}) AND (${compileTagExpression(node.right, noteAlias, params)})`;
+    }
+    return `(${compileTagExpression(node.left, noteAlias, params)}) OR (${compileTagExpression(node.right, noteAlias, params)})`;
+}
+function normalizeTagValue(value) {
+    return value.trim().toLowerCase();
+}
+function isExplicitEmptyArrayLiteral(value) {
+    if (!value.startsWith('[')) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) && parsed.length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function buildJsonArrayHasValuesSql(noteAlias, field, itemAlias) {
+    return `
+      EXISTS (
+        SELECT 1
+        FROM json_each(
+          CASE
+            WHEN json_valid(COALESCE(${noteAlias}.${field}, '')) THEN ${noteAlias}.${field}
+            ELSE '[]'
+          END
+        ) ${itemAlias}
+        WHERE LENGTH(TRIM(CAST(${itemAlias}.value AS TEXT))) > 0
+      )
+    `;
+}

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

@@ -0,0 +1,190 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+export declare const MAX_SEARCH_SUMMARY_CHARS = 200;
+export type NoteRow = {
+    id: string;
+    title: string | null;
+    content_md: string | null;
+    content_json: string | null;
+    content_text: string | null;
+    summary: string | null;
+    zettel_boxes: string | null;
+    tags: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    is_del: number | null;
+    starred_at: string | null;
+    is_starred: number | null;
+    version: number | null;
+};
+export type SearchNotesOptions = {
+    includeDeleted: boolean;
+    starred?: boolean;
+    tagsExpression?: string;
+    createdAtFrom?: string;
+    createdAtTo?: string;
+    zettelBoxIds?: string[];
+    matchEmptyZettelBoxes?: boolean;
+    sqlExpression?: string;
+};
+export type SearchResultRow = Pick<NoteRow, 'id' | 'title' | 'summary' | 'content_text' | 'tags' | 'zettel_boxes' | 'created_at' | 'starred_at' | 'is_starred'>;
+export type ZettelBoxRow = {
+    id: string | null;
+    name: string | null;
+    path: string | null;
+};
+export type BoxNameLookup = {
+    name: string;
+    ids: string[];
+    paths: string[];
+};
+export type SearchedNote = {
+    id: string;
+    title: string;
+    summary: string;
+    tags: string[];
+    created_at: string | null;
+    starred_at: string | null;
+    is_starred: boolean;
+    zettel_boxes: string[];
+};
+export type NoteDetailRow = {
+    id: string;
+    created_at: string | null;
+    updated_at: string | null;
+    title: string | null;
+    type: string | null;
+    source: string | null;
+    tags: string | null;
+    is_del: number | null;
+    is_pub: number | null;
+    properties: string | null;
+    starred_at: string | null;
+    is_starred: number | null;
+    content_md: string | null;
+    content_text: string | null;
+    content_json: string | null;
+    zettel_boxes_raw: string | null;
+};
+export type NoteExportRow = {
+    id: string;
+    created_at: string | null;
+    updated_at: string | null;
+    title: string | null;
+    type: string | null;
+    source: string | null;
+    tags: string | null;
+    summary: string | null;
+    is_del: number | null;
+    is_pub: number | null;
+    properties: string | null;
+    starred_at: string | null;
+    is_starred: number | null;
+    content_md: string | null;
+    content_text: string | null;
+    content_json: string | null;
+    zettel_boxes_raw: string | null;
+};
+export type NoteDetail = {
+    id: string;
+    created_at: string | null;
+    updated_at: string | null;
+    title: string | null;
+    type: string | null;
+    source: string | null;
+    tags: string[];
+    is_del: number | null;
+    is_pub: boolean;
+    properties: Record<string, unknown>;
+    starred_at: string | null;
+    is_starred: boolean;
+    content_md: string | null;
+    content_text: string | null;
+    content_json: unknown;
+    zettel_boxes: string[];
+};
+export type NoteExportItem = {
+    id: string;
+    created_at: string | null;
+    updated_at: string | null;
+    title: string | null;
+    type: string | null;
+    source: string | null;
+    summary: string | null;
+    tags: string[];
+    is_del: number | null;
+    is_pub: boolean;
+    properties: Record<string, unknown>;
+    starred_at: string | null;
+    is_starred: boolean;
+    content_md: string;
+    content_text: string | null;
+    content_json: unknown;
+    box_ids: string[];
+    boxes: string[];
+};
+export type NoteContextRow = {
+    id: string;
+    title: string | null;
+    summary: string | null;
+    content_text: string | null;
+    tags: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+    is_del: number | null;
+    starred_at: string | null;
+    is_starred: number | null;
+    zettel_boxes_raw: string | null;
+};
+export type NoteContext = {
+    id: string;
+    title: string;
+    summary: string;
+    tags: string[];
+    created_at: string | null;
+    updated_at: string | null;
+    is_del: number | null;
+    starred_at: string | null;
+    is_starred: boolean;
+    zettel_boxes: string[];
+    links: {
+        backlinks: number;
+        outlinks: number;
+    };
+};
+export type NotePreview = {
+    id: string;
+    title: string;
+    requested_lines: number;
+    total_lines: number;
+    returned_lines: number;
+    truncated: boolean;
+    preview: string;
+    updated_at: string | null;
+};
+export type NoteUpdateStateRow = {
+    id: string;
+    tags: string | null;
+    zettel_boxes: string | null;
+    is_del: number | null;
+    starred_at: string | null;
+};
+export type NoteUpdatableStateRow = {
+    id: string;
+    is_del: number | null;
+};
+export type UpdateNoteResult = {
+    id: string;
+    updated: boolean;
+    changed: string[];
+    tags: string[];
+    zettelBoxIds: string[];
+    is_starred: boolean;
+};
+export declare function normalizeStoredFlag(value: unknown): boolean;
+export declare function normalizeStoredStarred(value: unknown): boolean;
+export declare function parseStoredTags(raw: string | null): string[];
+export declare function parseZettelBoxIds(raw: string | null): string[];
+export declare function loadZettelBoxNameMap(db: AbstractPowerSyncDatabase, ids: string[]): Promise<Map<string, string>>;
+export declare function resolveSummary(summary: string | null, contentText: string | null): string;
+export declare function truncateSearchSummary(value: string): string;
+export declare function normalizeLookupKey(value: string): string;