@dinoxx/dinox-cli 1.1.1 → 2.1.0

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

@@ -1,5 +1,5 @@
 import type { SearchedNote } from './repo.js';
-export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "boxes", "is_starred"];
+export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "starred_at", "boxes", "is_starred"];
 export type NoteSearchField = (typeof NOTE_SEARCH_FIELDS)[number];
 export type NoteSearchResultItem = {
     id?: string;
@@ -7,6 +7,7 @@ export type NoteSearchResultItem = {
     summary?: string;
     tags?: string[];
     created_at?: string | null;
+    starred_at?: string | null;
     is_starred?: boolean;
     boxes?: string[];
 };

package/dist/commands/notes/searchOutput.js

@@ -1,5 +1,5 @@
 import { DinoxError } from '../../utils/errors.js';
-export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'];
+export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'starred_at', 'boxes', 'is_starred'];
 const NOTE_SEARCH_FIELD_SET = new Set(NOTE_SEARCH_FIELDS);
 export function parseNoteSearchFields(value, optionName) {
     if (value === undefined || value === null || value === '') {
@@ -35,6 +35,7 @@ export function projectNoteSearchFields(notes, fields) {
             summary: note.summary,
             tags: note.tags,
             created_at: note.created_at,
+            starred_at: note.starred_at,
             is_starred: note.is_starred,
             boxes: note.zettel_boxes,
         }));

package/dist/commands/notes/searchSql.js

@@ -32,8 +32,14 @@ const SCALAR_FIELD_COLUMNS = {
     summary: 'summary',
     created_at: 'created_at',
     type: 'type',
-    is_starred: 'is_starred',
+    is_starred: 'starred_at',
 };
+function scalarFieldSql(field, noteAlias) {
+    if (field === 'is_starred') {
+        return `(CASE WHEN ${noteAlias}.starred_at IS NOT NULL THEN 1 ELSE 0 END)`;
+    }
+    return `${noteAlias}.${SCALAR_FIELD_COLUMNS[field]}`;
+}
 export async function buildNoteSearchSqlFilter(options) {
     const expression = options.expression?.trim() ?? '';
     if (!expression) {
@@ -527,7 +533,7 @@ function compileComparison(node, noteAlias, params, zettelBoxIdByName) {
     `;
         return node.operator === '!=' ? `NOT (${existsSql})` : existsSql;
     }
-    const column = `${noteAlias}.${SCALAR_FIELD_COLUMNS[node.field]}`;
+    const column = scalarFieldSql(node.field, noteAlias);
     params.push(node.value);
     if (node.operator === 'LIKE' || node.operator === 'NOT LIKE') {
         return `(${column} IS NOT NULL AND ${column} ${node.operator} ?)`;
@@ -586,7 +592,7 @@ function compileInCondition(node, noteAlias, params, zettelBoxIdByName) {
     if (values.length === 0) {
         throw new Error('IN list cannot be empty');
     }
-    const column = `${noteAlias}.${SCALAR_FIELD_COLUMNS[node.field]}`;
+    const column = scalarFieldSql(node.field, noteAlias);
     const placeholders = values.map(() => '?').join(', ');
     params.push(...values);
     if (node.not) {

package/dist/commands/prompt/index.d.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
 import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare function parsePromptTextInput(value: unknown): Promise<string>;
 export declare const promptCommandGroup: CommandGroupDescriptor;
 export declare function registerPromptCommands(program: Command): void;

package/dist/commands/prompt/index.js

@@ -1,31 +1,43 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { readStringOrFile } from '../../utils/argValue.js';
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { DinoxError } from '../../utils/errors.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { buildPromptAddDryRunPreview } from '../writeDryRun.js';
-import { printDryRunPreview } from '../../utils/dryRun.js';
-import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { addPrompt, inspectAddPrompt, listPrompts } from './repo.js';
 const PROMPT_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
+export async function parsePromptTextInput(value) {
+    if (typeof value !== 'string' || !value) {
+        return '';
+    }
+    return (await readStringOrFile(value)).trim();
+}
 async function runPromptList(context) {
     await withCommandRuntime(context, async (runtime) => {
         const identity = await resolveAuthIdentity(runtime.config);
         await syncBeforeCommand(runtime, { syncTokenIndex: true });
-        printSuccess((await listPrompts(runtime.db, { userId: identity.userId })).map((prompt) => ({
+        const prompts = (await listPrompts(runtime.db, { userId: identity.userId })).map((prompt) => ({
             name: prompt.name,
             prompt: prompt.cmd,
-        })));
+        }));
+        printSuccess({
+            stale: commandStale(runtime),
+            count: prompts.length,
+            prompts,
+        });
     });
 }
 async function runPromptAdd(context) {
     const name = typeof context.options.name === 'string' ? context.options.name.trim() : '';
-    const cmd = typeof context.options.prompt === 'string' ? context.options.prompt.trim() : '';
+    const cmd = await parsePromptTextInput(context.options.prompt);
     if (!name) {
-        throw new DinoxError('Prompt name is required. Use `dino prompt add --name <name> --prompt <text>`.');
+        throw new DinoxError('Prompt name is required. Use `dino prompt add --name <name> --prompt <string|@file>`.');
     }
     if (!cmd) {
-        throw new DinoxError('Prompt text is required. Use `dino prompt add --name <name> --prompt <text>`.');
+        throw new DinoxError('Prompt text is required. Use `dino prompt add --name <name> --prompt <string|@file>`.');
     }
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
     await withCommandRuntime(context, async (runtime) => {
@@ -40,7 +52,7 @@ async function runPromptAdd(context) {
                     cmd,
                     userId: identity.userId,
                 })),
-            }));
+            }), runtime);
             return;
         }
         const result = await addPrompt(runtime.db, {
@@ -80,7 +92,7 @@ export const promptCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Prompt list payload',
-                    fields: ['name', 'prompt'],
+                    fields: ['stale', 'count', 'prompts.name', 'prompts.prompt'],
                 },
                 examples: ['dino prompt list --format json'],
             },
@@ -91,7 +103,7 @@ export const promptCommandGroup = {
             description: 'Create a prompt template, restoring a deleted prompt when possible',
             options: [
                 { flags: '--name <string>', description: 'Prompt name', required: true, type: 'string' },
-                { flags: '--prompt <string>', description: 'Prompt text', required: true, type: 'string' },
+                { flags: '--prompt <string|@file>', description: 'Prompt text or @file containing prompt text', required: true, type: 'string' },
                 { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
@@ -104,7 +116,10 @@ export const promptCommandGroup = {
                     summary: 'Prompt creation acknowledgement',
                     fields: ['id', 'name', 'prompt', 'restored', 'stale'],
                 },
-                examples: ['dino prompt add --name "周报助手" --prompt "请基于本周笔记输出一份简洁周报" --format json --dry-run'],
+                examples: [
+                    'dino prompt add --name "周报助手" --prompt "请基于本周笔记输出一份简洁周报" --format json --dry-run',
+                    'dino prompt add --name "周报助手" --prompt @/tmp/weekly-prompt.txt --format json --dry-run',
+                ],
             },
             action: runPromptAdd,
         },

package/dist/commands/savedViews/index.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+import { type SavedViewConfig, type SavedViewFilter } from './model.js';
+export declare function parseSavedViewFilterOption(value: unknown): Promise<SavedViewFilter | undefined>;
+export declare function parseSavedViewConfigOption(value: unknown): Promise<SavedViewConfig | undefined>;
+export declare const savedViewCommandGroup: CommandGroupDescriptor;
+export declare function registerSavedViewCommands(program: Command): void;

package/dist/commands/savedViews/index.js

@@ -0,0 +1,458 @@
+import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { readStringOrFile } from '../../utils/argValue.js';
+import { printDryRunPreview } from '../../utils/dryRun.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS, } from '../schema/globalOptions.js';
+import { WRITE_DURABILITY_OPTION } from '../writeDurability.js';
+import { validateSavedViewConfig, validateSavedViewFilter, } from './model.js';
+import { countSavedViewRows, createSavedView, deleteSavedView, getSavedView, getSavedViewFieldCatalog, inspectCreateSavedView, inspectDeleteSavedView, inspectUpdateSavedView, listSavedViews, querySavedView, updateSavedView, } from './repo.js';
+const VIEW_GLOBAL_OPTIONS = [
+    ...FORMAT_OPTIONS,
+    ...OFFLINE_OPTIONS,
+    ...REQUIRE_SYNC_OPTIONS,
+    ...SYNC_TIMEOUT_OPTIONS,
+];
+function parseIntegerOption(value) {
+    const normalized = value.trim();
+    if (!/^-?\d+$/.test(normalized)) {
+        throw new DinoxError('Expected an integer', { code: 'USAGE_ERROR' });
+    }
+    const parsed = Number(normalized);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new DinoxError('Expected a safe integer', { code: 'USAGE_ERROR' });
+    }
+    return parsed;
+}
+function parsePositiveIntegerOption(value) {
+    const parsed = parseIntegerOption(value);
+    if (parsed <= 0)
+        throw new DinoxError('Expected a positive integer', { code: 'USAGE_ERROR' });
+    return parsed;
+}
+function parseNonNegativeIntegerOption(value) {
+    const parsed = parseIntegerOption(value);
+    if (parsed < 0)
+        throw new DinoxError('Expected a non-negative integer', { code: 'USAGE_ERROR' });
+    return parsed;
+}
+async function readJsonOption(value, label) {
+    let raw;
+    try {
+        raw = await readStringOrFile(value);
+    }
+    catch (error) {
+        throw new DinoxError(`Failed to read ${label}`, { code: 'USAGE_ERROR', cause: error });
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new DinoxError(`${label} must be valid JSON`, {
+            code: 'USAGE_ERROR',
+            cause: error,
+            suggestion: `Pass inline JSON or use @file. See \`dino schema view.create --format json\`.`,
+        });
+    }
+}
+export async function parseSavedViewFilterOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new DinoxError('--filter requires inline JSON or @file', { code: 'USAGE_ERROR' });
+    }
+    return validateSavedViewFilter(await readJsonOption(value, 'Saved view filter'));
+}
+export async function parseSavedViewConfigOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new DinoxError('--config requires inline JSON or @file', { code: 'USAGE_ERROR' });
+    }
+    return validateSavedViewConfig(await readJsonOption(value, 'Saved view config'));
+}
+function requiredViewId(context) {
+    const id = context.args.id?.trim();
+    if (!id)
+        throw new DinoxError('Saved view id is required', { code: 'USAGE_ERROR' });
+    return id;
+}
+function assertExclusiveOptions(options) {
+    const conflicts = [
+        [Boolean(options.emoji !== undefined && options.clearEmoji), '--emoji cannot be used with --clear-emoji'],
+        [Boolean(options.templateId !== undefined && options.clearTemplate), '--template-id cannot be used with --clear-template'],
+        [Boolean(options.groupId !== undefined && options.clearGroup), '--group-id cannot be used with --clear-group'],
+        [Boolean(options.sortRank !== undefined && options.clearSortRank), '--sort-rank cannot be used with --clear-sort-rank'],
+        [Boolean(options.pinnedAt !== undefined && options.unpin), '--pinned-at cannot be used with --unpin'],
+    ];
+    const conflict = conflicts.find(([active]) => active);
+    if (conflict)
+        throw new DinoxError(conflict[1], { code: 'USAGE_ERROR' });
+}
+async function runViewList(context) {
+    const limit = context.options.limit;
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const views = await listSavedViews(runtime.db, { userId: identity.userId, limit });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), count: views.length, views });
+            return;
+        }
+        for (const view of views) {
+            printHumanReadableLine(`${view.id}\t${view.emoji ?? ''}\t${view.name}${view.valid ? '' : '\t[invalid]'}`);
+        }
+        if (views.length === 0)
+            printHumanReadableLine('No saved views found.');
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runViewGet(context) {
+    const id = requiredViewId(context);
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const view = await getSavedView(runtime.db, { id, userId: identity.userId });
+        printSuccess({ ok: true, stale: commandStale(runtime), view });
+    });
+}
+async function runViewFields(context) {
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const fields = await getSavedViewFieldCatalog(runtime.db, identity.userId);
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), count: fields.length, fields });
+            return;
+        }
+        for (const field of fields) {
+            printHumanReadableLine(`${field.field}\t${field.propertyType}\t${field.sortable ? 'sortable' : 'not-sortable'}\t${field.available ? 'available' : 'unavailable'}\t${field.name}`);
+        }
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runViewQuery(context) {
+    const viewId = requiredViewId(context);
+    const limit = context.options.limit;
+    const offset = context.options.offset;
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const result = await querySavedView(runtime.db, {
+            viewId,
+            userId: identity.userId,
+            limit,
+            offset,
+        });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+            return;
+        }
+        for (const row of result.rows) {
+            printHumanReadableLine(`${row.id}\t${row.title ?? ''}`);
+        }
+        printHumanReadableLine(`Showing ${result.rows.length} of ${result.totalCount} matching notes.`);
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runViewCount(context) {
+    const viewId = requiredViewId(context);
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const totalCount = await countSavedViewRows(runtime.db, { viewId, userId: identity.userId });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), viewId, totalCount });
+            return;
+        }
+        printHumanReadableLine(String(totalCount));
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runViewCreate(context) {
+    const options = context.options;
+    const name = options.name?.trim() ?? '';
+    if (!name)
+        throw new DinoxError('Saved view name is required. Use --name <string>.', { code: 'USAGE_ERROR' });
+    const [filter, config] = await Promise.all([
+        parseSavedViewFilterOption(options.filter),
+        parseSavedViewConfigOption(options.config),
+    ]);
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const input = {
+            userId: identity.userId,
+            name,
+            emoji: options.emoji,
+            filter,
+            config,
+            templateId: options.templateId,
+            groupId: options.groupId,
+            sortRank: options.sortRank,
+            pinnedAt: options.pinnedAt,
+        };
+        if (options.dryRun) {
+            const plan = await inspectCreateSavedView(runtime.db, input);
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino view create',
+                action: 'create_saved_view',
+                risk: 'write',
+                summary: `Create saved view "${name}".`,
+                inputs: { name, ...(filter ? { filter } : {}), ...(config ? { config } : {}) },
+                changes: plan.changes,
+            }, runtime);
+            return;
+        }
+        const view = await createSavedView(runtime.db, input);
+        const receipt = await waitForMutationUpload(runtime, { durability: options.durability });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), view, ...receipt });
+            return;
+        }
+        printHumanReadableLine(view.id);
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runViewUpdate(context) {
+    const id = requiredViewId(context);
+    const options = context.options;
+    assertExclusiveOptions(options);
+    const [filter, config] = await Promise.all([
+        parseSavedViewFilterOption(options.filter),
+        parseSavedViewConfigOption(options.config),
+    ]);
+    const inputPatch = {
+        ...(options.name === undefined ? {} : { name: options.name }),
+        ...(options.clearEmoji ? { emoji: null } : options.emoji === undefined ? {} : { emoji: options.emoji }),
+        ...(filter === undefined ? {} : { filter }),
+        ...(config === undefined ? {} : { config }),
+        ...(options.clearTemplate ? { templateId: null } : options.templateId === undefined ? {} : { templateId: options.templateId }),
+        ...(options.clearGroup ? { groupId: null } : options.groupId === undefined ? {} : { groupId: options.groupId }),
+        ...(options.clearSortRank ? { sortRank: null } : options.sortRank === undefined ? {} : { sortRank: options.sortRank }),
+        ...(options.unpin ? { pinnedAt: null } : options.pinnedAt === undefined ? {} : { pinnedAt: options.pinnedAt }),
+    };
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const input = { id, userId: identity.userId, ...inputPatch };
+        if (options.dryRun) {
+            const plan = await inspectUpdateSavedView(runtime.db, input);
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino view update',
+                action: 'update_saved_view',
+                risk: 'write',
+                summary: `Update saved view "${plan.target?.name ?? id}".`,
+                targets: plan.target ? [{ id: plan.target.id, name: plan.target.name }] : undefined,
+                changes: plan.changes,
+            }, runtime);
+            return;
+        }
+        const view = await updateSavedView(runtime.db, input);
+        const receipt = await waitForMutationUpload(runtime, { durability: options.durability });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), view, ...receipt });
+            return;
+        }
+        printHumanReadableLine(view.id);
+        printStaleCacheWarning(runtime);
+    });
+}
+async function runViewDelete(context) {
+    const id = requiredViewId(context);
+    const options = context.options;
+    await withCommandRuntime(context, async (runtime) => {
+        const identity = await resolveAuthIdentity(runtime.config);
+        await syncBeforeCommand(runtime);
+        const input = { id, userId: identity.userId };
+        if (options.dryRun) {
+            const plan = await inspectDeleteSavedView(runtime.db, input);
+            printDryRunPreview({
+                dry_run: true,
+                command: 'dino view delete',
+                action: 'delete_saved_view',
+                risk: 'write',
+                summary: `Soft-delete saved view "${plan.target?.name ?? id}".`,
+                targets: plan.target ? [{ id: plan.target.id, name: plan.target.name }] : undefined,
+                changes: plan.changes,
+            }, runtime);
+            return;
+        }
+        const view = await deleteSavedView(runtime.db, input);
+        const receipt = await waitForMutationUpload(runtime, { durability: options.durability });
+        if (getRequestedStructuredOutputFormat()) {
+            printSuccess({ ok: true, stale: commandStale(runtime), deleted: true, view, ...receipt });
+            return;
+        }
+        printHumanReadableLine(`Deleted ${view.id}`);
+        printStaleCacheWarning(runtime);
+    });
+}
+export const savedViewCommandGroup = {
+    name: 'view',
+    description: 'Manage and query saved table views',
+    commands: [
+        {
+            name: 'list',
+            description: 'List active saved table views',
+            options: [
+                { flags: '--limit <n>', description: 'Maximum returned views (1-5000)', parser: parsePositiveIntegerOption, type: 'number', defaultValue: 200 },
+            ],
+            schema: {
+                path: 'view.list',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Saved view catalog', fields: ['stale', 'count', 'views'] },
+                examples: ['dino view list --format json'],
+            },
+            action: runViewList,
+        },
+        {
+            name: 'get',
+            description: 'Get one saved view definition',
+            arguments: [{ syntax: '<id>', description: 'Saved view id' }],
+            schema: {
+                path: 'view.get',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Canonical saved view definition', fields: ['stale', 'view'] },
+                examples: ['dino view get <id> --format json'],
+            },
+            action: runViewGet,
+        },
+        {
+            name: 'fields',
+            description: 'List system and property fields available to saved views',
+            schema: {
+                path: 'view.fields',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Saved view field catalog and filter semantics', fields: ['stale', 'count', 'fields'] },
+                examples: ['dino view fields --format json'],
+            },
+            action: runViewFields,
+        },
+        {
+            name: 'query',
+            description: 'Query notes through a saved view filter and sort definition',
+            arguments: [{ syntax: '<id>', description: 'Saved view id' }],
+            options: [
+                { flags: '--limit <n>', description: 'Maximum returned notes (1-500)', parser: parsePositiveIntegerOption, type: 'number', defaultValue: 100 },
+                { flags: '--offset <n>', description: 'Result offset for pagination', parser: parseNonNegativeIntegerOption, type: 'number', defaultValue: 0 },
+            ],
+            schema: {
+                path: 'view.query',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Saved view page with projected configured columns', fields: ['stale', 'view', 'columns', 'totalCount', 'offset', 'limit', 'nextOffset', 'hasMore', 'rows'] },
+                examples: ['dino view query <id> --limit 50 --offset 0 --format json'],
+            },
+            action: runViewQuery,
+        },
+        {
+            name: 'count',
+            description: 'Count notes matching a saved view',
+            arguments: [{ syntax: '<id>', description: 'Saved view id' }],
+            schema: {
+                path: 'view.count',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Saved view matching note count', fields: ['stale', 'viewId', 'totalCount'] },
+                examples: ['dino view count <id> --format json'],
+            },
+            action: runViewCount,
+        },
+        {
+            name: 'create',
+            description: 'Create a canonical saved table view',
+            options: [
+                { flags: '--name <string>', description: 'Saved view name', required: true, type: 'string' },
+                { flags: '--emoji <string>', description: 'Optional emoji or short icon text', type: 'string' },
+                { flags: '--filter <json|@file>', description: 'Canonical version 1 saved view filter JSON; defaults to no filter', type: 'string' },
+                { flags: '--config <json|@file>', description: 'Canonical version 1 saved view config JSON; defaults to title + updated_at', type: 'string' },
+                { flags: '--template-id <id>', description: 'Optional note template id associated with the view', type: 'string' },
+                { flags: '--group-id <id>', description: 'Optional saved view group id', type: 'string' },
+                { flags: '--sort-rank <n>', description: 'Explicit catalog sort rank', parser: parseIntegerOption, type: 'number' },
+                { flags: '--pinned-at <timestamp>', description: 'Pinned timestamp', type: 'string' },
+                WRITE_DURABILITY_OPTION,
+                { flags: '--dry-run', description: 'Validate and preview the view without writing', type: 'boolean' },
+            ],
+            schema: {
+                path: 'view.create',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Created saved view definition or dry-run plan', fields: ['view', 'durability', 'upload_queue_remaining', 'stale'] },
+                examples: [
+                    'dino view create --name "Recent notes" --format json --dry-run',
+                    'dino view create --name "Active projects" --filter @filter.json --config @config.json --format json',
+                ],
+            },
+            action: runViewCreate,
+        },
+        {
+            name: 'update',
+            description: 'Update a canonical saved table view',
+            arguments: [{ syntax: '<id>', description: 'Saved view id' }],
+            options: [
+                { flags: '--name <string>', description: 'Replace the saved view name', type: 'string' },
+                { flags: '--emoji <string>', description: 'Replace emoji or short icon text', type: 'string' },
+                { flags: '--clear-emoji', description: 'Clear the saved view emoji', type: 'boolean' },
+                { flags: '--filter <json|@file>', description: 'Replace the canonical version 1 filter JSON', type: 'string' },
+                { flags: '--config <json|@file>', description: 'Replace the canonical version 1 config JSON', type: 'string' },
+                { flags: '--template-id <id>', description: 'Replace the associated note template id', type: 'string' },
+                { flags: '--clear-template', description: 'Clear the associated note template id', type: 'boolean' },
+                { flags: '--group-id <id>', description: 'Replace the saved view group id', type: 'string' },
+                { flags: '--clear-group', description: 'Clear the saved view group id', type: 'boolean' },
+                { flags: '--sort-rank <n>', description: 'Replace the catalog sort rank', parser: parseIntegerOption, type: 'number' },
+                { flags: '--clear-sort-rank', description: 'Clear the catalog sort rank', type: 'boolean' },
+                { flags: '--pinned-at <timestamp>', description: 'Replace the pinned timestamp', type: 'string' },
+                { flags: '--unpin', description: 'Clear the pinned timestamp', type: 'boolean' },
+                WRITE_DURABILITY_OPTION,
+                { flags: '--dry-run', description: 'Validate and preview the update without writing', type: 'boolean' },
+            ],
+            schema: {
+                path: 'view.update',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Updated saved view definition or dry-run plan', fields: ['view', 'durability', 'upload_queue_remaining', 'stale'] },
+                examples: [
+                    'dino view update <id> --filter @filter.json --format json --dry-run',
+                    'dino view update <id> --name "Priority work" --unpin --format json',
+                ],
+            },
+            action: runViewUpdate,
+        },
+        {
+            name: 'delete',
+            description: 'Soft-delete a saved view',
+            arguments: [{ syntax: '<id>', description: 'Saved view id' }],
+            options: [
+                WRITE_DURABILITY_OPTION,
+                { flags: '--dry-run', description: 'Preview the soft delete without writing', type: 'boolean' },
+            ],
+            schema: {
+                path: 'view.delete',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: VIEW_GLOBAL_OPTIONS,
+                output: { type: 'structured', summary: 'Saved view soft-delete acknowledgement or dry-run plan', fields: ['deleted', 'view', 'durability', 'upload_queue_remaining', 'stale'] },
+                examples: ['dino view delete <id> --format json --dry-run'],
+            },
+            action: runViewDelete,
+        },
+    ],
+};
+export function registerSavedViewCommands(program) {
+    registerCommandGroup(program, savedViewCommandGroup);
+}