archicore 0.1.8 → 0.2.0

package/dist/cli/commands/auth.d.ts

@@ -34,5 +34,9 @@ export declare function logout(): Promise<void>;
  * Require authentication - prompt login if needed
  */
 export declare function requireAuth(): Promise<TokenResponse['user'] | null>;
+/**
+ * Register auth CLI commands
+ */
+export declare function registerAuthCommands(program: any): void;
 export {};
 //# sourceMappingURL=auth.d.ts.map

package/dist/cli/commands/auth.js

@@ -161,4 +161,62 @@ export async function requireAuth() {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Register auth CLI commands
+ */
+export function registerAuthCommands(program) {
+    program
+        .command('login')
+        .description('Login to ArchiCore')
+        .action(async () => {
+        const user = await getCurrentUser();
+        if (user) {
+            printInfo(`Already logged in as ${user.name || user.email}`);
+            return;
+        }
+        await login();
+    });
+    program
+        .command('logout')
+        .description('Logout from ArchiCore')
+        .action(async () => {
+        await logout();
+    });
+    program
+        .command('status')
+        .description('Show authentication and subscription status')
+        .action(async () => {
+        const config = await loadConfig();
+        const user = await getCurrentUser();
+        console.log();
+        if (user) {
+            printSuccess(`Logged in as: ${user.name || user.email}`);
+            printInfo(`Tier: ${user.tier}`);
+            // Get subscription details
+            try {
+                const response = await fetch(`${config.serverUrl}/api/auth/subscription`, {
+                    headers: {
+                        'Authorization': `Bearer ${config.accessToken}`,
+                    },
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    console.log();
+                    printInfo(`Requests used today: ${data.usage?.used || 0}/${data.limits?.requestsPerDay === -1 ? '∞' : data.limits?.requestsPerDay || 0}`);
+                    if (data.expiresAt) {
+                        printInfo(`Subscription expires: ${new Date(data.expiresAt).toLocaleDateString()}`);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        else {
+            printError('Not logged in');
+            printInfo('Use "archicore login" to authenticate');
+        }
+        console.log();
+    });
+}
 //# sourceMappingURL=auth.js.map

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

@@ -3,7 +3,8 @@
  */
 export { registerAnalyzerCommands } from './analyzers.js';
 export { registerExportCommand } from './export.js';
+export { registerProjectsCommand } from './projects.js';
 export { startInteractiveMode } from './interactive.js';
 export { initProject, isInitialized, getLocalProject } from './init.js';
-export { login, logout, isAuthenticated, getCurrentUser, requireAuth } from './auth.js';
+export { login, logout, isAuthenticated, getCurrentUser, requireAuth, registerAuthCommands } from './auth.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/index.js

@@ -3,7 +3,8 @@
  */
 export { registerAnalyzerCommands } from './analyzers.js';
 export { registerExportCommand } from './export.js';
+export { registerProjectsCommand } from './projects.js';
 export { startInteractiveMode } from './interactive.js';
 export { initProject, isInitialized, getLocalProject } from './init.js';
-export { login, logout, isAuthenticated, getCurrentUser, requireAuth } from './auth.js';
+export { login, logout, isAuthenticated, getCurrentUser, requireAuth, registerAuthCommands } from './auth.js';
 //# sourceMappingURL=index.js.map

package/dist/cli/commands/interactive.js

@@ -6,6 +6,7 @@
 import * as readline from 'readline';
 import { loadConfig } from '../utils/config.js';
 import { checkServerConnection } from '../utils/session.js';
+import { printFormattedError, printStartupError, } from '../utils/error-handler.js';
 import { isInitialized, getLocalProject } from './init.js';
 import { requireAuth, logout } from './auth.js';
 import { colors, icons, createSpinner, printHelp, printGoodbye, printSection, printSuccess, printError, printWarning, printInfo, printKeyValue, header, } from '../ui/index.js';
@@ -71,21 +72,15 @@ function showTokenUsage() {
 export async function startInteractiveMode() {
     // Prevent process from exiting on unhandled errors
     process.on('uncaughtException', (error) => {
-        printError(`Unexpected error: ${error.message}`);
-        console.log();
+        printFormattedError(error, { operation: 'Unexpected error' });
     });
     process.on('unhandledRejection', (reason) => {
-        printError(`Unhandled promise rejection: ${reason}`);
-        console.log();
+        printFormattedError(reason, { operation: 'Unhandled promise' });
     });
     // Check if initialized in current directory
     const initialized = await isInitialized(state.projectPath);
     if (!initialized) {
-        console.log();
-        printError('ArchiCore not initialized in this directory');
-        console.log();
-        printInfo('Run `archicore init` to initialize');
-        console.log();
+        printStartupError(new Error('ArchiCore not initialized in this directory'));
         process.exit(1);
     }
     // Load local project config
@@ -99,14 +94,14 @@ export async function startInteractiveMode() {
     const connected = await checkServerConnection();
     if (!connected) {
         spinner.fail('Cannot connect to ArchiCore server');
-        printError('Make sure the server is running');
+        printStartupError(new Error('Cannot connect to server'));
         process.exit(1);
     }
     spinner.succeed('Connected');
     // Require authentication
     const user = await requireAuth();
     if (!user) {
-        printError('Authentication required');
+        printStartupError(new Error('Authentication required'));
         process.exit(1);
     }
     state.user = user;
@@ -277,8 +272,9 @@ async function handleCommand(input) {
             state.running = false;
             break;
         default:
-            printError(`Unknown command: /${command}`);
-            printInfo('Use /help to see available commands');
+            printFormattedError(`Unknown command: /${command}`, {
+                suggestion: 'Use /help to see available commands',
+            });
     }
 }
 async function handleIndexCommand() {
@@ -607,23 +603,33 @@ async function handleDeadCodeCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const result = data.deadCode;
+        // Handle various response formats
+        const result = data.deadCode || data.result || data || {};
         spinner.succeed('Analysis complete');
         printSection('Dead Code');
-        console.log(`  Unused exports: ${result.unusedExports?.length || 0}`);
-        console.log(`  Unused variables: ${result.unusedVariables?.length || 0}`);
-        console.log(`  Unreachable code: ${result.unreachableCode?.length || 0}`);
-        if (result.unusedExports?.length > 0) {
+        const unusedExports = result.unusedExports || [];
+        const unusedVariables = result.unusedVariables || [];
+        const unreachableCode = result.unreachableCode || [];
+        console.log(`  Unused exports: ${unusedExports.length}`);
+        console.log(`  Unused variables: ${unusedVariables.length}`);
+        console.log(`  Unreachable code: ${unreachableCode.length}`);
+        if (unusedExports.length === 0 && unusedVariables.length === 0 && unreachableCode.length === 0) {
+            printSuccess('No dead code found!');
+            return;
+        }
+        if (unusedExports.length > 0) {
             console.log();
             console.log(colors.muted('  Top unused exports:'));
-            for (const item of result.unusedExports.slice(0, 5)) {
-                console.log(`    ${colors.warning(icons.warning)} ${item.name} ${colors.dim(`(${item.filePath})`)}`);
+            for (const item of unusedExports.slice(0, 5)) {
+                const name = item.name || item.symbol || 'unknown';
+                const file = item.filePath || item.file || '';
+                console.log(`    ${colors.warning(icons.warning)} ${name} ${colors.dim(`(${file})`)}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Dead code analysis' });
     }
 }
 async function handleSecurityCommand() {
@@ -638,7 +644,9 @@ async function handleSecurityCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const vulns = data.security?.vulnerabilities || [];
+        // Handle various response formats
+        const security = data.security || data.result || data || {};
+        const vulns = security.vulnerabilities || security.issues || [];
         spinner.succeed('Analysis complete');
         printSection('Security');
         if (vulns.length === 0) {
@@ -659,13 +667,15 @@ async function handleSecurityCommand() {
             console.log();
             console.log(colors.muted('  Critical/High issues:'));
             for (const v of vulns.filter((v) => v.severity === 'critical' || v.severity === 'high').slice(0, 5)) {
-                console.log(`    ${colors.error(icons.error)} ${v.type}: ${v.description}`);
+                const type = v.type || v.category || 'Issue';
+                const desc = v.description || v.message || 'No description';
+                console.log(`    ${colors.error(icons.error)} ${type}: ${desc}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Security analysis' });
     }
 }
 async function handleMetricsCommand() {
@@ -680,19 +690,38 @@ async function handleMetricsCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const metrics = data.metrics;
+        // Handle various response formats
+        const metrics = data.metrics || data.result || data || {};
+        const summary = metrics.summary || metrics || {};
         spinner.succeed('Metrics calculated');
         printSection('Code Metrics');
-        if (metrics.summary) {
-            console.log(`  Files: ${metrics.summary.totalFiles || 0}`);
-            console.log(`  Lines: ${metrics.summary.totalLines || 0}`);
-            console.log(`  Avg Complexity: ${(metrics.summary.avgComplexity || 0).toFixed(2)}`);
-            console.log(`  Avg Maintainability: ${(metrics.summary.avgMaintainability || 0).toFixed(1)}`);
+        // Display available metrics
+        const totalFiles = summary.totalFiles || summary.files || metrics.totalFiles || 0;
+        const totalLines = summary.totalLines || summary.lines || metrics.totalLines || 0;
+        const avgComplexity = summary.avgComplexity || summary.complexity || metrics.avgComplexity || 0;
+        const avgMaintainability = summary.avgMaintainability || summary.maintainability || metrics.avgMaintainability || 0;
+        console.log(`  Files: ${totalFiles}`);
+        console.log(`  Lines: ${totalLines}`);
+        if (avgComplexity > 0) {
+            console.log(`  Avg Complexity: ${Number(avgComplexity).toFixed(2)}`);
+        }
+        if (avgMaintainability > 0) {
+            console.log(`  Avg Maintainability: ${Number(avgMaintainability).toFixed(1)}`);
+        }
+        // Show additional metrics if available
+        if (metrics.functions || summary.functions) {
+            console.log(`  Functions: ${metrics.functions || summary.functions}`);
+        }
+        if (metrics.classes || summary.classes) {
+            console.log(`  Classes: ${metrics.classes || summary.classes}`);
+        }
+        if (totalFiles === 0 && totalLines === 0) {
+            printWarning('No metrics data available. Make sure project is indexed.');
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Metrics calculation' });
     }
 }
 async function handleExportCommand(args) {
@@ -785,28 +814,37 @@ async function handleDuplicationCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const result = data.duplication;
+        // Handle various response formats
+        const result = data.duplication || data.result || data || {};
+        const clones = result.clones || [];
+        const duplicationRate = result.duplicationRate || result.rate || 0;
+        const duplicatedLines = result.duplicatedLines || result.lines || 0;
         spinner.succeed('Analysis complete');
         printSection('Code Duplication');
-        console.log(`  Code clones: ${result.clones?.length || 0}`);
-        console.log(`  Duplication rate: ${(result.duplicationRate || 0).toFixed(1)}%`);
-        console.log(`  Duplicated lines: ${result.duplicatedLines || 0}`);
-        if (result.clones?.length > 0) {
-            console.log();
-            console.log(colors.muted('  Top duplicates:'));
-            for (const clone of result.clones.slice(0, 5)) {
-                console.log(`    ${colors.warning(icons.warning)} ${clone.files?.length || 2} files, ${clone.lines || 0} lines`);
-                if (clone.files) {
-                    for (const f of clone.files.slice(0, 2)) {
-                        console.log(`      ${colors.dim(f)}`);
-                    }
+        console.log(`  Code clones: ${clones.length}`);
+        console.log(`  Duplication rate: ${Number(duplicationRate).toFixed(1)}%`);
+        console.log(`  Duplicated lines: ${duplicatedLines}`);
+        if (clones.length === 0) {
+            printSuccess('No code duplication found!');
+            return;
+        }
+        console.log();
+        console.log(colors.muted('  Top duplicates:'));
+        for (const clone of clones.slice(0, 5)) {
+            const files = clone.files || clone.locations || [];
+            const lines = clone.lines || clone.lineCount || 0;
+            console.log(`    ${colors.warning(icons.warning)} ${files.length || 2} files, ${lines} lines`);
+            if (files.length > 0) {
+                for (const f of files.slice(0, 2)) {
+                    const filePath = typeof f === 'string' ? f : f.file || f.path || '';
+                    console.log(`      ${colors.dim(filePath)}`);
                 }
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Duplication analysis' });
     }
 }
 async function handleRefactoringCommand() {
@@ -822,7 +860,9 @@ async function handleRefactoringCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const suggestions = data.refactoring?.suggestions || [];
+        // Handle various response formats
+        const refactoring = data.refactoring || data.result || data || {};
+        const suggestions = refactoring.suggestions || refactoring.items || [];
         spinner.succeed('Analysis complete');
         printSection('Refactoring Suggestions');
         if (suggestions.length === 0) {
@@ -841,17 +881,20 @@ async function handleRefactoringCommand() {
         console.log();
         console.log(colors.muted('  Top suggestions:'));
         for (const s of suggestions.slice(0, 5)) {
-            const priorityColor = s.priority === 'critical' ? colors.critical :
-                s.priority === 'high' ? colors.high : colors.muted;
-            console.log(`    ${priorityColor(`[${s.priority}]`)} ${s.type}: ${s.description}`);
-            if (s.file) {
-                console.log(`      ${colors.dim(s.file)}`);
+            const priority = s.priority || 'medium';
+            const type = s.type || s.category || 'Suggestion';
+            const desc = s.description || s.message || '';
+            const priorityColor = priority === 'critical' ? colors.critical :
+                priority === 'high' ? colors.high : colors.muted;
+            console.log(`    ${priorityColor(`[${priority}]`)} ${type}: ${desc}`);
+            if (s.file || s.filePath) {
+                console.log(`      ${colors.dim(s.file || s.filePath)}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Refactoring analysis' });
     }
 }
 async function handleRulesCommand() {
@@ -867,7 +910,9 @@ async function handleRulesCommand() {
         if (!response.ok)
             throw new Error('Analysis failed');
         const data = await response.json();
-        const violations = data.rules?.violations || [];
+        // Handle various response formats
+        const rules = data.rules || data.result || data || {};
+        const violations = rules.violations || rules.issues || [];
         spinner.succeed('Analysis complete');
         printSection('Architectural Rules');
         if (violations.length === 0) {
@@ -877,17 +922,20 @@ async function handleRulesCommand() {
         console.log(`  Violations: ${violations.length}`);
         console.log();
         for (const v of violations.slice(0, 10)) {
-            const severityColor = v.severity === 'error' ? colors.error :
-                v.severity === 'warning' ? colors.warning : colors.muted;
-            console.log(`    ${severityColor(icons.error)} ${v.rule}: ${v.message}`);
-            if (v.file) {
-                console.log(`      ${colors.dim(v.file)}`);
+            const severity = v.severity || 'warning';
+            const rule = v.rule || v.name || 'Unknown rule';
+            const message = v.message || v.description || '';
+            const severityColor = severity === 'error' ? colors.error :
+                severity === 'warning' ? colors.warning : colors.muted;
+            console.log(`    ${severityColor(icons.error)} ${rule}: ${message}`);
+            if (v.file || v.filePath) {
+                console.log(`      ${colors.dim(v.file || v.filePath)}`);
             }
         }
     }
     catch (error) {
         spinner.fail('Analysis failed');
-        throw error;
+        printFormattedError(error, { operation: 'Rules check' });
     }
 }
 async function handleDocsCommand(args) {

package/dist/cli/ui/index.d.ts

@@ -6,4 +6,5 @@ export * from './box.js';
 export * from './table.js';
 export * from './spinner.js';
 export * from './prompt.js';
+export * from './progress.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/ui/index.js

@@ -6,4 +6,5 @@ export * from './box.js';
 export * from './table.js';
 export * from './spinner.js';
 export * from './prompt.js';
+export * from './progress.js';
 //# sourceMappingURL=index.js.map

package/dist/cli/ui/progress.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ArchiCore CLI Progress Bar Component
+ *
+ * Visual progress bar for batch operations
+ */
+import cliProgress from 'cli-progress';
+export interface ProgressBarOptions {
+    total: number;
+    label?: string;
+    format?: string;
+    showEta?: boolean;
+    showSpeed?: boolean;
+}
+/**
+ * Create a styled progress bar
+ */
+export declare function createProgressBar(options: ProgressBarOptions): cliProgress.SingleBar;
+/**
+ * Multi-bar for parallel operations
+ */
+export declare function createMultiProgressBar(): cliProgress.MultiBar;
+/**
+ * Wrapper for batch processing with progress
+ */
+export declare function withProgress<T, R>(items: T[], processor: (item: T, index: number) => Promise<R>, options?: {
+    label?: string;
+    concurrency?: number;
+    onError?: (error: Error, item: T, index: number) => void;
+}): Promise<{
+    results: R[];
+    errors: Array<{
+        item: T;
+        error: Error;
+    }>;
+}>;
+/**
+ * File indexing progress (specialized for code indexing)
+ */
+export declare class IndexingProgress {
+    private multiBar;
+    private parseBar;
+    private symbolBar;
+    private uploadBar;
+    constructor();
+    startParsing(total: number): void;
+    updateParsing(current: number): void;
+    startSymbols(total: number): void;
+    updateSymbols(current: number): void;
+    startUpload(total: number): void;
+    updateUpload(current: number): void;
+    stop(): void;
+}
+/**
+ * Simple percentage display for quick operations
+ */
+export declare function printProgress(current: number, total: number, label?: string): void;
+//# sourceMappingURL=progress.d.ts.map

package/dist/cli/ui/progress.js

@@ -0,0 +1,149 @@
+/**
+ * ArchiCore CLI Progress Bar Component
+ *
+ * Visual progress bar for batch operations
+ */
+import cliProgress from 'cli-progress';
+import chalk from 'chalk';
+const DEFAULT_FORMAT = ' {bar} {percentage}% | {value}/{total} | {label}';
+const DEFAULT_FORMAT_WITH_ETA = ' {bar} {percentage}% | {value}/{total} | ETA: {eta}s | {label}';
+/**
+ * Create a styled progress bar
+ */
+export function createProgressBar(options) {
+    const format = options.showEta ? DEFAULT_FORMAT_WITH_ETA : (options.format || DEFAULT_FORMAT);
+    const bar = new cliProgress.SingleBar({
+        format: chalk.cyan('{bar}') + chalk.gray(format.replace('{bar}', '')),
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        clearOnComplete: false,
+        stopOnComplete: true,
+        forceRedraw: true,
+    }, cliProgress.Presets.shades_classic);
+    bar.start(options.total, 0, { label: options.label || '' });
+    return bar;
+}
+/**
+ * Multi-bar for parallel operations
+ */
+export function createMultiProgressBar() {
+    return new cliProgress.MultiBar({
+        format: chalk.cyan('{bar}') + chalk.gray(' {percentage}% | {value}/{total} | {label}'),
+        barCompleteChar: '\u2588',
+        barIncompleteChar: '\u2591',
+        hideCursor: true,
+        clearOnComplete: false,
+        stopOnComplete: true,
+    }, cliProgress.Presets.shades_classic);
+}
+/**
+ * Wrapper for batch processing with progress
+ */
+export async function withProgress(items, processor, options = {}) {
+    const { label = 'Processing', concurrency = 1, onError } = options;
+    const results = [];
+    const errors = [];
+    if (items.length === 0) {
+        return { results, errors };
+    }
+    const bar = createProgressBar({
+        total: items.length,
+        label,
+        showEta: items.length > 10,
+    });
+    if (concurrency === 1) {
+        // Sequential processing
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const result = await processor(items[i], i);
+                results.push(result);
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                errors.push({ item: items[i], error: err });
+                onError?.(err, items[i], i);
+            }
+            bar.update(i + 1, { label: `${label} (${i + 1}/${items.length})` });
+        }
+    }
+    else {
+        // Parallel processing with concurrency limit
+        const chunks = [];
+        for (let i = 0; i < items.length; i += concurrency) {
+            chunks.push(items.slice(i, i + concurrency));
+        }
+        let processed = 0;
+        for (const chunk of chunks) {
+            const chunkResults = await Promise.allSettled(chunk.map((item, i) => processor(item, processed + i)));
+            for (let i = 0; i < chunkResults.length; i++) {
+                const result = chunkResults[i];
+                if (result.status === 'fulfilled') {
+                    results.push(result.value);
+                }
+                else {
+                    const err = result.reason instanceof Error ? result.reason : new Error(String(result.reason));
+                    errors.push({ item: chunk[i], error: err });
+                    onError?.(err, chunk[i], processed + i);
+                }
+                processed++;
+                bar.update(processed, { label: `${label} (${processed}/${items.length})` });
+            }
+        }
+    }
+    bar.stop();
+    return { results, errors };
+}
+/**
+ * File indexing progress (specialized for code indexing)
+ */
+export class IndexingProgress {
+    multiBar;
+    parseBar = null;
+    symbolBar = null;
+    uploadBar = null;
+    constructor() {
+        this.multiBar = new cliProgress.MultiBar({
+            format: ' {stage} ' + chalk.cyan('{bar}') + chalk.gray(' {percentage}% | {value}/{total}'),
+            barCompleteChar: '\u2588',
+            barIncompleteChar: '\u2591',
+            hideCursor: true,
+            clearOnComplete: false,
+        }, cliProgress.Presets.shades_classic);
+    }
+    startParsing(total) {
+        this.parseBar = this.multiBar.create(total, 0, { stage: chalk.blue('Parsing  ') });
+    }
+    updateParsing(current) {
+        this.parseBar?.update(current);
+    }
+    startSymbols(total) {
+        this.symbolBar = this.multiBar.create(total, 0, { stage: chalk.yellow('Symbols  ') });
+    }
+    updateSymbols(current) {
+        this.symbolBar?.update(current);
+    }
+    startUpload(total) {
+        this.uploadBar = this.multiBar.create(total, 0, { stage: chalk.green('Upload   ') });
+    }
+    updateUpload(current) {
+        this.uploadBar?.update(current);
+    }
+    stop() {
+        this.multiBar.stop();
+    }
+}
+/**
+ * Simple percentage display for quick operations
+ */
+export function printProgress(current, total, label = '') {
+    const percentage = Math.round((current / total) * 100);
+    const filled = Math.round(percentage / 5);
+    const empty = 20 - filled;
+    const bar = chalk.cyan('\u2588'.repeat(filled)) + chalk.gray('\u2591'.repeat(empty));
+    process.stdout.write(`\r ${bar} ${percentage}% ${label}`);
+    if (current >= total) {
+        process.stdout.write('\n');
+    }
+}
+//# sourceMappingURL=progress.js.map

package/dist/cli/utils/error-handler.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ArchiCore CLI - Error Handler
+ *
+ * User-friendly error messages with suggestions
+ */
+export interface ErrorContext {
+    code?: string;
+    statusCode?: number;
+    operation?: string;
+    suggestion?: string;
+    details?: string;
+}
+/**
+ * Format error for CLI display
+ */
+export declare function formatError(error: unknown, context?: ErrorContext): string;
+/**
+ * Print error with formatting
+ */
+export declare function printFormattedError(error: unknown, context?: ErrorContext): void;
+/**
+ * Wrap async operation with error handling
+ */
+export declare function withErrorHandler<T>(operation: () => Promise<T>, context?: ErrorContext): Promise<T | null>;
+/**
+ * Create contextual error handler
+ */
+export declare function createErrorHandler(defaultContext: Partial<ErrorContext>): {
+    handle: (error: unknown, additionalContext?: Partial<ErrorContext>) => void;
+    wrap: <T>(operation: () => Promise<T>, additionalContext?: Partial<ErrorContext>) => Promise<T | null>;
+};
+/**
+ * HTTP response error handler
+ */
+export declare function handleResponseError(response: Response, operation?: string): Promise<never>;
+/**
+ * Print startup errors nicely
+ */
+export declare function printStartupError(error: unknown): void;
+//# sourceMappingURL=error-handler.d.ts.map