@lifestreamdynamics/vault-cli 1.3.9 → 1.3.11

package/dist/commands/ai.js

@@ -5,6 +5,30 @@ 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('create')
+        .description('Create a new AI chat session')
+        .option('--title <title>', 'Session title')
+        .option('--vault <vaultId>', 'Vault ID to scope the session'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating AI session...');
+        try {
+            const client = await getClientAsync();
+            const session = await client.ai.createSession({
+                title: _opts.title ? String(_opts.title) : undefined,
+                vaultId: _opts.vault ? String(_opts.vault) : undefined,
+            });
+            out.success(`Session created: ${session.id}`, {
+                id: session.id,
+                title: session.title ?? 'Untitled',
+                vaultId: session.vaultId ?? null,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create AI session');
+        }
+    });
     addGlobalFlags(sessions.command('list')
         .description('List AI chat sessions'))
         .action(async (_opts) => {

package/dist/commands/audit.js

@@ -91,8 +91,8 @@ EXAMPLES
         }
     });
     addGlobalFlags(audit.command('export')
-        .description('Export audit log entries to a CSV file or stdout')
-        .option('--format <format>', 'Export format (csv)', 'csv')
+        .description('Export audit log entries to a CSV or JSON file or stdout')
+        .option('--format <format>', 'Export format (csv or json)', 'csv')
         .option('--file <file>', 'Output file path')
         .option('--status <code>', 'Filter by HTTP status code', parseInt)
         .option('--since <date>', 'Show entries since date (ISO 8601)')
@@ -102,8 +102,8 @@ EXAMPLES
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
         try {
-            if (_opts.format !== 'csv') {
-                out.error(`Unsupported format: ${String(_opts.format)}. Only 'csv' is supported.`);
+            if (_opts.format !== 'csv' && _opts.format !== 'json') {
+                out.error(`Unsupported format: ${String(_opts.format)}. Supported: csv, json`);
                 process.exitCode = 2;
                 return;
             }
@@ -141,6 +141,26 @@ EXAMPLES
                 out.status('No audit log entries to export.');
                 return;
             }
+            if (_opts.format === 'json') {
+                const jsonOutput = JSON.stringify(entries, null, 2);
+                if (_opts.file) {
+                    const outputPath = String(_opts.file);
+                    const outputDir = path.dirname(outputPath);
+                    if (!fs.existsSync(outputDir)) {
+                        fs.mkdirSync(outputDir, { recursive: true });
+                    }
+                    fs.writeFileSync(outputPath, jsonOutput, 'utf-8');
+                    out.success(`Exported ${entries.length} entries to ${outputPath}`, {
+                        entries: entries.length,
+                        path: outputPath,
+                        format: 'json',
+                    });
+                }
+                else {
+                    out.raw(jsonOutput + '\n');
+                }
+                return;
+            }
             const csv = logger.exportCsv(entries);
             if (_opts.file) {
                 const outputPath = String(_opts.file);

package/dist/commands/links.js

@@ -100,9 +100,37 @@ export function registerLinkCommands(program) {
                 process.stdout.write(JSON.stringify({ nodes: graph.nodes, edges: graph.edges }) + '\n');
             }
             else {
-                process.stdout.write(chalk.bold(`Nodes: ${graph.nodes.length}  Edges: ${graph.edges.length}\n`));
+                process.stdout.write(chalk.bold(`Nodes: ${graph.nodes.length}  Edges: ${graph.edges.length}\n\n`));
+                // Most connected nodes (top 5)
+                const connectionCounts = new Map();
                 for (const node of graph.nodes) {
-                    process.stdout.write(`  ${chalk.cyan(String(node.path ?? node.id))}\n`);
+                    connectionCounts.set(node.id, 0);
+                }
+                for (const edge of graph.edges) {
+                    connectionCounts.set(edge.source, (connectionCounts.get(edge.source) ?? 0) + 1);
+                    connectionCounts.set(edge.target, (connectionCounts.get(edge.target) ?? 0) + 1);
+                }
+                const sorted = [...connectionCounts.entries()].sort((a, b) => b[1] - a[1]);
+                const topConnected = sorted.slice(0, 5).filter(([, count]) => count > 0);
+                if (topConnected.length > 0) {
+                    process.stdout.write(chalk.bold('Most connected:\n'));
+                    for (const [nodeId, count] of topConnected) {
+                        const node = graph.nodes.find((n) => n.id === nodeId);
+                        process.stdout.write(`  ${chalk.cyan(String(node?.path ?? nodeId))} (${count} links)\n`);
+                    }
+                    process.stdout.write('\n');
+                }
+                // Orphan nodes (no connections)
+                const orphans = sorted.filter(([, count]) => count === 0);
+                if (orphans.length > 0) {
+                    process.stdout.write(chalk.bold(`Orphan nodes (${orphans.length}):\n`));
+                    for (const [nodeId] of orphans.slice(0, 10)) {
+                        const node = graph.nodes.find((n) => n.id === nodeId);
+                        process.stdout.write(`  ${chalk.dim(String(node?.path ?? nodeId))}\n`);
+                    }
+                    if (orphans.length > 10) {
+                        process.stdout.write(chalk.dim(`  ... and ${orphans.length - 10} more\n`));
+                    }
                 }
             }
         }

package/dist/commands/publish.js

@@ -164,13 +164,16 @@ export function registerPublishCommands(program) {
             const result = await client.publish.getSubdomain(vaultId);
             out.stopSpinner();
             if (flags.output === 'json') {
-                out.record({ subdomain: result.subdomain });
+                out.raw(JSON.stringify(result, null, 2) + '\n');
             }
             else if (result.subdomain == null) {
                 out.status('No subdomain configured.');
             }
             else {
-                out.record({ subdomain: result.subdomain });
+                out.record({
+                    subdomain: result.subdomain,
+                    url: `https://${result.subdomain}.lifestreamdynamics.com`,
+                });
             }
         }
         catch (err) {

package/dist/commands/sync.js

@@ -9,7 +9,7 @@ import { formatUptime } from '../utils/format.js';
 import { loadSyncConfigs, createSyncConfig, deleteSyncConfig, getSyncConfig, } from '../sync/config.js';
 import { deleteSyncState, loadSyncState, saveSyncState, hashFileContent, buildRemoteFileState } from '../sync/state.js';
 import { resolveIgnorePatterns } from '../sync/ignore.js';
-import { scanLocalFiles, scanRemoteFiles, executePull, executePush, computePullDiff, computePushDiff, } from '../sync/engine.js';
+import { scanLocalFiles, scanRemoteFiles, executePull, executePush, computePullDiff, computePushDiff, resolveConcurrency, } from '../sync/engine.js';
 import { formatDiff } from '../sync/diff.js';
 import { createWatcher } from '../sync/watcher.js';
 import { createRemotePoller } from '../sync/remote-poller.js';
@@ -153,7 +153,8 @@ Sync modes:
     // sync pull <syncId>
     addGlobalFlags(sync.command('pull')
         .description('Pull remote changes to local directory')
-        .argument('<syncId>', 'Sync configuration ID'))
+        .argument('<syncId>', 'Sync configuration ID')
+        .option('--concurrency <n>', 'Max concurrent file transfers (1-16, default 4)', (v) => parseInt(v, 10)))
         .action(async (syncId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -211,12 +212,13 @@ Sync modes:
             if (flags.verbose) {
                 out.status(formatDiff(diff));
             }
+            const concurrency = resolveConcurrency(_opts.concurrency);
             out.startSpinner(`Pulling ${totalOps} file(s)...`);
             const result = await executePull(client, config, diff, (progress) => {
                 if (progress.phase === 'transferring' && progress.currentFile) {
                     out.startSpinner(`[${progress.current}/${progress.total}] ${progress.currentFile}`);
                 }
-            });
+            }, concurrency);
             if (result.errors.length > 0) {
                 out.failSpinner(`Pull completed with ${result.errors.length} error(s)`);
                 for (const err of result.errors) {
@@ -241,7 +243,8 @@ Sync modes:
     // sync push <syncId>
     addGlobalFlags(sync.command('push')
         .description('Push local changes to remote vault')
-        .argument('<syncId>', 'Sync configuration ID'))
+        .argument('<syncId>', 'Sync configuration ID')
+        .option('--concurrency <n>', 'Max concurrent file transfers (1-16, default 4)', (v) => parseInt(v, 10)))
         .action(async (syncId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -299,12 +302,13 @@ Sync modes:
             if (flags.verbose) {
                 out.status(formatDiff(diff));
             }
+            const concurrency = resolveConcurrency(_opts.concurrency);
             out.startSpinner(`Pushing ${totalOps} file(s)...`);
             const result = await executePush(client, config, diff, (progress) => {
                 if (progress.phase === 'transferring' && progress.currentFile) {
                     out.startSpinner(`[${progress.current}/${progress.total}] ${progress.currentFile}`);
                 }
-            });
+            }, concurrency);
             if (result.errors.length > 0) {
                 out.failSpinner(`Push completed with ${result.errors.length} error(s)`);
                 for (const err of result.errors) {

package/dist/commands/vaults.js

@@ -169,10 +169,12 @@ EXAMPLES
     // vault tree
     addGlobalFlags(vaults.command('tree')
         .description('Show vault file tree')
-        .argument('<vaultId>', 'Vault ID or slug'))
+        .argument('<vaultId>', 'Vault ID or slug')
+        .option('--depth <n>', 'Maximum display depth (0 = root only)', parseInt))
         .action(async (vaultId, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
+        const maxDepth = _opts.depth;
         out.startSpinner('Fetching vault tree...');
         try {
             vaultId = await resolveVaultId(vaultId);
@@ -184,6 +186,8 @@ EXAMPLES
             }
             else {
                 function printNode(node, depth) {
+                    if (maxDepth !== undefined && depth > maxDepth)
+                        return;
                     const indent = '  '.repeat(depth);
                     const icon = node.type === 'directory' ? chalk.yellow('📁') : chalk.cyan('📄');
                     process.stdout.write(`${indent}${icon} ${node.name}\n`);

package/dist/commands/versions.js

@@ -146,7 +146,8 @@ EXAMPLES
         .argument('<version>', 'Version number to restore')
         .addHelpText('after', `
 EXAMPLES
-  lsvault versions restore abc123 notes/todo.md 2`))
+  lsvault versions restore abc123 notes/todo.md 2
+  lsvault versions restore abc123 notes/todo.md 2 --dry-run`))
         .action(async (vaultId, docPath, versionStr, _opts) => {
         const flags = resolveFlags(_opts);
         const out = createOutput(flags);
@@ -156,6 +157,31 @@ EXAMPLES
             process.exitCode = 1;
             return;
         }
+        if (flags.dryRun) {
+            out.startSpinner(`Fetching version ${versionNum} preview...`);
+            try {
+                vaultId = await resolveVaultId(vaultId);
+                const client = await getClientAsync();
+                const version = await client.documents.getVersion(vaultId, docPath, versionNum);
+                out.stopSpinner();
+                if (flags.output === 'json') {
+                    out.raw(JSON.stringify({ dryRun: true, version: { version: version.versionNum, createdAt: version.createdAt, size: version.content?.length ?? 0 } }, null, 2) + '\n');
+                }
+                else {
+                    process.stdout.write(chalk.bold('Dry run — no changes made\n\n'));
+                    process.stdout.write(`Version: ${version.versionNum}\n`);
+                    process.stdout.write(`Created: ${version.createdAt}\n`);
+                    if (version.content) {
+                        const preview = version.content.slice(0, 200);
+                        process.stdout.write(`Content preview:\n${chalk.dim(preview)}${version.content.length > 200 ? '...' : ''}\n`);
+                    }
+                }
+            }
+            catch (err) {
+                handleError(out, err, 'Failed to preview version');
+            }
+            return;
+        }
         out.startSpinner(`Restoring to version ${versionNum}...`);
         try {
             vaultId = await resolveVaultId(vaultId);

package/dist/sync/engine.d.ts

@@ -30,12 +30,17 @@ export declare function scanLocalFiles(localPath: string, ignorePatterns: string
  * Returns a map of doc paths -> FileState.
  */
 export declare function scanRemoteFiles(client: LifestreamVaultClient, vaultId: string, ignorePatterns: string[]): Promise<Record<string, FileState>>;
+/**
+ * Validates and clamps a user-supplied concurrency value. Throws on invalid
+ * values so the CLI can surface a clear error before kicking off any I/O.
+ */
+export declare function resolveConcurrency(value: number | undefined): number;
 /**
  * Execute a pull operation: download remote changes to local.
  */
-export declare function executePull(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback): Promise<SyncResult>;
+export declare function executePull(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback, concurrency?: number): Promise<SyncResult>;
 /**
  * Execute a push operation: upload local changes to remote.
  */
-export declare function executePush(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback): Promise<SyncResult>;
+export declare function executePush(client: LifestreamVaultClient, config: SyncConfig, diff: SyncDiff, onProgress?: ProgressCallback, concurrency?: number): Promise<SyncResult>;
 export { computePullDiff, computePushDiff, type SyncDiff, type SyncDiffEntry };

package/dist/sync/engine.js

@@ -54,7 +54,7 @@ export async function scanRemoteFiles(client, vaultId, ignorePatterns) {
         if (!shouldIgnore(doc.path, ignorePatterns)) {
             files[doc.path] = {
                 path: doc.path,
-                hash: '', // We don't have content hash from list; will use mtime for comparison
+                hash: doc.contentHash,
                 mtime: doc.fileModifiedAt,
                 size: doc.sizeBytes,
             };
@@ -71,12 +71,31 @@ function atomicWriteFileSync(targetPath, content, encoding = 'utf-8') {
     fs.writeFileSync(tmpFile, content, encoding);
     fs.renameSync(tmpFile, targetPath);
 }
+/**
+ * Default in-flight transfer count. A small number flattens the load1 spike
+ * a full-vault `sync pull` causes on the API host without making single
+ * transfers measurably slower.
+ */
+const DEFAULT_TRANSFER_CONCURRENCY = 4;
+const MAX_TRANSFER_CONCURRENCY = 16;
+/**
+ * Validates and clamps a user-supplied concurrency value. Throws on invalid
+ * values so the CLI can surface a clear error before kicking off any I/O.
+ */
+export function resolveConcurrency(value) {
+    if (value === undefined)
+        return DEFAULT_TRANSFER_CONCURRENCY;
+    if (!Number.isInteger(value) || value < 1 || value > MAX_TRANSFER_CONCURRENCY) {
+        throw new Error(`--concurrency must be an integer between 1 and ${MAX_TRANSFER_CONCURRENCY} (got ${value})`);
+    }
+    return value;
+}
 /**
  * Shared sync operation executor used by both pull and push.
  * Handles result initialization, state loading, progress callbacks,
  * quota error handling, state saving, and lastSync update.
  */
-async function executeSyncOperation(config, diff, handlers, onProgress) {
+async function executeSyncOperation(config, diff, handlers, onProgress, concurrency = DEFAULT_TRANSFER_CONCURRENCY) {
     const result = {
         filesUploaded: 0,
         filesDownloaded: 0,
@@ -87,7 +106,12 @@ async function executeSyncOperation(config, diff, handlers, onProgress) {
     const state = loadSyncState(config.id);
     const allOps = [...handlers.transfers, ...handlers.deletes];
     let current = 0;
-    for (const entry of handlers.transfers) {
+    // Once a quota error is hit anywhere in the pool we stop submitting new
+    // work but let in-flight transfers drain to keep state consistent.
+    let stopSubmitting = false;
+    async function runOne(entry) {
+        if (stopSubmitting)
+            return;
         current++;
         onProgress?.({
             phase: 'transferring',
@@ -112,13 +136,25 @@ async function executeSyncOperation(config, diff, handlers, onProgress) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
+            result.errors.push({ path: entry.path, error: message });
             if (isQuotaError(message)) {
-                result.errors.push({ path: entry.path, error: message });
-                break; // Stop immediately on quota errors
+                stopSubmitting = true;
             }
-            result.errors.push({ path: entry.path, error: message });
         }
     }
+    // Bounded async pool. Workers race for entries off the queue tail; once
+    // the queue is empty (or stopSubmitting is set), each worker exits and
+    // Promise.all resolves only after every in-flight transfer has settled.
+    const queue = handlers.transfers.slice();
+    const poolSize = Math.min(Math.max(1, concurrency), Math.max(1, queue.length));
+    await Promise.all(Array.from({ length: poolSize }, async () => {
+        while (!stopSubmitting) {
+            const entry = queue.shift();
+            if (!entry)
+                return;
+            await runOne(entry);
+        }
+    }));
     for (const entry of handlers.deletes) {
         current++;
         onProgress?.({
@@ -154,7 +190,7 @@ async function executeSyncOperation(config, diff, handlers, onProgress) {
 /**
  * Execute a pull operation: download remote changes to local.
  */
-export async function executePull(client, config, diff, onProgress) {
+export async function executePull(client, config, diff, onProgress, concurrency) {
     return executeSyncOperation(config, diff, {
         transfers: diff.downloads,
         deletes: diff.deletes,
@@ -175,12 +211,12 @@ export async function executePull(client, config, diff, onProgress) {
                 fs.unlinkSync(localFile);
             }
         },
-    }, onProgress);
+    }, onProgress, concurrency);
 }
 /**
  * Execute a push operation: upload local changes to remote.
  */
-export async function executePush(client, config, diff, onProgress) {
+export async function executePush(client, config, diff, onProgress, concurrency) {
     return executeSyncOperation(config, diff, {
         transfers: diff.uploads,
         deletes: diff.deletes,
@@ -194,7 +230,7 @@ export async function executePush(client, config, diff, onProgress) {
         async deleteFile(entry, cfg) {
             await retryWithBackoff(() => client.documents.delete(cfg.vaultId, entry.path));
         },
-    }, onProgress);
+    }, onProgress, concurrency);
 }
 /**
  * Retry a function with exponential backoff (max 3 retries).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifestreamdynamics/vault-cli",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "description": "Command-line interface for Lifestream Vault",
   "engines": {
     "node": ">=22"