@dinoxx/dinox-cli 1.1.1 → 2.1.0

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

@@ -0,0 +1,187 @@
+// Tag validation and zettel box name/path resolution for note writes and search.
+import { DinoxError } from '../../../utils/errors.js';
+import { canonicalizeBoxPath, listBoxes } from '../../boxes/repo.js';
+import { listTags } from '../../tags/repo.js';
+import { normalizeLookupKey } from './shared.js';
+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 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;
+}

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

@@ -0,0 +1,42 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type SearchNotesOptions, type SearchedNote } from './shared.js';
+/**
+ * JSON-safe note-search request. Box *names/paths* are carried (not resolved ids) so the
+ * same payload can be executed either in-process or sent to the daemon over the wire;
+ * id resolution happens inside {@link executeNoteSearch} against whichever db runs it.
+ */
+export type NoteSearchExecuteParams = {
+    keyword: string;
+    includeDeleted: boolean;
+    tagsExpression?: string;
+    createdAtFrom?: string;
+    createdAtTo?: string;
+    starred?: boolean;
+    boxValues: string[];
+    matchEmptyZettelBoxes: boolean;
+    sqlExpression?: string;
+    limit?: number;
+    offset?: number;
+};
+export type NoteSearchExecuteResult = {
+    rows: SearchedNote[];
+    totalCount: number;
+    /** Resolved zettel-box ids, surfaced so callers can echo them in response metadata. */
+    zettelBoxIds: string[];
+};
+/**
+ * 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 declare function executeNoteSearch(db: AbstractPowerSyncDatabase, params: NoteSearchExecuteParams): Promise<NoteSearchExecuteResult>;
+export declare function searchNotes(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesOptions): Promise<SearchedNote[]>;
+type SearchNotesPageOptions = SearchNotesOptions & {
+    limit?: number;
+    offset?: number;
+};
+type SearchNotesPageResult = {
+    rows: SearchedNote[];
+    totalCount: number;
+};
+export declare function searchNotesPage(db: AbstractPowerSyncDatabase, query: string, options: SearchNotesPageOptions): Promise<SearchNotesPageResult>;
+export {};