@vdntio/clai 0.1.0-alpha.1

package/dist/context/types.js

@@ -0,0 +1,10 @@
+// Context Data Types for the clai CLI
+import { ClaiError } from '../error/index.js';
+/** Error class for context gathering failures */
+export class ContextError extends ClaiError {
+    constructor(message, code = 1) {
+        super(message, code);
+        this.name = 'ContextError';
+        Object.setPrototypeOf(this, ContextError.prototype);
+    }
+}

package/dist/error/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Base error class for all clai errors with exit code semantics
+ *
+ * Exit codes:
+ * 0: Success (help/version)
+ * 1: General/unhandled errors
+ * 2: Usage errors (invalid CLI arguments)
+ * 3: Config errors (parse failures, permissions)
+ * 4: API errors (auth, rate limit, timeout)
+ * 5: Safety errors (user abort)
+ * 130: Interrupted (SIGINT/SIGTERM)
+ */
+export declare class ClaiError extends Error {
+    readonly code: number;
+    constructor(message: string, code?: number, cause?: Error);
+}
+/**
+ * Usage error: invalid CLI arguments or options
+ * Exit code: 2
+ */
+export declare class UsageError extends ClaiError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Interrupt error: SIGINT/SIGTERM received
+ * Exit code: 130
+ */
+export declare class InterruptError extends ClaiError {
+    constructor(message?: string, cause?: Error);
+}

package/dist/error/index.js

@@ -0,0 +1,50 @@
+/**
+ * Base error class for all clai errors with exit code semantics
+ *
+ * Exit codes:
+ * 0: Success (help/version)
+ * 1: General/unhandled errors
+ * 2: Usage errors (invalid CLI arguments)
+ * 3: Config errors (parse failures, permissions)
+ * 4: API errors (auth, rate limit, timeout)
+ * 5: Safety errors (user abort)
+ * 130: Interrupted (SIGINT/SIGTERM)
+ */
+export class ClaiError extends Error {
+    code;
+    constructor(message, code = 1, cause) {
+        super(message, { cause });
+        this.name = 'ClaiError';
+        // Define code as non-writable property
+        Object.defineProperty(this, 'code', {
+            value: code,
+            writable: false,
+            enumerable: true,
+            configurable: false,
+        });
+        // Maintain proper prototype chain for instanceof checks
+        Object.setPrototypeOf(this, ClaiError.prototype);
+    }
+}
+/**
+ * Usage error: invalid CLI arguments or options
+ * Exit code: 2
+ */
+export class UsageError extends ClaiError {
+    constructor(message, cause) {
+        super(message, 2, cause);
+        this.name = 'UsageError';
+        Object.setPrototypeOf(this, UsageError.prototype);
+    }
+}
+/**
+ * Interrupt error: SIGINT/SIGTERM received
+ * Exit code: 130
+ */
+export class InterruptError extends ClaiError {
+    constructor(message = 'Interrupted', cause) {
+        super(message, 130, cause);
+        this.name = 'InterruptError';
+        Object.setPrototypeOf(this, InterruptError.prototype);
+    }
+}

package/dist/logging/file-logger.d.ts

@@ -0,0 +1,12 @@
+import { Logger, LogLevel } from './logger.js';
+export declare class FileLogger extends Logger {
+    private filePath;
+    constructor(filePath: string, level?: LogLevel);
+    private ensureDirectory;
+    private checkAndTruncate;
+    private writeToFile;
+    error(msg: string): void;
+    warn(msg: string): void;
+    info(msg: string): void;
+    debug(msg: string): void;
+}

package/dist/logging/file-logger.js

@@ -0,0 +1,66 @@
+import { appendFileSync, statSync, truncateSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { Logger } from './logger.js';
+const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+export class FileLogger extends Logger {
+    filePath;
+    constructor(filePath, level = 'verbose') {
+        super(level, 'never'); // File logging never uses color
+        this.filePath = filePath;
+        this.ensureDirectory();
+    }
+    ensureDirectory() {
+        try {
+            mkdirSync(dirname(this.filePath), { recursive: true });
+        }
+        catch (error) {
+            // Directory may already exist
+        }
+    }
+    checkAndTruncate() {
+        try {
+            const stats = statSync(this.filePath);
+            if (stats.size > MAX_FILE_SIZE) {
+                truncateSync(this.filePath, 0);
+            }
+        }
+        catch (error) {
+            // File doesn't exist yet, will be created on first write
+        }
+    }
+    writeToFile(level, msg) {
+        this.checkAndTruncate();
+        const entry = {
+            ts: new Date().toISOString(),
+            level,
+            msg,
+        };
+        const line = JSON.stringify(entry) + '\n';
+        try {
+            appendFileSync(this.filePath, line, 'utf-8');
+        }
+        catch (error) {
+            // Silent fail - don't crash app if file logging fails
+        }
+    }
+    error(msg) {
+        if (this.shouldLog('normal')) {
+            this.writeToFile('error', msg);
+        }
+    }
+    warn(msg) {
+        if (this.shouldLog('normal')) {
+            this.writeToFile('warn', msg);
+        }
+    }
+    info(msg) {
+        if (this.shouldLog('verbose')) {
+            this.writeToFile('info', msg);
+        }
+    }
+    debug(msg) {
+        if (this.shouldLog('verbose')) {
+            this.writeToFile('debug', msg);
+        }
+    }
+}

package/dist/logging/index.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from './logger.js';
+import type { LogLevel } from './logger.js';
+import { FileLogger } from './file-logger.js';
+export { Logger, FileLogger };
+export type { LogLevel };
+export declare class CombinedLogger {
+    private stderrLogger;
+    private fileLogger?;
+    constructor(level: LogLevel, colorMode: 'auto' | 'always' | 'never', filePath?: string);
+    error(msg: string): void;
+    warn(msg: string): void;
+    info(msg: string): void;
+    debug(msg: string): void;
+    log(level: 'error' | 'warn' | 'info' | 'debug', msg: string): void;
+}

package/dist/logging/index.js

@@ -0,0 +1,33 @@
+import { Logger } from './logger.js';
+import { FileLogger } from './file-logger.js';
+export { Logger, FileLogger };
+// Multi-target logger that writes to both stderr and file
+export class CombinedLogger {
+    stderrLogger;
+    fileLogger;
+    constructor(level, colorMode, filePath) {
+        this.stderrLogger = new Logger(level, colorMode);
+        if (filePath) {
+            this.fileLogger = new FileLogger(filePath, level);
+        }
+    }
+    error(msg) {
+        this.stderrLogger.error(msg);
+        this.fileLogger?.error(msg);
+    }
+    warn(msg) {
+        this.stderrLogger.warn(msg);
+        this.fileLogger?.warn(msg);
+    }
+    info(msg) {
+        this.stderrLogger.info(msg);
+        this.fileLogger?.info(msg);
+    }
+    debug(msg) {
+        this.stderrLogger.debug(msg);
+        this.fileLogger?.debug(msg);
+    }
+    log(level, msg) {
+        this[level](msg);
+    }
+}

package/dist/logging/logger.d.ts

@@ -0,0 +1,15 @@
+export type LogLevel = 'quiet' | 'normal' | 'verbose';
+export declare class Logger {
+    private level;
+    private colorEnabled;
+    private chalk;
+    constructor(level?: LogLevel, colorMode?: 'auto' | 'always' | 'never');
+    private resolveColorMode;
+    protected shouldLog(messageLevel: LogLevel): boolean;
+    private formatMessage;
+    error(msg: string): void;
+    warn(msg: string): void;
+    info(msg: string): void;
+    debug(msg: string): void;
+    log(level: 'error' | 'warn' | 'info' | 'debug', msg: string): void;
+}

package/dist/logging/logger.js

@@ -0,0 +1,60 @@
+import { Chalk } from 'chalk';
+export class Logger {
+    level;
+    colorEnabled;
+    chalk;
+    constructor(level = 'normal', colorMode = 'auto') {
+        this.level = level;
+        this.colorEnabled = this.resolveColorMode(colorMode);
+        // Create chalk instance with explicit level
+        this.chalk = this.colorEnabled ? new Chalk({ level: 3 }) : new Chalk({ level: 0 });
+    }
+    resolveColorMode(mode) {
+        if (mode === 'never' || process.env.NO_COLOR)
+            return false;
+        if (mode === 'always')
+            return true;
+        // auto: use TTY + TERM check
+        return process.stderr.isTTY && process.env.TERM !== 'dumb';
+    }
+    shouldLog(messageLevel) {
+        const levels = { quiet: 0, normal: 1, verbose: 2 };
+        return levels[messageLevel] <= levels[this.level];
+    }
+    formatMessage(level, msg) {
+        if (!this.colorEnabled)
+            return `[${level.toUpperCase()}] ${msg}`;
+        const prefixMap = {
+            error: this.chalk.red('[ERROR]'),
+            warn: this.chalk.yellow('[WARN]'),
+            info: this.chalk.cyan('[INFO]'),
+            debug: this.chalk.dim('[DEBUG]'),
+        };
+        const prefix = prefixMap[level] || `[${level.toUpperCase()}]`;
+        return `${prefix} ${msg}`;
+    }
+    error(msg) {
+        if (this.shouldLog('normal')) {
+            process.stderr.write(this.formatMessage('error', msg) + '\n');
+        }
+    }
+    warn(msg) {
+        if (this.shouldLog('normal')) {
+            process.stderr.write(this.formatMessage('warn', msg) + '\n');
+        }
+    }
+    info(msg) {
+        if (this.shouldLog('verbose')) {
+            process.stderr.write(this.formatMessage('info', msg) + '\n');
+        }
+    }
+    debug(msg) {
+        if (this.shouldLog('verbose')) {
+            process.stderr.write(this.formatMessage('debug', msg) + '\n');
+        }
+    }
+    // Generic log method
+    log(level, msg) {
+        this[level](msg);
+    }
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// clai - CLI for converting natural language to shell commands
+import { parseCli } from './cli/index.js';
+import { getConfig, ConfigError } from './config/index.js';
+import { gatherContext, ContextError } from './context/index.js';
+import { generateCommands, AIError, buildPrompt, formatPromptForDebug, } from './ai/index.js';
+import { checkSafety, SafetyError } from './safety/index.js';
+import { renderUI, UserAction, withSpinner, printCommand, printWarning, } from './ui/index.js';
+import { executeCommand, ExecutionError } from './output/index.js';
+import { UsageError, InterruptError } from './error/index.js';
+import { registerSignalHandlers, checkInterrupt } from './signals/index.js';
+import { CombinedLogger } from './logging/index.js';
+async function main() {
+    try {
+        // Register signal handlers first
+        registerSignalHandlers();
+        // Parse CLI arguments
+        const cli = parseCli(process.argv);
+        // Load and merge config (file + env + CLI)
+        const config = getConfig(cli);
+        // Determine log level
+        const logLevel = config.quiet
+            ? 'quiet'
+            : config.debug || config.verbose > 0
+                ? 'verbose'
+                : 'normal';
+        // Create logger
+        const logger = new CombinedLogger(logLevel, config.ui.color, config.debugFile);
+        // Handle offline mode (not yet implemented)
+        if (config.offline) {
+            logger.error('Offline mode is not yet supported');
+            process.exit(1);
+        }
+        // Check for interrupts before context gathering
+        checkInterrupt();
+        // Gather context for AI prompt
+        const context = await gatherContext(config);
+        // Debug output
+        if (config.debug) {
+            logger.debug('=== Loaded Config ===');
+            logger.debug(`Provider: ${config.provider.default}`);
+            logger.debug(`Context maxFiles: ${config.context.maxFiles}`);
+            logger.debug(`Context maxHistory: ${config.context.maxHistory}`);
+            logger.debug(`Safety confirmDangerous: ${config.safety.confirmDangerous}`);
+            logger.debug(`UI color: ${config.ui.color}`);
+            logger.debug(`UI interactive: ${config.ui.interactive}`);
+            logger.debug(`UI numOptions: ${config.ui.numOptions}`);
+            logger.debug(`Model: ${config.model || '(default)'}`);
+            logger.debug(`Verbose: ${config.verbose}`);
+            logger.debug(`Dry run: ${config.dryRun}`);
+            logger.debug(`Force: ${config.force}`);
+            logger.debug('===========================');
+            logger.debug('=== Gathered Context ===');
+            logger.debug(`OS: ${context.system.osName} ${context.system.osVersion}`);
+            logger.debug(`Architecture: ${context.system.architecture}`);
+            logger.debug(`Shell: ${context.system.shell}`);
+            logger.debug(`User: ${context.system.user}`);
+            logger.debug(`Memory: ${context.system.totalMemoryMb} MB`);
+            logger.debug(`CWD: ${context.cwd}`);
+            logger.debug(`Files (${context.files.length}):`);
+            context.files
+                .slice(0, 5)
+                .forEach((f) => logger.debug(`  - ${f}`));
+            if (context.files.length > 5) {
+                logger.debug(`  ... and ${context.files.length - 5} more`);
+            }
+            logger.debug(`History (${context.history.length}):`);
+            context.history.forEach((h) => logger.debug(`  - ${h}`));
+            if (context.stdin) {
+                logger.debug(`Stdin: ${context.stdin.substring(0, 100)}${context.stdin.length > 100 ? '...' : ''}`);
+            }
+            else {
+                logger.debug(`Stdin: (none - not piped)`);
+            }
+            logger.debug('===============================');
+            // Show the full prompt being sent to AI
+            const messages = buildPrompt(context, config.instruction, config.ui.numOptions);
+            logger.debug('=== AI Prompt ===');
+            logger.debug(formatPromptForDebug(messages));
+            logger.debug('========================');
+        }
+        // Check for interrupts before AI generation
+        checkInterrupt();
+        // Generate commands from AI (with spinner)
+        const commands = await withSpinner('Thinking...', () => generateCommands(context, config.instruction, config));
+        // Output the generated commands
+        if (config.dryRun) {
+            // Dry-run: show all commands with comments
+            process.stdout.write(`# Generated ${commands.length} command(s):\n`);
+            commands.forEach((cmd, i) => {
+                process.stdout.write(`# Option ${i + 1}:\n${cmd}\n\n`);
+            });
+            process.exit(0);
+        }
+        // Check safety of generated commands
+        const safety = checkSafety(commands, config);
+        if (config.debug) {
+            logger.debug('=== Safety Check ===');
+            logger.debug(`Is dangerous: ${safety.isDangerous}`);
+            logger.debug(`Should prompt: ${safety.shouldPrompt}`);
+            logger.debug('===========================');
+        }
+        // Determine if we should show interactive UI
+        // Always show in TTY mode (we're executing, not just copying)
+        // Skip only if: piped, force flag, or dry-run
+        const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+        const showUI = isTTY && !config.force;
+        let selectedCommand;
+        if (showUI) {
+            // Show interactive UI for command selection
+            const result = await renderUI({
+                commands,
+                config,
+                isDangerous: safety.isDangerous,
+            });
+            if (result.action === UserAction.Abort) {
+                throw new SafetyError('Command execution aborted by user');
+            }
+            selectedCommand = result.command;
+            // Check for interrupts after UI interaction
+            checkInterrupt();
+        }
+        else {
+            // Non-interactive: use first command
+            selectedCommand = commands[0] ?? '';
+            // Show warning for dangerous commands in non-interactive mode
+            if (safety.isDangerous && !config.force) {
+                printWarning('This command may be dangerous. Use -f to skip this warning.');
+            }
+        }
+        // Execute or output the selected command
+        if (selectedCommand) {
+            // Check for interrupts before command execution
+            checkInterrupt();
+            if (showUI) {
+                // Interactive: execute the command
+                const result = await executeCommand(selectedCommand);
+                if (!result.success) {
+                    logger.error(result.error.message);
+                    process.exit(result.error.code);
+                }
+                process.exit(result.exitCode);
+            }
+            else {
+                // Non-interactive (piped): just output the command
+                printCommand(selectedCommand, safety.isDangerous);
+                process.exit(0);
+            }
+        }
+        else {
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        // Note: logger may not be available if error occurs before config loading
+        if (error instanceof UsageError) {
+            process.stderr.write(`Error: ${error.message}\n`);
+            process.stderr.write("Try 'clai --help' for more information.\n");
+            process.exit(error.code);
+        }
+        if (error instanceof ConfigError) {
+            process.stderr.write(`Config error: ${error.message}\n`);
+            process.exit(error.code);
+        }
+        if (error instanceof ContextError) {
+            process.stderr.write(`Context error: ${error.message}\n`);
+            process.exit(error.code);
+        }
+        if (error instanceof AIError) {
+            process.stderr.write(`AI error: ${error.message}\n`);
+            process.exit(error.code);
+        }
+        if (error instanceof SafetyError) {
+            process.stderr.write(`Aborted: ${error.message}\n`);
+            process.exit(error.code);
+        }
+        if (error instanceof ExecutionError) {
+            process.stderr.write(`Execution error: ${error.message}\n`);
+            process.exit(error.code);
+        }
+        if (error instanceof InterruptError) {
+            process.stderr.write(`\n${error.message}\n`);
+            process.exit(error.code);
+        }
+        if (error instanceof Error) {
+            process.stderr.write(`Error: ${error.message}\n`);
+            process.exit(1);
+        }
+        process.exit(1);
+    }
+}
+main();

package/dist/output/execute.d.ts

@@ -0,0 +1,30 @@
+import { type ExecutionResult } from './types.js';
+/**
+ * Get the user's shell from environment, falling back to /bin/sh
+ */
+export declare function getShell(): string;
+/**
+ * Options for command execution
+ */
+export interface ExecuteOptions {
+    /** Shell to use (defaults to user's SHELL or /bin/sh) */
+    shell?: string;
+    /** Timeout in milliseconds (0 = no timeout) */
+    timeout?: number;
+    /** Whether to inherit stdio (default: true for interactive) */
+    inheritStdio?: boolean;
+}
+/**
+ * Execute a shell command and return the result
+ *
+ * Handles various edge cases:
+ * - Empty command → error with code 1
+ * - Recursive clai call → error with code 5 (safety)
+ * - Shell not found → error with code 127
+ * - Command not found → error with code 127
+ * - Permission denied → error with code 126
+ * - Signal termination → error with code 128
+ * - Timeout → error with code 124
+ * - Spawn failure → error with code 1
+ */
+export declare function executeCommand(command: string, options?: ExecuteOptions): Promise<ExecutionResult>;

package/dist/output/execute.js

@@ -0,0 +1,144 @@
+// src/output/execute.ts
+// Command execution with proper error handling and exit code propagation
+import { spawn } from 'child_process';
+import { Errors } from './types.js';
+import { validateCommand } from './validate.js';
+/**
+ * Get the user's shell from environment, falling back to /bin/sh
+ */
+export function getShell() {
+    return process.env.SHELL || '/bin/sh';
+}
+/**
+ * Execute a shell command and return the result
+ *
+ * Handles various edge cases:
+ * - Empty command → error with code 1
+ * - Recursive clai call → error with code 5 (safety)
+ * - Shell not found → error with code 127
+ * - Command not found → error with code 127
+ * - Permission denied → error with code 126
+ * - Signal termination → error with code 128
+ * - Timeout → error with code 124
+ * - Spawn failure → error with code 1
+ */
+export function executeCommand(command, options = {}) {
+    return new Promise((resolve) => {
+        // Validate command first
+        const validation = validateCommand(command);
+        if (!validation.valid) {
+            resolve({ success: false, error: validation.error });
+            return;
+        }
+        const shell = options.shell ?? getShell();
+        const inheritStdio = options.inheritStdio ?? true;
+        let child;
+        let timeoutId;
+        let killed = false;
+        try {
+            child = spawn(shell, ['-c', command], {
+                stdio: inheritStdio ? 'inherit' : 'pipe',
+                env: process.env,
+            });
+        }
+        catch (err) {
+            // Spawn itself threw (rare, but possible)
+            resolve({
+                success: false,
+                error: Errors.spawnFailed(command, err instanceof Error ? err : new Error(String(err))),
+            });
+            return;
+        }
+        // Set up timeout if specified
+        if (options.timeout && options.timeout > 0) {
+            timeoutId = setTimeout(() => {
+                killed = true;
+                child.kill('SIGTERM');
+                // Give it a moment, then SIGKILL if still alive
+                setTimeout(() => {
+                    if (!child.killed) {
+                        child.kill('SIGKILL');
+                    }
+                }, 1000);
+            }, options.timeout);
+        }
+        child.on('close', (code, signal) => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Handle timeout
+            if (killed) {
+                resolve({
+                    success: false,
+                    error: Errors.timeout(options.timeout),
+                });
+                return;
+            }
+            // Handle signal termination
+            if (signal) {
+                resolve({
+                    success: false,
+                    error: Errors.signalKilled(signal),
+                });
+                return;
+            }
+            // Handle exit codes
+            const exitCode = code ?? 0;
+            // Check for special exit codes that indicate errors
+            if (exitCode === 127) {
+                // Could be shell not found or command not found
+                // We can't easily distinguish, so use generic message
+                resolve({
+                    success: false,
+                    error: Errors.commandNotFound(command.split(/\s+/)[0] || command),
+                });
+                return;
+            }
+            if (exitCode === 126) {
+                resolve({
+                    success: false,
+                    error: Errors.permissionDenied(command.split(/\s+/)[0] || command),
+                });
+                return;
+            }
+            // All other exit codes: return as success with the exit code
+            // (The caller decides if non-zero is an error for their use case)
+            resolve({ success: true, exitCode });
+        });
+        child.on('error', (err) => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Check for specific error types
+            const errMsg = err.message.toLowerCase();
+            if (errMsg.includes('enoent') || errMsg.includes('not found')) {
+                // Shell or command not found
+                if (errMsg.includes(shell)) {
+                    resolve({
+                        success: false,
+                        error: Errors.shellNotFound(shell),
+                    });
+                }
+                else {
+                    resolve({
+                        success: false,
+                        error: Errors.commandNotFound(command.split(/\s+/)[0] || command),
+                    });
+                }
+                return;
+            }
+            if (errMsg.includes('eacces') || errMsg.includes('permission')) {
+                resolve({
+                    success: false,
+                    error: Errors.permissionDenied(command.split(/\s+/)[0] || command),
+                });
+                return;
+            }
+            // Generic spawn error
+            resolve({
+                success: false,
+                error: Errors.spawnFailed(command, err),
+            });
+        });
+    });
+}

package/dist/output/index.d.ts

@@ -0,0 +1,4 @@
+export { ExecutionError, Errors, type ExecutionResult, type ValidationResult, } from './types.js';
+export { isRecursiveCall, validateCommand, } from './validate.js';
+export { getShell, executeCommand, type ExecuteOptions, } from './execute.js';
+export { printCommand, printWarning, printError, printSuccess, printInfo, } from '../ui/output.js';