@dinoxx/dinox-cli 2.0.0 → 2.1.1

package/dist/commands/notes/repo.js

@@ -1,1360 +1,7 @@
-import { DinoxError } from '../../utils/errors.js';
-import { nowIsoUtc } from '../../utils/time.js';
-import { tokenizeWithJieba } from '../../utils/tokenize.js';
-import { canonicalizeBoxPath, listBoxes } from '../boxes/repo.js';
-import { listTags } from '../tags/repo.js';
-import { deriveImageDetailFromContentJson } from '../todo/contentModel.js';
-import { buildNoteSearchSqlFilter } from './searchSql.js';
-const MAX_SEARCH_SUMMARY_CHARS = 200;
-function normalizeStoredFlag(value) {
-    if (typeof value === 'number') {
-        return value === 1;
-    }
-    if (typeof value === 'string') {
-        return value.trim() === '1';
-    }
-    return false;
-}
-function normalizeStoredStarred(value) {
-    return normalizeStoredFlag(value);
-}
-/**
- * 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 resolveSummary(summary, contentText) {
-    const summaryValue = summary?.trim() ?? '';
-    if (summaryValue.length > 0) {
-        return truncateSearchSummary(summaryValue);
-    }
-    return truncateSearchSummary(contentText?.trim() ?? '');
-}
-function truncateSearchSummary(value) {
-    const chars = Array.from(value);
-    if (chars.length <= MAX_SEARCH_SUMMARY_CHARS) {
-        return value;
-    }
-    return chars.slice(0, MAX_SEARCH_SUMMARY_CHARS).join('');
-}
-export function parseZettelBoxIds(raw) {
-    const value = raw?.trim();
-    if (!value) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(value);
-        if (!Array.isArray(parsed)) {
-            return [];
-        }
-        return Array.from(new Set(parsed
-            .map((entry) => String(entry).trim())
-            .filter((entry) => entry.length > 0)));
-    }
-    catch {
-        return [];
-    }
-}
-async function loadZettelBoxNameMap(db, ids) {
-    const map = new Map();
-    if (ids.length === 0) {
-        return map;
-    }
-    const chunkSize = 500;
-    for (let i = 0; i < ids.length; i += chunkSize) {
-        const batch = ids.slice(i, i + chunkSize);
-        const placeholders = batch.map(() => '?').join(', ');
-        const rows = await db.getAll(`
-      SELECT id, name, path
-      FROM c_zettel_box
-      WHERE (is_del IS NULL OR is_del = 0)
-        AND id IN (${placeholders})
-      `, batch);
-        for (const row of rows) {
-            const id = row.id?.trim() ?? '';
-            if (!id) {
-                continue;
-            }
-            const path = canonicalizeBoxPath(row.path ?? row.name ?? '');
-            map.set(id, path || row.name?.trim() || '');
-        }
-    }
-    return map;
-}
-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
-      )
-    `;
-}
-export async function getNote(db, id) {
-    return db.getOptional(`
-    SELECT
-      id,
-      title,
-      content_md,
-      content_json,
-      content_text,
-      created_at,
-      updated_at,
-      is_del,
-      starred_at,
-      CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
-      version
-    FROM c_note
-    WHERE id = ?
-    `, [id]);
-}
-async function getLinkCount(db, direction, noteId) {
-    const [column, boundColumn] = direction === 'in'
-        ? ['src_note_id', 'dst_note_id']
-        : ['dst_note_id', 'src_note_id'];
-    const row = await db.getOptional(`
-    SELECT COUNT(1) AS count
-    FROM c_note_link l
-    JOIN c_note n ON n.id = l.${column}
-    WHERE l.${boundColumn} = ?
-      AND (l.is_del IS NULL OR l.is_del = 0)
-      AND (n.is_del IS NULL OR n.is_del = 0)
-    `, [noteId]);
-    return Number(row?.count ?? 0);
-}
-function buildPreviewText(contentMd, requestedLines) {
-    const normalized = (contentMd ?? '').replace(/\r\n/g, '\n');
-    if (!normalized) {
-        return {
-            preview: '',
-            totalLines: 0,
-            returnedLines: 0,
-            truncated: false,
-        };
-    }
-    const lines = normalized.split('\n');
-    const selected = lines.slice(0, requestedLines);
-    return {
-        preview: selected.join('\n'),
-        totalLines: lines.length,
-        returnedLines: selected.length,
-        truncated: selected.length < lines.length,
-    };
-}
-export async function getNoteContext(db, id) {
-    const row = await db.getOptional(`
-    SELECT
-      n.id,
-      n.title,
-      n.summary,
-      n.content_text,
-      n.tags,
-      n.created_at,
-      n.updated_at,
-      n.is_del,
-      n.starred_at,
-      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
-      n.zettel_boxes AS zettel_boxes_raw
-    FROM c_note n
-    WHERE n.id = ?
-    `, [id]);
-    if (!row) {
-        return null;
-    }
-    const boxIds = parseZettelBoxIds(row.zettel_boxes_raw);
-    const boxNameMap = await loadZettelBoxNameMap(db, boxIds);
-    const [backlinks, outlinks] = await Promise.all([
-        getLinkCount(db, 'in', id),
-        getLinkCount(db, 'out', id),
-    ]);
-    return {
-        id: row.id,
-        title: row.title?.trim() ?? '',
-        summary: resolveSummary(row.summary, row.content_text),
-        tags: parseStoredTags(row.tags),
-        created_at: row.created_at,
-        updated_at: row.updated_at,
-        is_del: row.is_del,
-        starred_at: row.starred_at ?? null,
-        is_starred: normalizeStoredStarred(row.is_starred),
-        zettel_boxes: boxIds
-            .map((boxId) => boxNameMap.get(boxId))
-            .filter((name) => typeof name === 'string' && name.length > 0),
-        links: {
-            backlinks,
-            outlinks,
-        },
-    };
-}
-export async function getNotePreview(db, id, requestedLines) {
-    const row = await db.getOptional(`
-    SELECT
-      n.id,
-      n.title,
-      n.content_md,
-      n.updated_at
-    FROM c_note n
-    WHERE n.id = ?
-    `, [id]);
-    if (!row) {
-        return null;
-    }
-    const preview = buildPreviewText(row.content_md, requestedLines);
-    return {
-        id: row.id,
-        title: row.title?.trim() ?? '',
-        requested_lines: requestedLines,
-        total_lines: preview.totalLines,
-        returned_lines: preview.returnedLines,
-        truncated: preview.truncated,
-        preview: preview.preview,
-        updated_at: row.updated_at ?? null,
-    };
-}
-function mapNoteDetailRow(note, boxNameMap) {
-    const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
-    const zettelBoxes = boxIds
-        .map((boxId) => boxNameMap.get(boxId))
-        .filter((name) => typeof name === 'string' && name.length > 0);
-    return {
-        id: note.id,
-        created_at: note.created_at,
-        updated_at: note.updated_at,
-        title: note.title,
-        type: note.type,
-        source: note.source,
-        tags: parseStoredTags(note.tags),
-        is_del: note.is_del,
-        is_pub: normalizeStoredFlag(note.is_pub),
-        properties: parseStoredNoteProperties(note.properties),
-        starred_at: note.starred_at ?? null,
-        is_starred: normalizeStoredStarred(note.is_starred),
-        content_md: note.content_md,
-        content_text: note.content_text,
-        content_json: parseStoredJsonValue(note.content_json),
-        zettel_boxes: zettelBoxes,
-    };
-}
-function parseStoredJsonValue(raw) {
-    const value = raw?.trim() ?? '';
-    if (!value) {
-        return null;
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return raw;
-    }
-}
-function parseStoredNoteProperties(raw) {
-    const value = raw?.trim() ?? '';
-    if (!value) {
-        return {};
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(value);
-    }
-    catch (cause) {
-        throw new DinoxError('c_note.properties must be valid JSON', {
-            code: 'NOTE_INVALID_PROPERTIES',
-            details: { cause: cause instanceof Error ? cause.message : String(cause) },
-            recoverable: false,
-        });
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new DinoxError('c_note.properties must be a JSON object', {
-            code: 'NOTE_INVALID_PROPERTIES',
-            recoverable: false,
-        });
-    }
-    return Object.fromEntries(Object.entries(parsed));
-}
-function mapNoteExportRow(note, boxNameMap) {
-    const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
-    const boxes = boxIds
-        .map((boxId) => boxNameMap.get(boxId))
-        .filter((name) => typeof name === 'string' && name.length > 0);
-    return {
-        id: note.id,
-        created_at: note.created_at,
-        updated_at: note.updated_at,
-        title: note.title,
-        type: note.type,
-        source: note.source,
-        summary: note.summary,
-        tags: parseStoredTags(note.tags),
-        is_del: note.is_del,
-        is_pub: normalizeStoredFlag(note.is_pub),
-        properties: parseStoredNoteProperties(note.properties),
-        starred_at: note.starred_at ?? null,
-        is_starred: normalizeStoredStarred(note.is_starred),
-        content_md: note.content_md ?? '',
-        content_text: note.content_text,
-        content_json: parseStoredJsonValue(note.content_json),
-        box_ids: boxIds,
-        boxes,
-    };
-}
-export async function getNoteDetails(db, ids) {
-    const targetIds = Array.from(new Set(ids
-        .map((id) => id.trim())
-        .filter((id) => id.length > 0)));
-    if (targetIds.length === 0) {
-        return [];
-    }
-    const noteRowsById = new Map();
-    const chunkSize = 500;
-    for (let index = 0; index < targetIds.length; index += chunkSize) {
-        const batch = targetIds.slice(index, index + chunkSize);
-        const placeholders = batch.map(() => '?').join(', ');
-        const rows = await db.getAll(`
-      SELECT
-        id,
-        created_at,
-        updated_at,
-        title,
-        type,
-        source,
-        tags,
-        is_del,
-        is_pub,
-        properties,
-        starred_at,
-        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
-        content_md,
-        content_text,
-        content_json,
-        zettel_boxes AS zettel_boxes_raw
-      FROM c_note
-      WHERE id IN (${placeholders})
-      `, batch);
-        for (const row of rows) {
-            const id = row.id?.trim() ?? '';
-            if (!id || noteRowsById.has(id)) {
-                continue;
-            }
-            noteRowsById.set(id, row);
-        }
-    }
-    const allBoxIds = Array.from(new Set(Array.from(noteRowsById.values()).flatMap((row) => parseZettelBoxIds(row.zettel_boxes_raw))));
-    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
-    const details = [];
-    for (const id of targetIds) {
-        const row = noteRowsById.get(id);
-        if (!row) {
-            continue;
-        }
-        details.push(mapNoteDetailRow(row, boxNameMap));
-    }
-    return details;
-}
-export async function getNoteDetail(db, id) {
-    const details = await getNoteDetails(db, [id]);
-    return details[0] ?? null;
-}
-export async function getNoteExportItems(db, ids) {
-    const targetIds = Array.from(new Set(ids
-        .map((id) => id.trim())
-        .filter((id) => id.length > 0)));
-    if (targetIds.length === 0) {
-        return [];
-    }
-    const noteRowsById = new Map();
-    const chunkSize = 500;
-    for (let index = 0; index < targetIds.length; index += chunkSize) {
-        const batch = targetIds.slice(index, index + chunkSize);
-        const placeholders = batch.map(() => '?').join(', ');
-        const rows = await db.getAll(`
-      SELECT
-        id,
-        created_at,
-        updated_at,
-        title,
-        type,
-        source,
-        tags,
-        summary,
-        is_del,
-        is_pub,
-        properties,
-        starred_at,
-        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
-        content_md,
-        content_text,
-        content_json,
-        zettel_boxes AS zettel_boxes_raw
-      FROM c_note
-      WHERE id IN (${placeholders})
-      `, batch);
-        for (const row of rows) {
-            const id = row.id?.trim() ?? '';
-            if (!id || noteRowsById.has(id)) {
-                continue;
-            }
-            noteRowsById.set(id, row);
-        }
-    }
-    const allBoxIds = Array.from(new Set(Array.from(noteRowsById.values()).flatMap((row) => parseZettelBoxIds(row.zettel_boxes_raw))));
-    const boxNameMap = await loadZettelBoxNameMap(db, allBoxIds);
-    const items = [];
-    for (const id of targetIds) {
-        const row = noteRowsById.get(id);
-        if (!row) {
-            continue;
-        }
-        items.push(mapNoteExportRow(row, boxNameMap));
-    }
-    return items;
-}
-export async function createNote(db, input) {
-    const userId = input.userId.trim();
-    if (!userId) {
-        throw new DinoxError('userId is required to create a note');
-    }
-    const now = nowIsoUtc();
-    const contentJson = JSON.stringify(input.contentJson);
-    const tags = JSON.stringify(input.tags);
-    const zettelBoxes = JSON.stringify(input.zettelBoxIds);
-    const imageDetail = JSON.stringify(Array.isArray(input.imageDetail)
-        ? input.imageDetail
-        : deriveImageDetailFromContentJson(input.contentJson, input.id));
-    const columns = await db.getAll('PRAGMA table_info(c_note)', []);
-    const columnNames = new Set(columns
-        .map((row) => row.name?.trim().toLowerCase() ?? '')
-        .filter((name) => name.length > 0));
-    const userColumns = [];
-    if (columnNames.has('user_id')) {
-        userColumns.push('user_id');
-    }
-    if (columnNames.has('user_no')) {
-        userColumns.push('user_no');
-    }
-    if (userColumns.length === 0) {
-        throw new DinoxError('c_note table is missing both user_id and user_no columns');
-    }
-    if (!columnNames.has('type')) {
-        throw new DinoxError('c_note table is missing type column');
-    }
-    const requiredColumns = [
-        'id',
-        'title',
-        'type',
-        'content_md',
-        'content_json',
-        'content_text',
-        'tags',
-        'zettel_boxes',
-        'created_at',
-        'updated_at',
-        'is_del',
-        'version',
-    ];
-    const missingRequired = requiredColumns.filter((name) => !columnNames.has(name));
-    if (missingRequired.length > 0) {
-        throw new DinoxError(`c_note table is missing required columns: ${missingRequired.join(', ')}`);
-    }
-    const fullInsertEntries = [
-        ['id', input.id],
-        ['title', input.title],
-        ['type', input.noteType],
-        ['user_no', userId],
-        ['user_id', userId],
-        ['created_at', now],
-        ['updated_at', now],
-        ['is_del', 0],
-        ['status', 0],
-        ['version', 1],
-        ['content', ''],
-        ['content_json', contentJson],
-        ['content_text', input.contentText],
-        ['content_md', input.contentMd],
-        ['summary', ''],
-        ['tags', tags],
-        ['zettel_boxes', zettelBoxes],
-        ['images', '[]'],
-        ['files', '[]'],
-        ['audios', '[]'],
-        ['audio_detail', '{}'],
-        ['image_detail', imageDetail],
-        ['source', ''],
-        ['resource_id', null],
-        ['note_ids', '[]'],
-        ['extra_data', '{}'],
-        ['properties', null],
-        ['is_pub', 0],
-        ['format_type', ''],
-        ['comments', '[]'],
-        ['is_top', 0],
-        ['pinned_at', '1997-01-01T00:00:00.000Z'],
-        ['starred_at', null],
-        ['chat_context', '{}'],
-        ['bid_links', '[]'],
-    ];
-    const insertEntries = fullInsertEntries.filter(([column]) => columnNames.has(column));
-    const insertColumns = insertEntries.map(([column]) => column);
-    const placeholders = insertEntries.map(() => '?').join(', ');
-    const params = insertEntries.map(([, value]) => value);
-    await db.execute(`
-    INSERT INTO c_note (
-      ${insertColumns.join(', ')}
-    ) VALUES (${placeholders})
-    `, params);
-    return { id: input.id };
-}
-function normalizeLookupKey(value) {
-    return value.trim().toLowerCase();
-}
-function normalizeZettelBoxLookupKey(value) {
-    return canonicalizeBoxPath(value).toLowerCase();
-}
-function buildZettelBoxRetryQuestion(intent, type) {
-    const command = intent === 'search'
-        ? 'dino note search'
-        : intent === 'update'
-            ? 'dino note update'
-            : intent === 'bulk'
-                ? 'dino note bulk'
-                : 'dino note create';
-    if (type === 'ambiguous') {
-        return `Do you want to specify box paths and retry \`${command}\`?`;
-    }
-    return `Do you want to add these missing boxes and retry \`${command}\`?`;
-}
-export async function validateTagsForCreate(db, requestedTags, userId) {
-    return validateTagsForWrite(db, requestedTags, userId, 'dino note create');
-}
-export async function validateTagsForUpdate(db, requestedTags, userId) {
-    return validateTagsForWrite(db, requestedTags, userId, 'dino note update');
-}
-export async function validateTagsForBulk(db, requestedTags, userId) {
-    return validateTagsForWrite(db, requestedTags, userId, 'dino note bulk');
-}
-async function validateTagsForWrite(db, requestedTags, userId, retryCommand) {
-    const normalizedUserId = userId.trim();
-    if (!normalizedUserId) {
-        throw new DinoxError('Tag validation requires the current userId. Run `dino auth login` first, or set DINOX_TOKEN and run an online command so the CLI can resolve the token identity.');
-    }
-    if (requestedTags.length === 0) {
-        return [];
-    }
-    const tags = await listTags(db, { userId: normalizedUserId });
-    const existingTagMap = new Map();
-    for (const tag of tags) {
-        const key = normalizeLookupKey(tag);
-        if (!key || existingTagMap.has(key)) {
-            continue;
-        }
-        existingTagMap.set(key, tag);
-    }
-    const resolved = [];
-    const seen = new Set();
-    const missing = [];
-    for (const requested of requestedTags) {
-        const key = normalizeLookupKey(requested);
-        if (!key || seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        const matched = existingTagMap.get(key);
-        if (!matched) {
-            missing.push(requested);
-            continue;
-        }
-        resolved.push(matched);
-    }
-    if (missing.length > 0) {
-        throw new DinoxError(`Unknown tags: ${missing.join(', ')}`, {
-            details: {
-                type: 'missing_tags',
-                missing,
-                knownCount: tags.length,
-                knownSample: tags.slice(0, 20),
-                question: `Do you want to add these missing tags and retry \`${retryCommand}\`?`,
-            },
-        });
-    }
-    return resolved;
-}
-export function parseStoredTags(raw) {
-    if (!raw) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed)) {
-            return [];
-        }
-        const result = [];
-        const seen = new Set();
-        for (const value of parsed) {
-            const normalized = String(value).trim();
-            const key = normalizeLookupKey(normalized);
-            if (!key || seen.has(key)) {
-                continue;
-            }
-            seen.add(key);
-            result.push(normalized);
-        }
-        return result;
-    }
-    catch {
-        return [];
-    }
-}
-function normalizeDistinctStrings(values) {
-    return Array.from(new Set(values
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0)));
-}
-function sameTagSet(left, right) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    const leftKeys = left.map(normalizeLookupKey).sort();
-    const rightKeys = right.map(normalizeLookupKey).sort();
-    return leftKeys.every((value, index) => value === rightKeys[index]);
-}
-function sameStringSet(left, right) {
-    if (left.length !== right.length) {
-        return false;
-    }
-    const leftSorted = [...left].sort();
-    const rightSorted = [...right].sort();
-    return leftSorted.every((value, index) => value === rightSorted[index]);
-}
-export async function updateNote(db, input) {
-    const id = input.id.trim();
-    if (!id) {
-        throw new DinoxError('Note id is required');
-    }
-    const shouldUpdateTags = Array.isArray(input.tags);
-    const shouldUpdateBoxes = Array.isArray(input.zettelBoxIds);
-    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, starred_at
-    FROM c_note
-    WHERE id = ?
-    `, [id]);
-    if (!existing) {
-        throw new DinoxError(`Note not found: ${id}`);
-    }
-    if (typeof existing.is_del === 'number' && existing.is_del !== 0) {
-        throw new DinoxError(`Note has been deleted: ${id}`);
-    }
-    const currentTags = parseStoredTags(existing.tags);
-    const currentZettelBoxIds = parseZettelBoxIds(existing.zettel_boxes);
-    const currentStarred = existing.starred_at !== null;
-    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);
-    const starredChanged = shouldUpdateStarred && currentStarred !== nextStarred;
-    if (!tagsChanged && !boxesChanged && !starredChanged) {
-        return {
-            id,
-            updated: false,
-            changed: [],
-            tags: currentTags,
-            zettelBoxIds: currentZettelBoxIds,
-            is_starred: currentStarred,
-        };
-    }
-    const setParts = [];
-    const params = [];
-    if (tagsChanged) {
-        setParts.push('tags = ?');
-        params.push(JSON.stringify(nextTags));
-    }
-    if (boxesChanged) {
-        setParts.push('zettel_boxes = ?');
-        params.push(JSON.stringify(nextZettelBoxIds));
-    }
-    if (starredChanged) {
-        setParts.push('starred_at = ?');
-    }
-    const updatedAt = nowIsoUtc();
-    if (starredChanged) {
-        params.push(nextStarred ? updatedAt : null);
-    }
-    setParts.push('updated_at = ?');
-    params.push(updatedAt);
-    setParts.push('version = COALESCE(version, 0) + 1');
-    params.push(id);
-    await db.execute(`
-    UPDATE c_note
-    SET ${setParts.join(',\n        ')}
-    WHERE id = ?
-    `, params);
-    return {
-        id,
-        updated: true,
-        changed: [
-            ...(tagsChanged ? ['tags'] : []),
-            ...(boxesChanged ? ['boxes'] : []),
-            ...(starredChanged ? ['is_starred'] : []),
-        ],
-        tags: nextTags,
-        zettelBoxIds: nextZettelBoxIds,
-        is_starred: nextStarred,
-    };
-}
-export async function assertNotesUpdatable(db, noteIds) {
-    const ids = Array.from(new Set(noteIds
-        .map((id) => id.trim())
-        .filter((id) => id.length > 0)));
-    if (ids.length === 0) {
-        throw new DinoxError('At least one note id is required');
-    }
-    const existing = new Map();
-    const chunkSize = 500;
-    for (let index = 0; index < ids.length; index += chunkSize) {
-        const batch = ids.slice(index, index + chunkSize);
-        const placeholders = batch.map(() => '?').join(', ');
-        const rows = await db.getAll(`
-      SELECT id, is_del
-      FROM c_note
-      WHERE id IN (${placeholders})
-      `, batch);
-        for (const row of rows) {
-            const id = row.id?.trim();
-            if (!id) {
-                continue;
-            }
-            existing.set(id, row.is_del ?? null);
-        }
-    }
-    const missing = ids.filter((id) => !existing.has(id));
-    if (missing.length > 0) {
-        throw new DinoxError(`Notes not found: ${missing.join(', ')}`);
-    }
-    const deleted = ids.filter((id) => {
-        const isDel = existing.get(id);
-        return typeof isDel === 'number' && isDel !== 0;
-    });
-    if (deleted.length > 0) {
-        throw new DinoxError(`Notes have been deleted: ${deleted.join(', ')}`);
-    }
-}
-export async function resolveZettelBoxIdsForCreate(db, requestedNames) {
-    return resolveZettelBoxIdsByName(db, requestedNames, 'create');
-}
-export async function resolveZettelBoxIdsForSearch(db, requestedNames) {
-    return resolveZettelBoxIdsByName(db, requestedNames, 'search');
-}
-export async function resolveZettelBoxIdsForUpdate(db, requestedNames) {
-    return resolveZettelBoxIdsByName(db, requestedNames, 'update');
-}
-export async function resolveZettelBoxIdsForBulk(db, requestedNames) {
-    return resolveZettelBoxIdsByName(db, requestedNames, 'bulk');
-}
-async function resolveZettelBoxIdsByName(db, requestedNames, intent) {
-    if (requestedNames.length === 0) {
-        return [];
-    }
-    const boxes = await listBoxes(db);
-    const availablePaths = Array.from(new Set(boxes.map((box) => box.path.trim()).filter(Boolean)));
-    const boxByPath = new Map();
-    const boxByName = new Map();
-    for (const box of boxes) {
-        const name = box.name.trim();
-        const path = canonicalizeBoxPath(box.path || name);
-        const pathKey = normalizeZettelBoxLookupKey(path);
-        if (pathKey && !boxByPath.has(pathKey)) {
-            boxByPath.set(pathKey, box.id);
-        }
-        const nameKey = normalizeLookupKey(name);
-        if (!nameKey) {
-            continue;
-        }
-        const current = boxByName.get(nameKey);
-        if (!current) {
-            boxByName.set(nameKey, {
-                name,
-                ids: [box.id],
-                paths: path ? [path] : [],
-            });
-            continue;
-        }
-        if (!current.ids.includes(box.id)) {
-            current.ids.push(box.id);
-        }
-        if (path && !current.paths.includes(path)) {
-            current.paths.push(path);
-        }
-    }
-    const resolvedIds = [];
-    const seenIds = new Set();
-    const missing = [];
-    const ambiguous = [];
-    const seenAmbiguous = new Set();
-    for (const requested of requestedNames) {
-        const pathKey = normalizeZettelBoxLookupKey(requested);
-        if (!pathKey) {
-            continue;
-        }
-        const pathMatchId = boxByPath.get(pathKey);
-        if (pathMatchId) {
-            if (!seenIds.has(pathMatchId)) {
-                seenIds.add(pathMatchId);
-                resolvedIds.push(pathMatchId);
-            }
-            continue;
-        }
-        const lookup = boxByName.get(normalizeLookupKey(requested));
-        if (!lookup) {
-            missing.push(requested);
-            continue;
-        }
-        if (lookup.ids.length > 1) {
-            const marker = `${requested.toLowerCase()}::${lookup.ids.join(',')}`;
-            if (!seenAmbiguous.has(marker)) {
-                seenAmbiguous.add(marker);
-                ambiguous.push({
-                    name: requested,
-                    ids: lookup.ids,
-                    paths: lookup.paths,
-                });
-            }
-            continue;
-        }
-        const id = lookup.ids[0];
-        if (!seenIds.has(id)) {
-            seenIds.add(id);
-            resolvedIds.push(id);
-        }
-    }
-    if (ambiguous.length > 0) {
-        throw new DinoxError(`Ambiguous zettel box names: ${ambiguous.map((item) => `${item.name} -> [${item.paths.join(', ')}]`).join('; ')}`, {
-            details: {
-                type: 'ambiguous_zettel_boxes',
-                ambiguous,
-                availablePathsSample: availablePaths.slice(0, 20),
-                question: buildZettelBoxRetryQuestion(intent, 'ambiguous'),
-            },
-        });
-    }
-    if (missing.length > 0) {
-        throw new DinoxError(`Unknown zettel box paths or names: ${missing.join(', ')}`, {
-            details: {
-                type: 'missing_zettel_boxes',
-                missing,
-                availableCount: availablePaths.length,
-                availablePathsSample: availablePaths.slice(0, 20),
-                question: buildZettelBoxRetryQuestion(intent, 'missing'),
-            },
-        });
-    }
-    return resolvedIds;
-}
-export async function softDeleteNote(db, id) {
-    const existing = await db.getOptional('SELECT id FROM c_note WHERE id = ?', [id]);
-    if (!existing) {
-        throw new DinoxError(`Note not found: ${id}`);
-    }
-    await db.execute(`
-    UPDATE c_note
-    SET is_del = 1,
-        updated_at = ?,
-        version = COALESCE(version, 0) + 1
-    WHERE id = ?
-    `, [nowIsoUtc(), id]);
-}
+// Public note repository API. Implementation lives in ./repo/*; this module re-exports
+// only the original public surface so callers do not depend on the internal split.
+export { parseStoredTags, parseZettelBoxIds, } from './repo/shared.js';
+export { executeNoteSearch, searchNotes, searchNotesPage, } from './repo/search.js';
+export { getNote, getNoteContext, getNoteDetail, getNoteDetails, getNoteExportItems, getNotePreview, } from './repo/read.js';
+export { assertNotesUpdatable, createNote, softDeleteNote, updateNote, } from './repo/write.js';
+export { resolveZettelBoxIdsForBulk, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, validateTagsForBulk, validateTagsForCreate, validateTagsForUpdate, } from './repo/resolve.js';