@ribershamoelias/forge 1.0.0

package/dist/core/doctor.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const logger_js_1 = require("../lib/logger.js");
+const version_js_1 = require("../lib/version.js");
+function runDoctor() {
+    logger_js_1.Logger.info('System Status:');
+    let missing = [];
+    let outdated = [];
+    let ok = [];
+    for (const tool of version_js_1.TOOL_VERSION_CHECKS) {
+        const { version, error } = (0, version_js_1.getToolVersion)(tool);
+        if (error) {
+            logger_js_1.Logger.error(`${tool.name} (missing)`, [
+                `Try manually: install ${tool.name}`
+            ]);
+            missing.push(tool.name);
+            continue;
+        }
+        const cmp = (0, version_js_1.compareVersions)(version, tool.recommended);
+        if (cmp < 0) {
+            logger_js_1.Logger.warn(`${tool.name} (${version}, outdated)`);
+            outdated.push(tool.name);
+        }
+        else {
+            logger_js_1.Logger.success(`${tool.name} (${version})`);
+            ok.push(tool.name);
+        }
+    }
+    logger_js_1.Logger.info('');
+    if (missing.length || outdated.length) {
+        logger_js_1.Logger.warn('Some issues detected.');
+        if (missing.length)
+            logger_js_1.Logger.error(`Missing: ${missing.join(', ')}`);
+        if (outdated.length)
+            logger_js_1.Logger.warn(`Outdated: ${outdated.join(', ')}`);
+        logger_js_1.Logger.info('To fix, run: forge setup --preset web-dev');
+    }
+    else {
+        logger_js_1.Logger.success('All essential tools are installed and up to date!');
+    }
+}

package/dist/core/list.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runList = runList;
+const logger_js_1 = require("../lib/logger.js");
+const version_js_1 = require("../lib/version.js");
+function runList() {
+    logger_js_1.Logger.info('Listing installed tools:');
+    for (const tool of version_js_1.TOOL_VERSION_CHECKS) {
+        const { version, error } = (0, version_js_1.getToolVersion)(tool);
+        if (error) {
+            logger_js_1.Logger.error(`${tool.name}: Not installed`);
+            continue;
+        }
+        const cmp = (0, version_js_1.compareVersions)(version, tool.recommended);
+        if (cmp < 0) {
+            logger_js_1.Logger.warn(`${tool.name}: ${version} (outdated, recommended: ${tool.recommended})`);
+        }
+        else {
+            logger_js_1.Logger.success(`${tool.name}: ${version} (OK)`);
+        }
+    }
+}

package/dist/core/profile.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveProfile = saveProfile;
+exports.listProfiles = listProfiles;
+exports.applyProfile = applyProfile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const logger_js_1 = require("../lib/logger.js");
+const version_js_1 = require("../lib/version.js");
+const tools_js_1 = require("../lib/tools.js");
+const terminal_js_1 = require("../lib/terminal.js");
+const PROFILE_DIR = path_1.default.join(os_1.default.homedir(), '.forge', 'profiles');
+function ensureProfileDir() {
+    if (!fs_extra_1.default.existsSync(PROFILE_DIR))
+        fs_extra_1.default.mkdirpSync(PROFILE_DIR);
+}
+async function saveProfile(name) {
+    ensureProfileDir();
+    logger_js_1.Logger.info(`Saving profile: ${name}`);
+    // Detect installed tools and versions
+    const tools = version_js_1.TOOL_VERSION_CHECKS.map(tool => {
+        const { version } = (0, version_js_1.getToolVersion)(tool);
+        return { name: tool.name, version: version || null };
+    });
+    // Detect shell and aliases
+    const shell = process.env.SHELL?.split('/').pop() || 'zsh';
+    const rcFile = shell === 'zsh' ? '.zshrc' : '.bashrc';
+    const rcPath = path_1.default.join(os_1.default.homedir(), rcFile);
+    let aliases = {};
+    if (fs_extra_1.default.existsSync(rcPath)) {
+        const content = fs_extra_1.default.readFileSync(rcPath, 'utf8');
+        const aliasLines = content.split('\n').filter(l => l.trim().startsWith('alias '));
+        for (const line of aliasLines) {
+            const match = line.match(/^alias (\w+)='(.+)'$/);
+            if (match)
+                aliases[match[1]] = match[2];
+        }
+    }
+    const profile = {
+        tools,
+        terminal: {
+            shell,
+            aliases
+        },
+        created: new Date().toISOString()
+    };
+    const filePath = path_1.default.join(PROFILE_DIR, `${name}.json`);
+    fs_extra_1.default.writeJsonSync(filePath, profile, { spaces: 2 });
+    logger_js_1.Logger.success(`Profile saved: ${filePath}`);
+}
+function listProfiles() {
+    ensureProfileDir();
+    const files = fs_extra_1.default.readdirSync(PROFILE_DIR).filter(f => f.endsWith('.json'));
+    if (!files.length) {
+        logger_js_1.Logger.info('No profiles found');
+        logger_js_1.Logger.info('→ Run `forge profile save <name>` to create one');
+        return;
+    }
+    logger_js_1.Logger.info('Available profiles:');
+    for (const file of files) {
+        const full = path_1.default.join(PROFILE_DIR, file);
+        const data = fs_extra_1.default.readJsonSync(full);
+        logger_js_1.Logger.info(`- ${file.replace('.json', '')} (created: ${data.created})`);
+    }
+}
+async function applyProfile(name) {
+    ensureProfileDir();
+    const filePath = path_1.default.join(PROFILE_DIR, `${name}.json`);
+    if (!fs_extra_1.default.existsSync(filePath)) {
+        logger_js_1.Logger.error(`Profile not found: ${name}`);
+        return;
+    }
+    logger_js_1.Logger.info(`Applying profile: ${name}`);
+    const profile = fs_extra_1.default.readJsonSync(filePath);
+    // Step 1: Install missing tools
+    logger_js_1.Logger.step('Installing missing tools...', 1, 3);
+    let allToolsOk = true;
+    for (const tool of profile.tools) {
+        // Find tool check definition
+        const check = version_js_1.TOOL_VERSION_CHECKS.find(t => t.name === tool.name);
+        if (!check) {
+            logger_js_1.Logger.warn(`Unknown tool in profile: ${tool.name}`);
+            continue;
+        }
+        const { version: currentVersion, error } = (0, version_js_1.getToolVersion)(check);
+        if (error) {
+            // Not installed, install
+            const ok = await (0, tools_js_1.installTool)(tool.name, { os: os_1.default.platform(), pkg: detectPkgMgr(), dryRun: false });
+            if (!ok) {
+                logger_js_1.Logger.error(`Failed to install ${tool.name}`, [
+                    `Try manually: brew install ${tool.name}`
+                ]);
+                allToolsOk = false;
+            }
+        }
+        else {
+            // Already installed, check version
+            if (tool.version && currentVersion && (0, version_js_1.compareVersions)(currentVersion, tool.version) !== 0) {
+                logger_js_1.Logger.warn(`${tool.name} version differs (profile: ${tool.version}, current: ${currentVersion})`);
+            }
+        }
+    }
+    // Step 2: Apply terminal config
+    logger_js_1.Logger.step('Configuring terminal...', 2, 3);
+    try {
+        await (0, terminal_js_1.setupTerminal)(profile.terminal, false);
+        logger_js_1.Logger.success('Aliases and terminal config applied');
+    }
+    catch (e) {
+        logger_js_1.Logger.error('Failed to apply terminal config', [e.message]);
+        allToolsOk = false;
+    }
+    // Step 3: Finalizing
+    logger_js_1.Logger.step('Finalizing...', 3, 3);
+    if (allToolsOk) {
+        logger_js_1.Logger.success('Profile applied successfully');
+    }
+    else {
+        logger_js_1.Logger.warn('Profile applied with some issues. See above.');
+    }
+}
+// Helper to detect package manager (reuse from setup if possible)
+function detectPkgMgr() {
+    // Simple detection for demo; in real code, reuse detectPackageManager from setup
+    if (fs_extra_1.default.existsSync('/opt/homebrew/bin/brew') || fs_extra_1.default.existsSync('/usr/local/bin/brew'))
+        return 'brew';
+    if (fs_extra_1.default.existsSync('/usr/bin/apt'))
+        return 'apt';
+    if (fs_extra_1.default.existsSync('/usr/bin/pacman'))
+        return 'pacman';
+    return 'brew';
+}

package/dist/core/setup.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetup = runSetup;
+const detect_js_1 = require("../lib/detect.js");
+const config_js_1 = require("../lib/config.js");
+const logger_js_1 = require("../lib/logger.js");
+const tools_js_1 = require("../lib/tools.js");
+const editor_js_1 = require("../lib/editor.js");
+const terminal_js_1 = require("../lib/terminal.js");
+async function runSetup(opts) {
+    logger_js_1.Logger.info('Forge setup (Unix-only)');
+    const totalTimer = new logger_js_1.Logger.Timer();
+    let config = (0, config_js_1.loadConfig)();
+    if (opts.preset) {
+        config = (0, config_js_1.mergePreset)(config, opts.preset);
+        logger_js_1.Logger.info(`Using preset: ${opts.preset}`);
+    }
+    const os = (0, detect_js_1.detectOS)();
+    const pkg = (0, detect_js_1.detectPackageManager)();
+    const ctx = { os, pkg, dryRun: !!opts.dryRun };
+    const steps = [
+        ...config.tools.map((tool) => ({ type: 'tool', name: tool })),
+        { type: 'editor', name: 'Configuring editor' },
+        { type: 'terminal', name: 'Configuring terminal' },
+    ];
+    const totalSteps = steps.length;
+    const installed = [];
+    const warnings = [];
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        const stepTimer = new logger_js_1.Logger.Timer();
+        if (step.type === 'tool') {
+            logger_js_1.Logger.step(`Installing ${step.name}`, i + 1, totalSteps);
+            const ok = await (0, tools_js_1.installTool)(step.name, ctx);
+            if (!ok) {
+                logger_js_1.Logger.error(`Failed to install ${step.name}`, [
+                    'Check your internet connection',
+                    `Try manually: ${pkg} install ${step.name}`
+                ]);
+                warnings.push(step.name);
+            }
+            else {
+                installed.push(step.name);
+            }
+        }
+        else if (step.type === 'editor') {
+            logger_js_1.Logger.step('Configuring editor', i + 1, totalSteps);
+            await (0, editor_js_1.setupEditor)(config.editor, ctx.dryRun);
+            logger_js_1.Logger.success('Editor configured', stepTimer.elapsed());
+        }
+        else if (step.type === 'terminal') {
+            logger_js_1.Logger.step('Configuring terminal', i + 1, totalSteps);
+            await (0, terminal_js_1.setupTerminal)(config.terminal, ctx.dryRun);
+            logger_js_1.Logger.success('Terminal configured', stepTimer.elapsed());
+        }
+    }
+    // Final summary
+    logger_js_1.Logger.success(`Setup complete in ${totalTimer.elapsed()}`);
+    if (installed.length)
+        logger_js_1.Logger.info(`Installed: ${installed.join(', ')}`);
+    if (warnings.length)
+        logger_js_1.Logger.warn(`Warnings: ${warnings.length}`);
+    // Smart suggestions
+    if (!installed.length) {
+        logger_js_1.Logger.info('Tip: Try `forge setup --preset web-dev`');
+    }
+}

package/dist/lib/config.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.mergePreset = mergePreset;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+function loadConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), 'forge.json');
+    if (!fs_extra_1.default.existsSync(configPath))
+        throw new Error('forge.json not found');
+    return fs_extra_1.default.readJsonSync(configPath);
+}
+function mergePreset(config, presetName) {
+    const presetPath = path_1.default.resolve(process.cwd(), 'presets', `${presetName}.json`);
+    if (!fs_extra_1.default.existsSync(presetPath))
+        throw new Error(`Preset ${presetName} not found`);
+    const preset = fs_extra_1.default.readJsonSync(presetPath);
+    return { ...config, ...preset };
+}

package/dist/lib/detect.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOS = detectOS;
+exports.detectPackageManager = detectPackageManager;
+const child_process_1 = require("child_process");
+function detectOS() {
+    const platform = process.platform;
+    if (platform === 'darwin')
+        return 'macos';
+    if (platform === 'linux')
+        return 'linux';
+    console.error('Forge only supports macOS and Linux.');
+    process.exit(1);
+}
+function detectPackageManager() {
+    // Only support brew (macOS), apt/pacman (Linux)
+    try {
+        (0, child_process_1.execSync)('which brew', { stdio: 'ignore' });
+        return 'brew';
+    }
+    catch { }
+    try {
+        (0, child_process_1.execSync)('which apt', { stdio: 'ignore' });
+        return 'apt';
+    }
+    catch { }
+    try {
+        (0, child_process_1.execSync)('which pacman', { stdio: 'ignore' });
+        return 'pacman';
+    }
+    catch { }
+    console.error('No supported package manager found (brew, apt, pacman).');
+    process.exit(1);
+}

package/dist/lib/editor.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupEditor = setupEditor;
+const logger_js_1 = require("./logger.js");
+const child_process_1 = require("child_process");
+async function setupEditor(editorConfig, dryRun) {
+    if (editorConfig.name !== 'vscode') {
+        logger_js_1.Logger.warn('Only VS Code is supported for now.');
+        return;
+    }
+    // Check if VS Code is already installed
+    let vsCodeInstalled = false;
+    if (process.platform === 'darwin') {
+        // Check for app bundle
+        try {
+            (0, child_process_1.execSync)('test -d "/Applications/Visual Studio Code.app"');
+            vsCodeInstalled = true;
+        }
+        catch { }
+    }
+    else if (process.platform === 'linux') {
+        try {
+            (0, child_process_1.execSync)('command -v code');
+            vsCodeInstalled = true;
+        }
+        catch { }
+    }
+    if (vsCodeInstalled) {
+        logger_js_1.Logger.success('VS Code already installed');
+    }
+    else {
+        let cmd = '';
+        if (process.platform === 'darwin') {
+            cmd = 'brew install --cask visual-studio-code';
+        }
+        else if (process.platform === 'linux') {
+            cmd = 'sudo snap install --classic code || sudo apt-get install -y code';
+        }
+        if (dryRun) {
+            logger_js_1.Logger.info(`[dry-run] Would run: ${cmd}`);
+        }
+        else {
+            try {
+                // Suppress brew warnings by capturing output
+                (0, child_process_1.execSync)(cmd, { stdio: 'pipe' });
+                logger_js_1.Logger.success('VS Code installed');
+            }
+            catch (e) {
+                // If already installed, treat as success
+                const msg = e?.stdout?.toString() || e?.message || '';
+                if (/already installed|already exists|is already installed/i.test(msg)) {
+                    logger_js_1.Logger.success('VS Code already installed');
+                }
+                else {
+                    logger_js_1.Logger.error('Failed to install VS Code', [
+                        'Check your internet connection',
+                        'Try manually: brew install --cask visual-studio-code'
+                    ]);
+                }
+            }
+        }
+    }
+    // Install extensions
+    for (const ext of editorConfig.extensions || []) {
+        let extInstalled = false;
+        if (!dryRun) {
+            try {
+                // Check if extension is already installed
+                const list = (0, child_process_1.execSync)('code --list-extensions', { encoding: 'utf8' });
+                if (list.split('\n').includes(ext)) {
+                    extInstalled = true;
+                }
+            }
+            catch { }
+        }
+        if (dryRun) {
+            logger_js_1.Logger.info(`[dry-run] Would run: code --install-extension ${ext}`);
+        }
+        else if (extInstalled) {
+            logger_js_1.Logger.success(`Extension ${ext} already installed`);
+        }
+        else {
+            try {
+                // Suppress warnings by capturing output
+                (0, child_process_1.execSync)(`code --install-extension ${ext}`, { stdio: 'pipe' });
+                logger_js_1.Logger.success(`Extension ${ext} installed`);
+            }
+            catch (e) {
+                const msg = e?.stdout?.toString() || e?.message || '';
+                if (/already installed|already exists|is already installed/i.test(msg)) {
+                    logger_js_1.Logger.success(`Extension ${ext} already installed`);
+                }
+                else {
+                    logger_js_1.Logger.error(`Failed to install extension ${ext}`, [
+                        'Check your internet connection',
+                        `Try manually: code --install-extension ${ext}`
+                    ]);
+                }
+            }
+        }
+    }
+}

package/dist/lib/exec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const logger_js_1 = require("./logger.js");
+const child_process_1 = require("child_process");
+function runCommand(command, options = {}) {
+    logger_js_1.Logger.info(`${options.dryRun ? '[dry-run] ' : ''}Running: ${command}`);
+    if (options.dryRun)
+        return true;
+    try {
+        (0, child_process_1.execSync)(command, { stdio: options.stdio || 'inherit', cwd: options.cwd });
+        return true;
+    }
+    catch (e) {
+        logger_js_1.Logger.error(`Command failed: ${command}`, [
+            'Check your internet connection',
+            'Try running the command manually for more details.'
+        ]);
+        return false;
+    }
+}

package/dist/lib/logger.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.setLogLevel = setLogLevel;
+const chalk_1 = __importDefault(require("chalk"));
+const timer_js_1 = require("./timer.js");
+let logLevel = 'normal';
+function setLogLevel(level) {
+    logLevel = level;
+}
+function shouldLog(type) {
+    if (logLevel === 'silent')
+        return type === 'error';
+    if (logLevel === 'normal')
+        return type !== 'info' || type === 'info';
+    return true;
+}
+function icon(type) {
+    switch (type) {
+        case 'success': return chalk_1.default.green('✔');
+        case 'error': return chalk_1.default.red('✖');
+        case 'warn': return chalk_1.default.yellow('⚠');
+        case 'info': return chalk_1.default.blue('ℹ');
+    }
+}
+class Logger {
+    static info(msg) {
+        if (!shouldLog('info'))
+            return;
+        console.log(`${icon('info')} ${msg}`);
+    }
+    static step(msg, current, total, timing) {
+        if (!shouldLog('step'))
+            return;
+        if (typeof current === 'number' && typeof total === 'number') {
+            // Align step numbers for up to 99 steps
+            const pad = (n) => n.toString().padStart(2, ' ');
+            const time = timing ? chalk_1.default.gray(`(${timing})`) : '';
+            console.log(chalk_1.default.cyan(`[${pad(current)}/${pad(total)}]`), msg, time);
+        }
+        else {
+            console.log(chalk_1.default.cyan('→'), msg);
+        }
+    }
+    static success(msg, timing) {
+        if (!shouldLog('success'))
+            return;
+        const time = timing ? chalk_1.default.gray(`(${timing})`) : '';
+        console.log(`${icon('success')} ${msg} ${time}`.trim());
+    }
+    static warn(msg) {
+        if (!shouldLog('warn'))
+            return;
+        console.log(`${icon('warn')} ${msg}`);
+    }
+    static error(msg, suggestions) {
+        if (!shouldLog('error'))
+            return;
+        // Only log the main error message, never stack traces or raw error objects
+        console.error(`${icon('error')} ${msg}`);
+        if (suggestions && suggestions.length) {
+            for (const s of suggestions) {
+                console.error(chalk_1.default.gray('→'), s);
+            }
+        }
+    }
+    static verbose(msg) {
+        if (logLevel === 'verbose') {
+            console.log(chalk_1.default.gray(msg));
+        }
+    }
+}
+exports.Logger = Logger;
+Logger.Timer = timer_js_1.Timer;

package/dist/lib/terminal.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTerminal = setupTerminal;
+const logger_js_1 = require("./logger.js");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function detectUserShell() {
+    const shellEnv = process.env.SHELL || '';
+    if (shellEnv.includes('zsh'))
+        return 'zsh';
+    if (shellEnv.includes('bash'))
+        return 'bash';
+    // Fallback: check for .zshrc, then .bashrc
+    const home = os_1.default.homedir();
+    if (fs_extra_1.default.existsSync(path_1.default.join(home, '.zshrc')))
+        return 'zsh';
+    if (fs_extra_1.default.existsSync(path_1.default.join(home, '.bashrc')))
+        return 'bash';
+    return 'zsh'; // Default to zsh
+}
+function ensureLineInFile(filePath, line) {
+    const content = fs_extra_1.default.existsSync(filePath) ? fs_extra_1.default.readFileSync(filePath, 'utf8') : '';
+    if (!content.includes(line)) {
+        fs_extra_1.default.appendFileSync(filePath, line + '\n');
+    }
+}
+async function setupTerminal(terminalConfig, dryRun) {
+    const shell = terminalConfig.shell || detectUserShell();
+    const home = os_1.default.homedir();
+    const rcFile = shell === 'zsh' ? '.zshrc' : '.bashrc';
+    const rcPath = path_1.default.join(home, rcFile);
+    // Backup
+    if (!dryRun && fs_extra_1.default.existsSync(rcPath)) {
+        fs_extra_1.default.copySync(rcPath, rcPath + '.forge.bak');
+        logger_js_1.Logger.info(`Backed up ${rcFile} to ${rcFile}.forge.bak`);
+    }
+    // Add aliases (idempotent)
+    const aliases = terminalConfig.aliases || {};
+    for (const [k, v] of Object.entries(aliases)) {
+        const aliasLine = `alias ${k}='${v}'`;
+        if (dryRun) {
+            logger_js_1.Logger.info(`[dry-run] Would add alias to ${rcFile}: ${aliasLine}`);
+        }
+        else {
+            ensureLineInFile(rcPath, aliasLine);
+            logger_js_1.Logger.success(`Alias added: ${aliasLine}`);
+        }
+    }
+    // Add PATH handling if specified
+    if (terminalConfig.PATH && typeof terminalConfig.PATH === 'string') {
+        const exportLine = `export PATH="${terminalConfig.PATH}:$PATH"`;
+        if (dryRun) {
+            logger_js_1.Logger.info(`[dry-run] Would add to PATH in ${rcFile}: ${exportLine}`);
+        }
+        else {
+            ensureLineInFile(rcPath, exportLine);
+            logger_js_1.Logger.success(`PATH updated in ${rcFile}`);
+        }
+    }
+    logger_js_1.Logger.info(`Terminal configuration complete for ${rcFile}`);
+}

package/dist/lib/timer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor() {
+        this.startTime = Date.now();
+    }
+    elapsed() {
+        const ms = Date.now() - this.startTime;
+        if (ms < 1000)
+            return `${ms}ms`;
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+}
+exports.Timer = Timer;

package/dist/lib/tools.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installTool = installTool;
+const logger_js_1 = require("./logger.js");
+const child_process_1 = require("child_process");
+const toolInstallers = {
+    git: (ctx) => installViaPkg('git', ctx),
+    node: (ctx) => installViaPkg('node', ctx),
+    python: (ctx) => installViaPkg('python3', ctx),
+    docker: (ctx) => installViaPkg('docker', ctx),
+    zsh: (ctx) => installViaPkg('zsh', ctx),
+};
+function installViaPkg(tool, ctx) {
+    // Check if tool is already installed
+    let checkCmd = '';
+    if (tool === 'python3' || tool === 'python')
+        checkCmd = 'python3 --version';
+    else
+        checkCmd = `${tool} --version`;
+    let alreadyInstalled = false;
+    try {
+        (0, child_process_1.execSync)(checkCmd, { stdio: 'ignore' });
+        alreadyInstalled = true;
+    }
+    catch { }
+    if (alreadyInstalled) {
+        logger_js_1.Logger.success(`${tool.replace('python3', 'python')} already installed`);
+        return true;
+    }
+    let cmd = '';
+    if (ctx.pkg === 'brew')
+        cmd = `brew install ${tool}`;
+    else if (ctx.pkg === 'apt')
+        cmd = `sudo apt-get update && sudo apt-get install -y ${tool}`;
+    else if (ctx.pkg === 'pacman')
+        cmd = `sudo pacman -Sy --noconfirm ${tool}`;
+    else
+        throw new Error('Unsupported package manager');
+    logger_js_1.Logger.info(`Installing ${tool} using ${ctx.pkg}...`);
+    try {
+        // Suppress brew/apt/pacman warnings by capturing output
+        (0, child_process_1.execSync)(cmd, { stdio: 'pipe' });
+        logger_js_1.Logger.success(`${tool.replace('python3', 'python')} installed`);
+        return true;
+    }
+    catch (e) {
+        const msg = e?.stdout?.toString() || e?.message || '';
+        if (/already installed|already exists|is already installed/i.test(msg)) {
+            logger_js_1.Logger.success(`${tool.replace('python3', 'python')} already installed`);
+            return true;
+        }
+        logger_js_1.Logger.error(`Failed to install ${tool}`, [
+            'Check your internet connection',
+            `Try manually: ${cmd}`
+        ]);
+        return false;
+    }
+}
+async function installTool(tool, ctx) {
+    if (toolInstallers[tool]) {
+        return toolInstallers[tool](ctx);
+    }
+    else {
+        logger_js_1.Logger.warn(`No installer for tool: ${tool}`);
+        return false;
+    }
+}