@lifestreamdynamics/vault-cli 1.1.0 → 1.2.0

package/dist/commands/ai.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerAiCommands(program: Command): void;

package/dist/commands/ai.js

@@ -0,0 +1,111 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerAiCommands(program) {
+    const ai = program.command('ai').description('AI chat and document summarization');
+    const sessions = ai.command('sessions').description('AI chat session management');
+    addGlobalFlags(sessions.command('list')
+        .description('List AI chat sessions'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching AI sessions...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.ai.listSessions();
+            out.stopSpinner();
+            out.list(list.map(s => ({ id: s.id, title: s.title ?? 'Untitled', createdAt: s.createdAt })), {
+                emptyMessage: 'No AI sessions found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'title', header: 'Title' },
+                    { key: 'createdAt', header: 'Created' },
+                ],
+                textFn: (s) => `${chalk.cyan(String(s.id))} — ${String(s.title)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch AI sessions');
+        }
+    });
+    addGlobalFlags(sessions.command('get')
+        .description('Get an AI chat session with messages')
+        .argument('<sessionId>', 'Session ID'))
+        .action(async (sessionId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching AI session...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.ai.getSession(sessionId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Session: ${chalk.cyan(result.session.id)}\n`);
+                process.stdout.write(`Title: ${result.session.title ?? 'Untitled'}\n\n`);
+                for (const msg of result.messages ?? []) {
+                    const role = msg.role === 'assistant' ? chalk.green('AI') : chalk.blue('You');
+                    process.stdout.write(`${role}: ${String(msg.content ?? '')}\n\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch AI session');
+        }
+    });
+    addGlobalFlags(sessions.command('delete')
+        .description('Delete an AI chat session')
+        .argument('<sessionId>', 'Session ID'))
+        .action(async (sessionId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Deleting AI session...');
+        try {
+            const client = await getClientAsync();
+            await client.ai.deleteSession(sessionId);
+            out.success('Session deleted', { id: sessionId });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete AI session');
+        }
+    });
+    addGlobalFlags(ai.command('chat')
+        .description('Send a message in an AI chat session')
+        .argument('<sessionId>', 'Session ID')
+        .argument('<message>', 'Message to send'))
+        .action(async (sessionId, message, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Sending message...');
+        try {
+            const client = await getClientAsync();
+            const response = await client.ai.chat({ message, sessionId });
+            out.stopSpinner();
+            process.stdout.write(String(response.content ?? JSON.stringify(response)) + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to send AI message');
+        }
+    });
+    addGlobalFlags(ai.command('summarize')
+        .description('Summarize a document with AI')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<docPath>', 'Document path'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Summarizing document...');
+        try {
+            const client = await getClientAsync();
+            const summary = await client.ai.summarize(vaultId, docPath);
+            out.stopSpinner();
+            process.stdout.write(String(summary.summary ?? JSON.stringify(summary)) + '\n');
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to summarize document');
+        }
+    });
+}

package/dist/commands/analytics.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerAnalyticsCommands(program: Command): void;

package/dist/commands/analytics.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerAnalyticsCommands(program) {
+    const analytics = program.command('analytics').description('Analytics for published documents and share links');
+    addGlobalFlags(analytics.command('published')
+        .description('Summary of published document views'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching analytics...');
+        try {
+            const client = await getClientAsync();
+            const summary = await client.analytics.getPublishedSummary();
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(summary, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Total published: ${summary.totalPublished}, Total views: ${summary.totalViews}\n\n`);
+                out.list(summary.documents.map(d => ({ slug: d.slug, title: d.title ?? '', viewCount: d.viewCount, publishedAt: d.publishedAt })), {
+                    emptyMessage: 'No published documents.',
+                    columns: [
+                        { key: 'slug', header: 'Slug' },
+                        { key: 'title', header: 'Title' },
+                        { key: 'viewCount', header: 'Views' },
+                        { key: 'publishedAt', header: 'Published' },
+                    ],
+                    textFn: (d) => `${chalk.cyan(String(d.slug))} — ${String(d.viewCount)} views`,
+                });
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch analytics');
+        }
+    });
+    addGlobalFlags(analytics.command('share')
+        .description('Analytics for a share link')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<shareId>', 'Share ID'))
+        .action(async (vaultId, shareId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching share analytics...');
+        try {
+            const client = await getClientAsync();
+            const data = await client.analytics.getShareAnalytics(vaultId, shareId);
+            out.stopSpinner();
+            out.record({
+                shareId: data.shareId,
+                viewCount: data.viewCount,
+                uniqueViewers: data.uniqueViewers,
+                lastViewedAt: data.lastViewedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch share analytics');
+        }
+    });
+    addGlobalFlags(analytics.command('doc')
+        .description('Analytics for a published document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<publishedDocId>', 'Published document ID'))
+        .action(async (vaultId, publishedDocId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching document analytics...');
+        try {
+            const client = await getClientAsync();
+            const data = await client.analytics.getPublishedDocAnalytics(vaultId, publishedDocId);
+            out.stopSpinner();
+            out.record({
+                publishedDocId: data.publishedDocId,
+                viewCount: data.viewCount,
+                uniqueViewers: data.uniqueViewers,
+                lastViewedAt: data.lastViewedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch document analytics');
+        }
+    });
+}

package/dist/commands/calendar.js

@@ -154,6 +154,59 @@ export function registerCalendarCommands(program) {
             handleError(out, err, 'Calendar events failed');
         }
     });
+    addGlobalFlags(calendar.command('agenda')
+        .description('View due-date agenda grouped by time period')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--status <status>', 'Filter by status')
+        .option('--range <range>', 'Time range (e.g., week, month)')
+        .option('--group-by <groupBy>', 'Group by field'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching agenda...');
+        try {
+            const client = await getClientAsync();
+            const agenda = await client.calendar.getAgenda(vaultId, {
+                status: _opts.status,
+                range: _opts.range,
+                groupBy: _opts.groupBy,
+            });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(agenda, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Total: ${agenda.total} items\n\n`);
+                for (const group of agenda.groups) {
+                    process.stdout.write(`${chalk.bold(group.label)}\n`);
+                    for (const item of group.items) {
+                        process.stdout.write(`  ${chalk.cyan(item.path ?? '')} — due: ${String(item.dueAt ?? 'N/A')}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch agenda');
+        }
+    });
+    addGlobalFlags(calendar.command('ical')
+        .description('Output iCal feed for a vault to stdout')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--include <types>', 'Types to include'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        try {
+            const client = await getClientAsync();
+            const ical = await client.calendar.getIcalFeed(vaultId, {
+                include: _opts.include,
+            });
+            process.stdout.write(ical);
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch iCal feed');
+        }
+    });
 }
 function getDefaultStart() {
     const d = new Date();

package/dist/commands/custom-domains.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCustomDomainCommands(program: Command): void;

package/dist/commands/custom-domains.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk';
+import { getClientAsync } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerCustomDomainCommands(program) {
+    const domains = program.command('custom-domains').description('Manage custom domains for published vaults');
+    addGlobalFlags(domains.command('list')
+        .description('List custom domains'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching custom domains...');
+        try {
+            const client = await getClientAsync();
+            const list = await client.customDomains.list();
+            out.stopSpinner();
+            out.list(list.map(d => ({ id: d.id, domain: d.domain, verified: d.verified ? 'yes' : 'no', createdAt: d.createdAt })), {
+                emptyMessage: 'No custom domains found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'domain', header: 'Domain' },
+                    { key: 'verified', header: 'Verified' },
+                    { key: 'createdAt', header: 'Created' },
+                ],
+                textFn: (d) => `${chalk.cyan(String(d.domain))} — ${d.verified === 'yes' ? chalk.green('verified') : chalk.yellow('unverified')}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch custom domains');
+        }
+    });
+    addGlobalFlags(domains.command('get')
+        .description('Get a custom domain')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.get(domainId);
+            out.stopSpinner();
+            out.record({ id: d.id, domain: d.domain, verified: d.verified, verificationToken: d.verificationToken, createdAt: d.createdAt });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('add')
+        .description('Add a custom domain')
+        .argument('<domain>', 'Domain name (e.g., docs.example.com)'))
+        .action(async (domain, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Adding custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.create({ domain });
+            out.success(`Domain added: ${d.domain}`, { id: d.id, domain: d.domain, verificationToken: d.verificationToken });
+            if (flags.output !== 'json') {
+                process.stdout.write(`\nTo verify, add this DNS TXT record:\n`);
+                process.stdout.write(`  ${chalk.cyan('_lsvault-verification.' + d.domain)} TXT ${chalk.green(d.verificationToken)}\n`);
+                process.stdout.write(`\nThen run: lsvault custom-domains verify ${d.id}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to add custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('update')
+        .description('Update a custom domain')
+        .argument('<domainId>', 'Domain ID')
+        .requiredOption('--domain <domain>', 'New domain name'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.update(domainId, { domain: _opts.domain });
+            out.success(`Domain updated: ${d.domain}`, { id: d.id, domain: d.domain });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('remove')
+        .description('Remove a custom domain')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Removing custom domain...');
+        try {
+            const client = await getClientAsync();
+            await client.customDomains.delete(domainId);
+            out.success('Custom domain removed', { id: domainId });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to remove custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('verify')
+        .description('Verify a custom domain via DNS')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Verifying custom domain...');
+        try {
+            const client = await getClientAsync();
+            const d = await client.customDomains.verify(domainId);
+            out.success(`Domain ${d.verified ? 'verified' : 'not yet verified'}: ${d.domain}`, { id: d.id, domain: d.domain, verified: d.verified });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to verify custom domain');
+        }
+    });
+    addGlobalFlags(domains.command('check')
+        .description('Check DNS configuration for a custom domain')
+        .argument('<domainId>', 'Domain ID'))
+        .action(async (domainId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Checking DNS...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.customDomains.checkDns(domainId);
+            out.stopSpinner();
+            out.record({
+                domain: result.domain,
+                resolved: result.resolved,
+                expectedValue: result.expectedValue,
+                actualValue: result.actualValue ?? 'N/A',
+            });
+            if (flags.output !== 'json') {
+                if (result.resolved) {
+                    process.stdout.write(chalk.green('\n✓ DNS configured correctly\n'));
+                }
+                else {
+                    process.stdout.write(chalk.yellow(`\n⚠ DNS not yet propagated. Expected: ${result.expectedValue}\n`));
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to check DNS');
+        }
+    });
+}

package/dist/commands/docs.js

@@ -191,4 +191,144 @@ EXAMPLES
             handleError(out, err, 'Failed to move document');
         }
     });
+    addGlobalFlags(docs.command('bulk-move')
+        .description('Move multiple documents to a target directory')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
+        .requiredOption('--target <dir>', 'Target directory'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Moving documents...');
+        try {
+            const client = await getClientAsync();
+            const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
+            const result = await client.documents.bulkMove(vaultId, { paths, targetDirectory: _opts.target });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk move documents');
+        }
+    });
+    addGlobalFlags(docs.command('bulk-copy')
+        .description('Copy multiple documents to a target directory')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
+        .requiredOption('--target <dir>', 'Target directory'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Copying documents...');
+        try {
+            const client = await getClientAsync();
+            const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
+            const result = await client.documents.bulkCopy(vaultId, { paths, targetDirectory: _opts.target });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk copy documents');
+        }
+    });
+    addGlobalFlags(docs.command('bulk-delete')
+        .description('Delete multiple documents')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--paths <csv>', 'Comma-separated list of document paths'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Deleting documents...');
+        try {
+            const client = await getClientAsync();
+            const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
+            const result = await client.documents.bulkDelete(vaultId, { paths });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk delete documents');
+        }
+    });
+    addGlobalFlags(docs.command('bulk-tag')
+        .description('Add or remove tags from multiple documents')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--paths <csv>', 'Comma-separated list of document paths')
+        .option('--add <csv>', 'Tags to add (comma-separated)')
+        .option('--remove <csv>', 'Tags to remove (comma-separated)'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.add && !_opts.remove) {
+            out.error('At least one of --add or --remove must be specified');
+            process.exitCode = 1;
+            return;
+        }
+        out.startSpinner('Tagging documents...');
+        try {
+            const client = await getClientAsync();
+            const paths = (String(_opts.paths)).split(',').map(p => p.trim()).filter(Boolean);
+            const addTags = _opts.add ? (String(_opts.add)).split(',').map(t => t.trim()).filter(Boolean) : undefined;
+            const removeTags = _opts.remove ? (String(_opts.remove)).split(',').map(t => t.trim()).filter(Boolean) : undefined;
+            const result = await client.documents.bulkTag(vaultId, { paths, addTags, removeTags });
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Succeeded: ${result.succeeded.length}, Failed: ${result.failed.length}\n`);
+                if (result.failed.length > 0) {
+                    for (const f of result.failed)
+                        process.stdout.write(`  ${chalk.red('✗')} ${f.path}: ${f.error}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to bulk tag documents');
+        }
+    });
+    addGlobalFlags(docs.command('mkdir')
+        .description('Create a directory in a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<path>', 'Directory path to create'))
+        .action(async (vaultId, path, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating directory...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.documents.createDirectory(vaultId, path);
+            out.success(`Directory ${result.created ? 'created' : 'already exists'}: ${result.path}`, { path: result.path, created: result.created });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create directory');
+        }
+    });
 }

package/dist/commands/publish-vault.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerPublishVaultCommands(program: Command): void;