@lifestreamdynamics/vault-cli 1.0.0

package/dist/utils/output.d.ts

@@ -0,0 +1,87 @@
+import type { GlobalFlags } from './flags.js';
+/**
+ * Column definition for table output.
+ */
+export interface TableColumn {
+    key: string;
+    header: string;
+    width?: number;
+}
+/**
+ * Output helper that centralizes formatting for text, json, and table modes.
+ * Status messages go to stderr so stdout stays clean for piping.
+ */
+export declare class Output {
+    private flags;
+    private spinner;
+    constructor(flags: GlobalFlags);
+    /**
+     * Start a spinner (only shown in text mode, non-quiet, TTY).
+     */
+    startSpinner(message: string): void;
+    /**
+     * Stop the spinner without a status symbol.
+     */
+    stopSpinner(): void;
+    /**
+     * Stop the spinner with a success message.
+     */
+    succeedSpinner(message: string): void;
+    /**
+     * Stop the spinner with a failure message.
+     */
+    failSpinner(message: string): void;
+    /**
+     * Print a status/info message to stderr (never captured by piping).
+     */
+    status(message: string): void;
+    /**
+     * Print a verbose/debug message to stderr.
+     */
+    debug(message: string): void;
+    /**
+     * Print an error message to stderr.
+     */
+    error(message: string): void;
+    /**
+     * Print a warning message to stderr.
+     */
+    warn(message: string): void;
+    /**
+     * Output a single record based on the format.
+     * - text: prints key-value lines
+     * - json: prints a single JSON object
+     * - table: prints a single-row table
+     */
+    record(data: Record<string, unknown>, columns?: TableColumn[]): void;
+    /**
+     * Output a list of records based on the format.
+     * - text: prints each item using textFn, or key-value pairs
+     * - json: prints one JSON object per line (JSON Lines)
+     * - table: prints an ASCII table
+     */
+    list(data: Record<string, unknown>[], options?: {
+        columns?: TableColumn[];
+        textFn?: (item: Record<string, unknown>) => string;
+        emptyMessage?: string;
+    }): void;
+    /**
+     * Output raw content to stdout (for piping document content, etc.).
+     */
+    raw(content: string): void;
+    /**
+     * Print a success result (used for create/update/delete confirmations).
+     */
+    success(message: string, data?: Record<string, unknown>): void;
+    private printKeyValue;
+    private table;
+}
+/**
+ * Create an Output instance from global flags.
+ */
+export declare function createOutput(flags: GlobalFlags): Output;
+/**
+ * Standard error handler for commands.
+ * Prints error to stderr and sets exit code.
+ */
+export declare function handleError(out: Output, err: unknown, spinnerMessage?: string): void;

package/dist/utils/output.js

@@ -0,0 +1,229 @@
+import chalk from 'chalk';
+import ora from 'ora';
+/**
+ * Output helper that centralizes formatting for text, json, and table modes.
+ * Status messages go to stderr so stdout stays clean for piping.
+ */
+export class Output {
+    flags;
+    spinner = null;
+    constructor(flags) {
+        this.flags = flags;
+    }
+    /**
+     * Start a spinner (only shown in text mode, non-quiet, TTY).
+     */
+    startSpinner(message) {
+        if (this.flags.output === 'text' && !this.flags.quiet && process.stderr.isTTY) {
+            this.spinner = ora({ text: message, stream: process.stderr }).start();
+        }
+    }
+    /**
+     * Stop the spinner without a status symbol.
+     */
+    stopSpinner() {
+        this.spinner?.stop();
+        this.spinner = null;
+    }
+    /**
+     * Stop the spinner with a success message.
+     */
+    succeedSpinner(message) {
+        if (this.spinner) {
+            this.spinner.succeed(message);
+            this.spinner = null;
+        }
+        else if (this.flags.output === 'text' && !this.flags.quiet) {
+            process.stderr.write(chalk.green('✓') + ' ' + message + '\n');
+        }
+    }
+    /**
+     * Stop the spinner with a failure message.
+     */
+    failSpinner(message) {
+        if (this.spinner) {
+            this.spinner.fail(message);
+            this.spinner = null;
+        }
+        else {
+            process.stderr.write(chalk.red('✖') + ' ' + message + '\n');
+        }
+    }
+    /**
+     * Print a status/info message to stderr (never captured by piping).
+     */
+    status(message) {
+        if (!this.flags.quiet) {
+            process.stderr.write(message + '\n');
+        }
+    }
+    /**
+     * Print a verbose/debug message to stderr.
+     */
+    debug(message) {
+        if (this.flags.verbose) {
+            process.stderr.write(chalk.dim('[debug] ' + message) + '\n');
+        }
+    }
+    /**
+     * Print an error message to stderr.
+     */
+    error(message) {
+        process.stderr.write(chalk.red(message) + '\n');
+    }
+    /**
+     * Print a warning message to stderr.
+     */
+    warn(message) {
+        if (!this.flags.quiet) {
+            process.stderr.write(chalk.yellow(message) + '\n');
+        }
+    }
+    /**
+     * Output a single record based on the format.
+     * - text: prints key-value lines
+     * - json: prints a single JSON object
+     * - table: prints a single-row table
+     */
+    record(data, columns) {
+        switch (this.flags.output) {
+            case 'json':
+                process.stdout.write(JSON.stringify(data) + '\n');
+                break;
+            case 'table':
+                this.table([data], columns);
+                break;
+            case 'text':
+            default:
+                this.printKeyValue(data);
+                break;
+        }
+    }
+    /**
+     * Output a list of records based on the format.
+     * - text: prints each item using textFn, or key-value pairs
+     * - json: prints one JSON object per line (JSON Lines)
+     * - table: prints an ASCII table
+     */
+    list(data, options) {
+        if (data.length === 0) {
+            if (this.flags.output === 'json') {
+                // empty json array: no output
+                return;
+            }
+            if (options?.emptyMessage && !this.flags.quiet) {
+                this.status(options.emptyMessage);
+            }
+            return;
+        }
+        switch (this.flags.output) {
+            case 'json':
+                for (const item of data) {
+                    process.stdout.write(JSON.stringify(item) + '\n');
+                }
+                break;
+            case 'table':
+                this.table(data, options?.columns);
+                break;
+            case 'text':
+            default:
+                if (options?.textFn) {
+                    for (const item of data) {
+                        process.stdout.write(options.textFn(item) + '\n');
+                    }
+                }
+                else {
+                    for (const item of data) {
+                        this.printKeyValue(item);
+                        process.stdout.write('\n');
+                    }
+                }
+                break;
+        }
+    }
+    /**
+     * Output raw content to stdout (for piping document content, etc.).
+     */
+    raw(content) {
+        process.stdout.write(content);
+    }
+    /**
+     * Print a success result (used for create/update/delete confirmations).
+     */
+    success(message, data) {
+        if (this.flags.output === 'json' && data) {
+            process.stdout.write(JSON.stringify(data) + '\n');
+        }
+        else if (!this.flags.quiet) {
+            this.succeedSpinner(message);
+            if (data && this.flags.output === 'text') {
+                this.printKeyValue(data);
+            }
+        }
+    }
+    printKeyValue(data) {
+        const maxKeyLen = Math.max(...Object.keys(data).map(k => k.length));
+        for (const [key, value] of Object.entries(data)) {
+            const label = key.charAt(0).toUpperCase() + key.slice(1);
+            const padding = ' '.repeat(Math.max(0, maxKeyLen - key.length + 1));
+            const displayValue = value === null || value === undefined
+                ? chalk.dim('none')
+                : String(value);
+            process.stdout.write(`${label}:${padding}${displayValue}\n`);
+        }
+    }
+    table(data, columns) {
+        if (data.length === 0)
+            return;
+        const cols = columns ?? Object.keys(data[0]).map(key => ({
+            key,
+            header: key.charAt(0).toUpperCase() + key.slice(1),
+        }));
+        // Calculate column widths
+        const widths = cols.map(col => {
+            const headerLen = col.header.length;
+            const maxDataLen = Math.max(...data.map(row => String(row[col.key] ?? '').length), 0);
+            return col.width ?? Math.max(headerLen, maxDataLen);
+        });
+        const separator = '─';
+        const corner = {
+            tl: '┌', tr: '┐', bl: '└', br: '┘',
+            ml: '├', mr: '┤', t: '┬', b: '┴', m: '┼',
+        };
+        // Top border
+        const topBorder = corner.tl + widths.map(w => separator.repeat(w + 2)).join(corner.t) + corner.tr;
+        process.stdout.write(topBorder + '\n');
+        // Header row
+        const headerRow = '│' + cols.map((col, i) => ' ' + col.header.padEnd(widths[i]) + ' ').join('│') + '│';
+        process.stdout.write(headerRow + '\n');
+        // Header separator
+        const headerSep = corner.ml + widths.map(w => separator.repeat(w + 2)).join(corner.m) + corner.mr;
+        process.stdout.write(headerSep + '\n');
+        // Data rows
+        for (const row of data) {
+            const dataRow = '│' + cols.map((col, i) => ' ' + String(row[col.key] ?? '').padEnd(widths[i]) + ' ').join('│') + '│';
+            process.stdout.write(dataRow + '\n');
+        }
+        // Bottom border
+        const bottomBorder = corner.bl + widths.map(w => separator.repeat(w + 2)).join(corner.b) + corner.br;
+        process.stdout.write(bottomBorder + '\n');
+    }
+}
+/**
+ * Create an Output instance from global flags.
+ */
+export function createOutput(flags) {
+    return new Output(flags);
+}
+/**
+ * Standard error handler for commands.
+ * Prints error to stderr and sets exit code.
+ */
+export function handleError(out, err, spinnerMessage) {
+    if (spinnerMessage) {
+        out.failSpinner(spinnerMessage);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    out.error(message);
+    process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@lifestreamdynamics/vault-cli",
+  "version": "1.0.0",
+  "description": "Command-line interface for Lifestream Vault",
+  "type": "module",
+  "bin": {
+    "lsvault": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/__tests__",
+    "README.md"
+  ],
+  "keywords": [
+    "lifestream",
+    "vault",
+    "cli",
+    "markdown",
+    "webdav",
+    "sync",
+    "command-line"
+  ],
+  "author": "Lifestream Dynamics <eric@lifestreamdynamics.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lifestreamdynamics/lifestream-vault-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lifestreamdynamics/lifestream-vault-cli/issues"
+  },
+  "homepage": "https://github.com/lifestreamdynamics/lifestream-vault-cli#readme",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "@lifestreamdynamics/vault-sdk": "^1.0.0",
+    "chalk": "^5.4.0",
+    "chokidar": "^4.0.3",
+    "commander": "^13.0.0",
+    "minimatch": "^10.2.0",
+    "ora": "^8.0.0"
+  },
+  "optionalDependencies": {
+    "keytar": "^7.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^2.0.0",
+    "@vitest/ui": "^2.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.0.0"
+  }
+}