@lifestreamdynamics/vault-cli 1.0.1 → 1.2.0

package/README.md

@@ -20,6 +20,7 @@ A powerful command-line interface for Lifestream Vault - the multi-user Markdown
   - [Team Commands](#team-commands)
   - [Sharing & Publishing](#sharing--publishing)
   - [Hooks & Webhooks](#hooks--webhooks)
+  - [Links & Backlinks](#links--backlinks)
   - [Admin Commands](#admin-commands)
 - [Sync & Watch Mode](#-sync--watch-mode)
 - [Configuration](#️-configuration)
@@ -372,6 +373,41 @@ lsvault webhooks create \
   --secret webhook_secret_key
 ```
 
+### Calendar
+
+| Command | Description |
+|---------|-------------|
+| `lsvault calendar view <vaultId>` | Browse calendar views and activity heatmap |
+| `lsvault calendar due <vaultId>` | List documents by due date |
+| `lsvault calendar events <vaultId>` | List calendar events |
+| `lsvault calendar create-event <vaultId>` | Create a calendar event |
+| `lsvault calendar update-event <vaultId> <eventId>` | Update a calendar event |
+| `lsvault calendar delete-event <vaultId> <eventId>` | Delete a calendar event |
+
+### Links & Backlinks
+
+| Command | Description |
+|---------|-------------|
+| `lsvault links list <vaultId> <path>` | List forward links from a document |
+| `lsvault links backlinks <vaultId> <path>` | List backlinks pointing to a document |
+| `lsvault links graph <vaultId>` | Get the link graph for a vault |
+| `lsvault links broken <vaultId>` | List unresolved (broken) links in a vault |
+
+**Example:**
+```bash
+# List forward links from a document
+lsvault links list vault_abc123 notes/index.md
+
+# Find all documents linking to a specific document
+lsvault links backlinks vault_abc123 notes/important.md
+
+# Get the full link graph for visualization
+lsvault links graph vault_abc123 --output json > graph.json
+
+# Find broken links
+lsvault links broken vault_abc123
+```
+
 ### Admin Commands
 
 **Note:** Admin commands require admin role.

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/auth.js

@@ -11,11 +11,13 @@ export function registerAuthCommands(program) {
         .option('--api-key <key>', 'API key (lsv_k_... prefix)')
         .option('--email <email>', 'Email address for password login')
         .option('--password <password>', 'Password (prompts interactively if omitted)')
+        .option('--mfa-code <code>', 'MFA code (TOTP or backup code) if account has MFA enabled')
         .option('--api-url <url>', 'API server URL (default: https://vault.lifestreamdynamics.com)')
         .addHelpText('after', `
 EXAMPLES
   lsvault auth login --api-key lsv_k_abc123
   lsvault auth login --email user@example.com
+  lsvault auth login --email user@example.com --mfa-code 123456
   lsvault auth login --email user@example.com --api-url https://api.example.com`)
         .action(async (opts) => {
         const cm = getCredentialManager();
@@ -42,7 +44,20 @@ EXAMPLES
             const apiUrl = opts.apiUrl ?? config.apiUrl;
             const spinner = ora('Authenticating...').start();
             try {
-                const { tokens, refreshToken } = await LifestreamVaultClient.login(apiUrl, opts.email, password);
+                const { tokens, refreshToken } = await LifestreamVaultClient.login(apiUrl, opts.email, password, {}, {
+                    mfaCode: opts.mfaCode,
+                    onMfaRequired: async (challenge) => {
+                        spinner.stop();
+                        console.log(chalk.yellow('MFA required for this account.'));
+                        console.log(`Available methods: ${challenge.methods.join(', ')}`);
+                        const code = await promptMfaCode();
+                        if (!code) {
+                            throw new Error('MFA code is required');
+                        }
+                        spinner.start('Verifying MFA code...');
+                        return { method: 'totp', code };
+                    },
+                });
                 // Save tokens to secure storage
                 await cm.saveCredentials({
                     accessToken: tokens.accessToken,
@@ -245,6 +260,57 @@ async function promptPassword() {
         process.stdin.resume();
     });
 }
+/**
+ * Prompt for an MFA code from stdin (6 digits, non-echoing).
+ * Returns the code or null if stdin is not a TTY.
+ */
+async function promptMfaCode() {
+    // In non-interactive mode, cannot prompt
+    if (!process.stdin.isTTY) {
+        return null;
+    }
+    const readline = await import('node:readline');
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stderr,
+            terminal: true,
+        });
+        // Disable echoing
+        process.stderr.write('MFA code: ');
+        process.stdin.setRawMode?.(true);
+        let code = '';
+        const onData = (chunk) => {
+            const char = chunk.toString('utf-8');
+            if (char === '\n' || char === '\r' || char === '\u0004') {
+                process.stderr.write('\n');
+                process.stdin.setRawMode?.(false);
+                process.stdin.removeListener('data', onData);
+                rl.close();
+                resolve(code);
+            }
+            else if (char === '\u0003') {
+                // Ctrl+C
+                process.stderr.write('\n');
+                process.stdin.setRawMode?.(false);
+                process.stdin.removeListener('data', onData);
+                rl.close();
+                resolve(null);
+            }
+            else if (char === '\u007F' || char === '\b') {
+                // Backspace
+                if (code.length > 0) {
+                    code = code.slice(0, -1);
+                }
+            }
+            else {
+                code += char;
+            }
+        };
+        process.stdin.on('data', onData);
+        process.stdin.resume();
+    });
+}
 function formatMethod(method) {
     switch (method) {
         case 'keychain': return chalk.green('OS Keychain');

package/dist/commands/calendar.d.ts

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

package/dist/commands/calendar.js

@@ -0,0 +1,220 @@
+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 registerCalendarCommands(program) {
+    const calendar = program.command('calendar').description('Document calendar and due date management');
+    // calendar view
+    addGlobalFlags(calendar.command('view')
+        .description('View calendar activity for a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--start <date>', 'Start date (YYYY-MM-DD)', getDefaultStart())
+        .option('--end <date>', 'End date (YYYY-MM-DD)', getDefaultEnd()))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading calendar...');
+        try {
+            const client = await getClientAsync();
+            const response = await client.calendar.getActivity(vaultId, {
+                start: _opts.start,
+                end: _opts.end,
+            });
+            out.stopSpinner();
+            if (flags.output === 'text') {
+                out.status(chalk.dim(`Activity from ${response.start} to ${response.end}:\n`));
+            }
+            out.list(response.days.map(d => ({
+                date: d.date,
+                created: String(d.created),
+                updated: String(d.updated),
+                deleted: String(d.deleted),
+                total: String(d.total),
+            })), {
+                emptyMessage: 'No activity in this period.',
+                columns: [
+                    { key: 'date', header: 'Date' },
+                    { key: 'created', header: 'Created' },
+                    { key: 'updated', header: 'Updated' },
+                    { key: 'deleted', header: 'Deleted' },
+                    { key: 'total', header: 'Total' },
+                ],
+                textFn: (d) => {
+                    const bar = '█'.repeat(Math.min(Number(d.total), 20));
+                    return `${chalk.dim(String(d.date))} ${chalk.green(bar)} ${chalk.bold(String(d.total))}`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Calendar view failed');
+        }
+    });
+    // calendar due
+    addGlobalFlags(calendar.command('due')
+        .description('List documents with due dates')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--status <status>', 'Filter: overdue, upcoming, all', 'all'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading due dates...');
+        try {
+            const client = await getClientAsync();
+            const docs = await client.calendar.getDueDates(vaultId, {
+                status: _opts.status,
+            });
+            out.stopSpinner();
+            out.list(docs.map(d => ({
+                title: d.title || d.path,
+                path: d.path,
+                dueAt: d.dueAt,
+                priority: d.priority || '-',
+                status: d.overdue ? 'OVERDUE' : d.completed ? 'Done' : 'Pending',
+            })), {
+                emptyMessage: 'No documents with due dates.',
+                columns: [
+                    { key: 'title', header: 'Title' },
+                    { key: 'dueAt', header: 'Due' },
+                    { key: 'priority', header: 'Priority' },
+                    { key: 'status', header: 'Status' },
+                ],
+                textFn: (d) => {
+                    const statusColor = d.status === 'OVERDUE' ? chalk.red : d.status === 'Done' ? chalk.green : chalk.yellow;
+                    return `${chalk.cyan(String(d.title))} — due ${chalk.dim(String(d.dueAt))} ${statusColor(String(d.status))}`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Due dates failed');
+        }
+    });
+    // calendar set-due
+    addGlobalFlags(calendar.command('set-due')
+        .description('Set due date on a document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<path>', 'Document path')
+        .requiredOption('--date <date>', 'Due date (YYYY-MM-DD or "clear")')
+        .option('--priority <priority>', 'Priority (low/medium/high)')
+        .option('--recurrence <recurrence>', 'Recurrence (daily/weekly/monthly/yearly)'))
+        .action(async (vaultId, path, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Setting due date...');
+        try {
+            const client = await getClientAsync();
+            const dateStr = _opts.date;
+            await client.calendar.setDocumentDue(vaultId, path, {
+                dueAt: dateStr === 'clear' ? null : new Date(dateStr).toISOString(),
+                priority: _opts.priority || null,
+                recurrence: _opts.recurrence || null,
+            });
+            out.stopSpinner();
+            out.status(dateStr === 'clear'
+                ? chalk.green(`Due date cleared for ${path}`)
+                : chalk.green(`Due date set to ${dateStr} for ${path}`));
+        }
+        catch (err) {
+            handleError(out, err, 'Set due date failed');
+        }
+    });
+    // calendar events
+    addGlobalFlags(calendar.command('events')
+        .description('List calendar events')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--start <date>', 'Start date')
+        .option('--end <date>', 'End date'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Loading events...');
+        try {
+            const client = await getClientAsync();
+            const events = await client.calendar.listEvents(vaultId, {
+                start: _opts.start,
+                end: _opts.end,
+            });
+            out.stopSpinner();
+            out.list(events.map(e => ({
+                title: e.title,
+                startDate: e.startDate,
+                priority: e.priority || '-',
+                completed: e.completed ? '✓' : '-',
+            })), {
+                emptyMessage: 'No calendar events.',
+                columns: [
+                    { key: 'title', header: 'Title' },
+                    { key: 'startDate', header: 'Date' },
+                    { key: 'priority', header: 'Priority' },
+                    { key: 'completed', header: 'Done' },
+                ],
+                textFn: (e) => `${chalk.cyan(String(e.title))} — ${chalk.dim(String(e.startDate))}`,
+            });
+        }
+        catch (err) {
+            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();
+    d.setDate(1);
+    return d.toISOString().split('T')[0];
+}
+function getDefaultEnd() {
+    const d = new Date();
+    d.setMonth(d.getMonth() + 1, 0);
+    return d.toISOString().split('T')[0];
+}

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

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