@dinoxx/dinox-cli 1.0.0

package/dist/commands/notes/repo.js

@@ -0,0 +1,674 @@
+import { DinoxError } from '../../utils/errors.js';
+import { nowIsoUtc } from '../../utils/time.js';
+import { tokenizeWithJieba } from '../../utils/tokenize.js';
+import { listBoxes } from '../boxes/repo.js';
+import { listTags } from '../tags/repo.js';
+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');
+    let rows = [];
+    if (!options.includeDeleted) {
+        const ftsMatch = buildFtsMatchQuery(normalizedQuery);
+        if (ftsMatch) {
+            try {
+                rows = await searchNotesWithFts(db, ftsMatch, tagFilter, createdAtFilter);
+                return enrichSearchRows(db, rows);
+            }
+            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 = `%${normalizedQuery}%`;
+        whereClauses.push(`
+      (
+        (n.title IS NOT NULL AND n.title LIKE ?)
+        OR (n.content_text IS NOT NULL AND n.content_text LIKE ?)
+      )
+      `);
+        params.push(like, like);
+    }
+    if (tagFilter) {
+        whereClauses.push(tagFilter.sql);
+        params.push(...tagFilter.params);
+    }
+    if (createdAtFilter) {
+        whereClauses.push(createdAtFilter.sql);
+        params.push(...createdAtFilter.params);
+    }
+    rows = await db.getAll(`
+    SELECT
+      n.id,
+      n.title,
+      n.summary,
+      n.content_text,
+      n.zettel_boxes,
+      n.updated_at,
+      n.is_del,
+      n.version
+    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) {
+    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);
+    }
+    return db.getAll(`
+    SELECT
+      n.id,
+      n.title,
+      n.summary,
+      n.content_text,
+      n.zettel_boxes,
+      n.updated_at,
+      n.is_del,
+      n.version
+    FROM note_local_fts f
+    JOIN c_note n ON n.id = f.note_id
+    WHERE ${whereClauses.join('\n      AND ')}
+    ORDER BY bm25(note_local_fts, 8.0, 4.0, 1.0) ASC, COALESCE(n.updated_at, n.created_at) DESC
+    `, params);
+}
+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,
+            updated_at: row.updated_at,
+            is_del: row.is_del,
+            version: row.version,
+            zettel_boxes: zettelBoxes,
+        };
+    });
+}
+function resolveSummary(summary, contentText) {
+    const summaryValue = summary?.trim() ?? '';
+    if (summaryValue.length > 0) {
+        return summaryValue;
+    }
+    return contentText?.trim() ?? '';
+}
+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
+      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;
+            }
+            map.set(id, 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;
+    }
+    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 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();
+}
+export async function getNote(db, id) {
+    return db.getOptional(`
+    SELECT
+      id,
+      title,
+      content_md,
+      content_json,
+      content_text,
+      created_at,
+      updated_at,
+      is_del,
+      version
+    FROM c_note
+    WHERE id = ?
+    `, [id]);
+}
+export async function getNoteDetail(db, id) {
+    const note = await db.getOptional(`
+    SELECT
+      id,
+      content,
+      audios,
+      images,
+      created_at,
+      updated_at,
+      title,
+      type,
+      source,
+      resource_id,
+      tags,
+      is_del,
+      content_md,
+      format_type,
+      zettel_boxes AS zettel_boxes_raw
+    FROM c_note
+    WHERE id = ?
+    `, [id]);
+    if (!note) {
+        return null;
+    }
+    const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
+    const boxNameMap = await loadZettelBoxNameMap(db, boxIds);
+    const zettelBoxes = boxIds
+        .map((boxId) => boxNameMap.get(boxId))
+        .filter((name) => typeof name === 'string' && name.length > 0);
+    return {
+        id: note.id,
+        content: note.content,
+        audios: note.audios,
+        images: note.images,
+        created_at: note.created_at,
+        updated_at: note.updated_at,
+        title: note.title,
+        type: note.type,
+        source: note.source,
+        resource_id: note.resource_id,
+        tags: note.tags,
+        is_del: note.is_del,
+        content_md: note.content_md,
+        format_type: note.format_type,
+        zettel_boxes: zettelBoxes,
+    };
+}
+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 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', '{}'],
+        ['source', ''],
+        ['resource_id', null],
+        ['note_ids', '[]'],
+        ['extra_data', '{}'],
+        ['format_type', ''],
+        ['comments', '[]'],
+        ['is_top', 0],
+        ['pinned_at', '1997-01-01T00:00:00.000Z'],
+        ['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();
+}
+export async function validateTagsForCreate(db, requestedTags) {
+    if (requestedTags.length === 0) {
+        return [];
+    }
+    const tags = await listTags(db);
+    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 `dino note create`?',
+            },
+        });
+    }
+    return resolved;
+}
+export async function resolveZettelBoxIdsForCreate(db, requestedNames) {
+    if (requestedNames.length === 0) {
+        return [];
+    }
+    const boxes = await listBoxes(db);
+    const availableNames = Array.from(new Set(boxes.map((box) => box.name.trim()).filter(Boolean)));
+    const boxByName = new Map();
+    for (const box of boxes) {
+        const name = box.name.trim();
+        const key = normalizeLookupKey(name);
+        if (!key) {
+            continue;
+        }
+        const current = boxByName.get(key);
+        if (!current) {
+            boxByName.set(key, {
+                name,
+                ids: [box.id],
+            });
+            continue;
+        }
+        if (!current.ids.includes(box.id)) {
+            current.ids.push(box.id);
+        }
+    }
+    const resolvedIds = [];
+    const seenIds = new Set();
+    const missing = [];
+    const ambiguous = [];
+    const seenAmbiguous = new Set();
+    for (const requested of requestedNames) {
+        const key = normalizeLookupKey(requested);
+        if (!key) {
+            continue;
+        }
+        const lookup = boxByName.get(key);
+        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,
+                });
+            }
+            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.ids.join(', ')}]`).join('; ')}`, {
+            details: {
+                type: 'ambiguous_zettel_boxes',
+                ambiguous,
+                availableNamesSample: availableNames.slice(0, 20),
+                question: 'Do you want to specify unique box names (or IDs) and retry `dino note create`?',
+            },
+        });
+    }
+    if (missing.length > 0) {
+        throw new DinoxError(`Unknown zettel box names: ${missing.join(', ')}`, {
+            details: {
+                type: 'missing_zettel_boxes',
+                missing,
+                availableCount: availableNames.length,
+                availableNamesSample: availableNames.slice(0, 20),
+                question: 'Do you want to add these missing boxes and retry `dino note create`?',
+            },
+        });
+    }
+    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]);
+}

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

@@ -0,0 +1,9 @@
+export type ParsedCreatedAtRange = {
+    createdAtFrom?: string;
+    createdAtTo?: string;
+};
+export declare function parseCreatedAtRange(input: {
+    from?: unknown;
+    to?: unknown;
+    days?: unknown;
+}, now?: Date): ParsedCreatedAtRange;