@dinoxx/dinox-cli 1.0.6 → 1.0.7

package/README.md

@@ -342,17 +342,23 @@ dino box add "你的卡片盒"
 
 | 参数 | 必填 | 说明 |
 | --- | --- | --- |
-| `<id>` | 是 | 笔记 ID。 |
+| `[id]` | 否 | 单个笔记 ID（可与 `--ids` 组合，去重后批量更新）。 |
 
 支持全局参数：`--json`、`--offline`、`--sync-timeout`
 
-### `dino note detail <id>`
+### `dino note detail [id]`
 
-按 ID 获取笔记完整详情。
+按 ID 获取笔记完整详情，支持批量读取。
 
 | 参数 | 必填 | 说明 |
 | --- | --- | --- |
-| `<id>` | 是 | 笔记 ID。 |
+| `[id]` | 否 | 单个笔记 ID（可与 `--ids` 组合，去重后批量读取）。 |
+
+| 选项 | 必填 | 说明 |
+| --- | --- | --- |
+| `--ids <string\|@file>` | 否 | 笔记 ID 列表（JSON 数组或逗号/换行分隔）。 |
+
+说明：`[id]` 与 `--ids` 至少提供一个。
 
 支持全局参数：`--offline`、`--sync-timeout`
 
@@ -370,6 +376,24 @@ dino box add "你的卡片盒"
 
 支持全局参数：`--json`、`--offline`、`--sync-timeout`
 
+### `dino note update [id] [options]`
+
+按 ID 更新笔记标签/卡片盒（全量替换）。
+
+| 参数 | 必填 | 说明 |
+| --- | --- | --- |
+| `<id>` | 是 | 笔记 ID。 |
+
+| 选项 | 必填 | 说明 |
+| --- | --- | --- |
+| `--ids <string\|@file>` | 否 | 批量更新的笔记 ID 列表（JSON 数组或逗号/换行分隔）。 |
+| `--tags <string\|@file>` | 否 | 标签列表（JSON 数组或逗号/换行分隔）。传 `[]` 可清空标签。 |
+| `--boxes <string\|@file>` | 否 | 卡片盒名称列表（JSON 数组或逗号/换行分隔）。传 `[]` 可清空卡片盒。 |
+
+说明：`<id>` 与 `--ids` 至少提供一个；`--tags` 与 `--boxes` 至少提供一个。
+
+支持全局参数：`--json`、`--offline`、`--sync-timeout`
+
 ### `dino note delete <id>`
 
 软删除笔记（`is_del=1`）。

package/dist/commands/notes/index.js

@@ -8,7 +8,7 @@ import { printYaml } from '../../utils/output.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { connectPowerSync, waitForIdleDataFlow } from '../../powersync/runtime.js';
 import { syncNoteTokenIndex } from '../../powersync/tokenIndex.js';
-import { createNote, getNote, getNoteDetail, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, searchNotes, softDeleteNote, validateTagsForCreate, } from './repo.js';
+import { createNote, getNote, getNoteDetails, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
 import { parseCreatedAtRange } from './searchTime.js';
 function parseSyncTimeoutMs(value) {
     if (typeof value !== 'string') {
@@ -61,6 +61,23 @@ async function parseStringListInput(value, optionName) {
     const raw = await readStringOrFile(value);
     return parseListInput(raw, optionName);
 }
+async function parseTargetNoteIds(idArg, idsOption, commandName) {
+    const merged = [];
+    const idFromArg = typeof idArg === 'string' ? idArg.trim() : '';
+    if (idFromArg) {
+        merged.push(idFromArg);
+    }
+    if (typeof idsOption === 'string') {
+        merged.push(...(await parseStringListInput(idsOption, '--ids')));
+    }
+    const ids = Array.from(new Set(merged
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0)));
+    if (ids.length === 0) {
+        throw new DinoxError(`Provide <id> or --ids for ${commandName}`);
+    }
+    return ids;
+}
 async function syncBeforeNoteCommand(db, offline, timeoutMs) {
     if (offline) {
         return;
@@ -154,8 +171,9 @@ export function registerNoteCommands(program) {
     note
         .command('detail')
         .description('Get full note details by id')
-        .argument('<id>', 'note id')
-        .action(async (id, _options, command) => {
+        .argument('[id]', 'note id')
+        .option('--ids <string|@file>', 'note ids (JSON array or comma/newline-separated) for batch read')
+        .action(async (id, options, command) => {
         const globals = command.optsWithGlobals?.() ?? {};
         const offline = Boolean(globals.offline);
         const config = resolveConfig(await loadConfig());
@@ -163,11 +181,22 @@ export function registerNoteCommands(program) {
         const { db } = await connectPowerSync({ config, offline, timeoutMs });
         try {
             await syncBeforeNoteCommand(db, offline, timeoutMs);
-            const note = await getNoteDetail(db, id);
-            if (!note) {
-                throw new DinoxError(`Note not found: ${id}`);
+            const ids = await parseTargetNoteIds(id, options.ids, 'detail');
+            const notes = await getNoteDetails(db, ids);
+            const foundIds = new Set(notes.map((note) => note.id));
+            const missing = ids.filter((noteId) => !foundIds.has(noteId));
+            if (missing.length > 0) {
+                if (ids.length === 1) {
+                    throw new DinoxError(`Note not found: ${missing[0]}`);
+                }
+                throw new DinoxError(`Notes not found: ${missing.join(', ')}`);
+            }
+            if (notes.length === 1) {
+                printYaml(notes[0]);
+            }
+            else {
+                printYaml(notes);
             }
-            printYaml(note);
         }
         finally {
             await db.close().catch(() => undefined);
@@ -276,4 +305,76 @@ export function registerNoteCommands(program) {
             await db.close().catch(() => undefined);
         }
     });
+    note
+        .command('update')
+        .description('Update note tags/boxes by id')
+        .argument('[id]', 'note id')
+        .option('--ids <string|@file>', 'note ids (JSON array or comma/newline-separated) for batch update')
+        .option('--tags <string|@file>', 'tag list (JSON array or comma/newline-separated)')
+        .option('--boxes <string|@file>', 'zettel box names (JSON array or comma/newline-separated)')
+        .action(async (id, options, command) => {
+        const globals = command.optsWithGlobals?.() ?? {};
+        const offline = Boolean(globals.offline);
+        const jsonOutput = Boolean(globals.json);
+        const config = resolveConfig(await loadConfig());
+        const timeoutMs = parseSyncTimeoutMs(globals.syncTimeout) ?? config.sync.timeoutMs;
+        const { db, stale } = await connectPowerSync({ config, offline, timeoutMs });
+        try {
+            await syncBeforeNoteCommand(db, offline, timeoutMs);
+            const ids = await parseTargetNoteIds(id, options.ids, 'update');
+            const hasTags = typeof options.tags === 'string';
+            const hasBoxes = typeof options.boxes === 'string';
+            if (!hasTags && !hasBoxes) {
+                throw new DinoxError('At least one option is required: --tags or --boxes');
+            }
+            const tags = hasTags
+                ? await validateTagsForUpdate(db, await parseStringListInput(options.tags, '--tags'))
+                : undefined;
+            const zettelBoxIds = hasBoxes
+                ? await resolveZettelBoxIdsForUpdate(db, await parseStringListInput(options.boxes, '--boxes'))
+                : undefined;
+            await assertNotesUpdatable(db, ids);
+            const results = [];
+            for (const targetId of ids) {
+                const result = await updateNote(db, { id: targetId, tags, zettelBoxIds });
+                results.push(result);
+            }
+            const updatedCount = results.filter((item) => item.updated).length;
+            if (!offline && !config.powersync.uploadBaseUrl) {
+                console.log('warning: upload disabled (powersync.uploadBaseUrl is unset); changes are local-only for now');
+            }
+            if (!offline) {
+                await waitForIdleDataFlow(db, Math.min(timeoutMs, 5_000));
+            }
+            const payload = {
+                ok: true,
+                total: results.length,
+                updatedCount,
+                results: results.map((item) => ({
+                    id: item.id,
+                    updated: item.updated,
+                    tags: item.tags,
+                    boxes: item.zettelBoxIds,
+                })),
+                stale: offline ? true : stale,
+            };
+            if (jsonOutput) {
+                printYaml(payload);
+            }
+            else {
+                if (results.length === 1) {
+                    console.log(results[0].updated ? 'OK' : 'No changes');
+                }
+                else {
+                    console.log(`Updated ${updatedCount}/${results.length} notes`);
+                }
+                if (stale && !offline) {
+                    console.log('warning: sync timed out; local cache may be stale');
+                }
+            }
+        }
+        finally {
+            await db.close().catch(() => undefined);
+        }
+    });
 }

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

@@ -25,33 +25,30 @@ export type SearchedNote = {
     id: string;
     title: string;
     summary: string;
-    updated_at: string | null;
-    is_del: number | null;
-    version: number | null;
+    tags: string[];
+    created_at: string | null;
     zettel_boxes: string[];
 };
-type NoteDetailRow = {
+export type NoteDetail = {
     id: string;
-    content: string | null;
-    audios: string | null;
-    images: string | null;
     created_at: string | null;
-    updated_at: string | null;
     title: string | null;
     type: string | null;
     source: string | null;
-    resource_id: string | null;
     tags: string | null;
     is_del: number | null;
     content_md: string | null;
-    format_type: string | null;
-    zettel_boxes_raw: string | null;
-};
-export type NoteDetail = Omit<NoteDetailRow, 'zettel_boxes_raw'> & {
     zettel_boxes: string[];
 };
+export type UpdateNoteResult = {
+    id: string;
+    updated: boolean;
+    tags: string[];
+    zettelBoxIds: string[];
+};
 export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
 export declare function getNote(db: AbstractPowerSyncDatabase, id: string): Promise<NoteRow | null>;
+export declare function getNoteDetails(db: AbstractPowerSyncDatabase, ids: string[]): Promise<NoteDetail[]>;
 export declare function getNoteDetail(db: AbstractPowerSyncDatabase, id: string): Promise<NoteDetail | null>;
 export declare function createNote(db: AbstractPowerSyncDatabase, input: {
     id: string;
@@ -67,7 +64,15 @@ export declare function createNote(db: AbstractPowerSyncDatabase, input: {
     id: string;
 }>;
 export declare function validateTagsForCreate(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
+export declare function validateTagsForUpdate(db: AbstractPowerSyncDatabase, requestedTags: string[]): Promise<string[]>;
+export declare function updateNote(db: AbstractPowerSyncDatabase, input: {
+    id: string;
+    tags?: string[];
+    zettelBoxIds?: string[];
+}): Promise<UpdateNoteResult>;
+export declare function assertNotesUpdatable(db: AbstractPowerSyncDatabase, noteIds: string[]): Promise<void>;
 export declare function resolveZettelBoxIdsForCreate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
 export declare function resolveZettelBoxIdsForSearch(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
+export declare function resolveZettelBoxIdsForUpdate(db: AbstractPowerSyncDatabase, requestedNames: string[]): Promise<string[]>;
 export declare function softDeleteNote(db: AbstractPowerSyncDatabase, id: string): Promise<void>;
 export {};

package/dist/commands/notes/repo.js

@@ -4,6 +4,7 @@ import { tokenizeWithJieba } from '../../utils/tokenize.js';
 import { listBoxes } from '../boxes/repo.js';
 import { listTags } from '../tags/repo.js';
 import { buildNoteSearchSqlFilter } from './searchSql.js';
+const MAX_SEARCH_SUMMARY_CHARS = 200;
 export async function searchNotes(db, query, options) {
     const normalizedQuery = query.trim();
     const tagFilter = buildTagFilter(options.tagsExpression, 'n');
@@ -74,10 +75,9 @@ export async function searchNotes(db, query, options) {
       n.title,
       n.summary,
       n.content_text,
+      n.tags,
       n.zettel_boxes,
-      n.updated_at,
-      n.is_del,
-      n.version
+      n.created_at
     FROM c_note n
     WHERE ${whereClauses.join('\n      AND ')}
     ORDER BY COALESCE(n.updated_at, n.created_at) DESC
@@ -109,10 +109,9 @@ async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, ze
       n.title,
       n.summary,
       n.content_text,
+      n.tags,
       n.zettel_boxes,
-      n.updated_at,
-      n.is_del,
-      n.version
+      n.created_at
     FROM note_local_fts f
     JOIN c_note n ON n.id = f.note_id
     WHERE ${whereClauses.join('\n      AND ')}
@@ -131,9 +130,8 @@ async function enrichSearchRows(db, rows) {
             id: row.id,
             title: row.title?.trim() ?? '',
             summary,
-            updated_at: row.updated_at,
-            is_del: row.is_del,
-            version: row.version,
+            tags: parseStoredTags(row.tags),
+            created_at: row.created_at,
             zettel_boxes: zettelBoxes,
         };
     });
@@ -141,9 +139,16 @@ async function enrichSearchRows(db, rows) {
 function resolveSummary(summary, contentText) {
     const summaryValue = summary?.trim() ?? '';
     if (summaryValue.length > 0) {
-        return summaryValue;
+        return truncateSearchSummary(summaryValue);
     }
-    return contentText?.trim() ?? '';
+    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('');
 }
 function parseZettelBoxIds(raw) {
     const value = raw?.trim();
@@ -445,53 +450,73 @@ export async function getNote(db, id) {
     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;
-    }
+function mapNoteDetailRow(note, boxNameMap) {
     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 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,
+        title,
+        type,
+        source,
+        tags,
+        is_del,
+        content_md,
+        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 createNote(db, input) {
     const userId = input.userId.trim();
     if (!userId) {
@@ -585,13 +610,23 @@ function normalizeLookupKey(value) {
     return value.trim().toLowerCase();
 }
 function buildZettelBoxRetryQuestion(intent, type) {
-    const command = intent === 'search' ? 'dino note search' : 'dino note create';
+    const command = intent === 'search'
+        ? 'dino note search'
+        : intent === 'update'
+            ? 'dino note update'
+            : 'dino note create';
     if (type === 'ambiguous') {
         return `Do you want to specify unique box names (or IDs) and retry \`${command}\`?`;
     }
     return `Do you want to add these missing boxes and retry \`${command}\`?`;
 }
 export async function validateTagsForCreate(db, requestedTags) {
+    return validateTagsForWrite(db, requestedTags, 'dino note create');
+}
+export async function validateTagsForUpdate(db, requestedTags) {
+    return validateTagsForWrite(db, requestedTags, 'dino note update');
+}
+async function validateTagsForWrite(db, requestedTags, retryCommand) {
     if (requestedTags.length === 0) {
         return [];
     }
@@ -627,18 +662,166 @@ export async function validateTagsForCreate(db, requestedTags) {
                 missing,
                 knownCount: tags.length,
                 knownSample: tags.slice(0, 20),
-                question: 'Do you want to add these missing tags and retry `dino note create`?',
+                question: `Do you want to add these missing tags and retry \`${retryCommand}\`?`,
             },
         });
     }
     return resolved;
 }
+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);
+    if (!shouldUpdateTags && !shouldUpdateBoxes) {
+        throw new DinoxError('At least one field is required: tags or boxes');
+    }
+    const existing = await db.getOptional(`
+    SELECT id, tags, zettel_boxes, is_del
+    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 nextTags = shouldUpdateTags ? normalizeDistinctStrings(input.tags) : currentTags;
+    const nextZettelBoxIds = shouldUpdateBoxes ? normalizeDistinctStrings(input.zettelBoxIds) : currentZettelBoxIds;
+    const tagsChanged = shouldUpdateTags && !sameTagSet(currentTags, nextTags);
+    const boxesChanged = shouldUpdateBoxes && !sameStringSet(currentZettelBoxIds, nextZettelBoxIds);
+    if (!tagsChanged && !boxesChanged) {
+        return {
+            id,
+            updated: false,
+            tags: currentTags,
+            zettelBoxIds: currentZettelBoxIds,
+        };
+    }
+    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));
+    }
+    setParts.push('updated_at = ?');
+    params.push(nowIsoUtc());
+    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,
+        tags: nextTags,
+        zettelBoxIds: nextZettelBoxIds,
+    };
+}
+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');
+}
 async function resolveZettelBoxIdsByName(db, requestedNames, intent) {
     if (requestedNames.length === 0) {
         return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {