@ribershamoelias/forge 1.0.2 → 1.0.3

package/README.md

@@ -271,7 +271,7 @@ Presets live in `presets/` and are merged with the base config at runtime. You c
 **From source:**
 
 ```bash
-git clone https://github.com/yourusername/forge
+git clone https://github.com/ribershamoelias/Forge
 cd forge
 npm install
 npm run build
@@ -392,3 +392,61 @@ Configure once. Reproduce anywhere.
 If Forge saves you time, a ⭐ goes a long way — it helps more people find it.
 
 </div>
+
+---
+
+## 🏗️ Phase 1: Production-Ready CLI Improvements
+
+### Key Functions & Features Implemented
+
+#### 1. `forge init`
+- **Purpose:** Interactive project bootstrapper. No manual `forge.json` needed.
+- **How:**
+  - Prompts for project type, Docker, and VS Code extension install.
+  - Loads preset (from `presets/`) and merges user choices.
+  - Writes a valid `forge.json` in the current directory.
+  - **Command:** `forge init`
+
+#### 2. Premium Setup UX
+- **No duplicate logs:** Only one success per step.
+- **Already installed detection:**
+  - Tools and VS Code are checked before install.
+  - Output: `✔ git already installed` (not "Installing git...")
+- **Suppressed noisy output:**
+  - Only shown if `--verbose` is enabled or on error.
+- **Clean step display:**
+  - `[1/7] git` (not `[ 1/ 7] Installing git`)
+  - Success: `✔ git already installed (1.2s)`
+- **Final summary:**
+  - `✔ Setup complete in 27.2s`
+  - `✔ 5 tools verified`
+  - `✔ 0 installed`
+  - `⚠ 0 warnings`
+
+#### 3. Idempotency & Robustness
+- **No duplicate aliases or tool reinstalls.**
+- **Safe system changes:** Always checks before modifying.
+- **No stack traces:** Only actionable, user-friendly errors.
+
+#### 4. `forge doctor --fix`
+- **Purpose:** Diagnose and auto-fix missing/outdated tools.
+- **Behavior:**
+  - Installs missing tools automatically.
+  - Offers to upgrade outdated tools.
+  - Clear, premium UX summary.
+  - **Command:** `forge doctor --fix`
+
+#### 5. Centralized Logging & Async/Await
+- **All output via logger system.**
+- **No `console.log` outside logger.**
+- **All async/await for reliability.**
+
+#### 6. Modular, Extensible Codebase
+- **Each feature in its own file:**
+  - `src/core/init.ts` — `forge init`
+  - `src/core/setup.ts` — setup logic
+  - `src/core/doctor.ts` — diagnostics
+  - `src/lib/tools.ts` — tool install logic
+  - `src/lib/editor.ts` — editor/extension install
+  - `src/lib/logger.ts` — all output
+

package/dist/cli.js

@@ -5,6 +5,7 @@ const setup_js_1 = require("./core/setup.js");
 const doctor_js_1 = require("./core/doctor.js");
 const clean_js_1 = require("./core/clean.js");
 const list_js_1 = require("./core/list.js");
+const init_js_1 = require("./core/init.js");
 const logger_js_1 = require("./lib/logger.js");
 const profile_js_1 = require("./core/profile.js");
 const program = new commander_1.Command();
@@ -16,6 +17,18 @@ profile
     const parent = cmd.parent?.parent || program;
     if (parent.opts().silent)
         (0, logger_js_1.setLogLevel)('silent');
+    program
+        .command('init')
+        .description('Initialize Forge in this project')
+        .action(async () => {
+        try {
+            await (0, init_js_1.runInit)();
+        }
+        catch (err) {
+            const msg = (err && typeof err === 'object' && 'message' in err) ? err.message : String(err);
+            logger_js_1.Logger.error('✖ Failed to initialize Forge', [msg]);
+        }
+    });
     if (parent.opts().verbose)
         (0, logger_js_1.setLogLevel)('verbose');
     await (0, profile_js_1.saveProfile)(name);
@@ -64,13 +77,14 @@ program
 program
     .command('doctor')
     .description('Check your system for issues')
-    .action((opts, cmd) => {
+    .option('--fix', 'Automatically fix issues')
+    .action(async (opts, cmd) => {
     const parent = cmd.parent || program;
     if (parent.opts().silent)
         (0, logger_js_1.setLogLevel)('silent');
     if (parent.opts().verbose)
         (0, logger_js_1.setLogLevel)('verbose');
-    (0, doctor_js_1.runDoctor)();
+    await (0, doctor_js_1.runDoctor)({ fix: opts.fix });
 });
 program
     .command('clean')

package/dist/core/doctor.js

@@ -3,11 +3,18 @@ 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() {
+const tools_js_1 = require("../lib/tools.js");
+const detect_js_1 = require("../lib/detect.js");
+async function runDoctor(opts) {
     logger_js_1.Logger.info('System Status:');
     let missing = [];
     let outdated = [];
     let ok = [];
+    let fixed = [];
+    let upgraded = [];
+    const os = (0, detect_js_1.detectOS)();
+    const pkg = (0, detect_js_1.detectPackageManager)();
+    const ctx = { os, pkg, dryRun: false };
     for (const tool of version_js_1.TOOL_VERSION_CHECKS) {
         const { version, error } = (0, version_js_1.getToolVersion)(tool);
         if (error) {
@@ -15,12 +22,37 @@ function runDoctor() {
                 `Try manually: install ${tool.name}`
             ]);
             missing.push(tool.name);
+            if (opts?.fix) {
+                logger_js_1.Logger.info(`→ Installing ${tool.name}...`);
+                const result = await (0, tools_js_1.installTool)(tool.name, ctx);
+                if (result === true || result === 'already') {
+                    logger_js_1.Logger.success(`${tool.name} installed`);
+                    fixed.push(tool.name);
+                }
+                else {
+                    logger_js_1.Logger.error(`Failed to install ${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);
+            if (opts?.fix) {
+                logger_js_1.Logger.info(`→ Updating ${tool.name}...`);
+                const result = await (0, tools_js_1.installTool)(tool.name, ctx);
+                if (result === true) {
+                    logger_js_1.Logger.success(`${tool.name} updated`);
+                    upgraded.push(tool.name);
+                }
+                else if (result === 'already') {
+                    logger_js_1.Logger.success(`${tool.name} already up to date`);
+                }
+                else {
+                    logger_js_1.Logger.error(`Failed to update ${tool.name}`);
+                }
+            }
         }
         else {
             logger_js_1.Logger.success(`${tool.name} (${version})`);
@@ -34,9 +66,17 @@ function runDoctor() {
             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');
+        if (!opts?.fix) {
+            logger_js_1.Logger.info('To fix, run: forge doctor --fix');
+        }
     }
     else {
         logger_js_1.Logger.success('All essential tools are installed and up to date!');
     }
+    if (opts?.fix) {
+        logger_js_1.Logger.success('✔ System is now fully healthy');
+        logger_js_1.Logger.success(`${ok.length + fixed.length + upgraded.length} tools verified`);
+        logger_js_1.Logger.success(`${fixed.length + upgraded.length} fixed/updated`);
+        logger_js_1.Logger.success('0 warnings');
+    }
 }

package/dist/core/init.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const inquirer = __importStar(require("inquirer"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const logger_js_1 = require("../lib/logger.js");
+const PRESETS = {
+    backend: 'presets/backend.json',
+    frontend: 'presets/web-dev.json',
+    fullstack: 'presets/minimal.json', // Placeholder, update if you have a fullstack preset
+    minimal: 'presets/minimal.json',
+};
+async function loadPreset(presetKey) {
+    const presetPath = path_1.default.resolve(process.cwd(), PRESETS[presetKey]);
+    const data = await promises_1.default.readFile(presetPath, 'utf8');
+    return JSON.parse(data);
+}
+async function writeForgeJson(config) {
+    const outPath = path_1.default.resolve(process.cwd(), 'forge.json');
+    await promises_1.default.writeFile(outPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+}
+async function runInit() {
+    logger_js_1.Logger.info('Welcome to Forge Init!');
+    const { projectType, useDocker, installExtensions } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'projectType',
+            message: 'Select project type:',
+            choices: [
+                { name: 'Backend (Node)', value: 'backend' },
+                { name: 'Frontend (React)', value: 'frontend' },
+                { name: 'Fullstack', value: 'fullstack' },
+                { name: 'Minimal', value: 'minimal' },
+            ],
+        },
+        {
+            type: 'confirm',
+            name: 'useDocker',
+            message: 'Use Docker?',
+            default: false,
+        },
+        {
+            type: 'confirm',
+            name: 'installExtensions',
+            message: 'Install VS Code extensions?',
+            default: true,
+        },
+    ]);
+    const preset = await loadPreset(projectType);
+    const config = {
+        ...preset,
+        docker: useDocker,
+        extensions: installExtensions,
+    };
+    await writeForgeJson(config);
+    logger_js_1.Logger.success('✔ Forge initialized successfully');
+    logger_js_1.Logger.info('ℹ Created forge.json');
+    logger_js_1.Logger.info('→ Run `forge setup` to install your environment');
+}

package/dist/core/setup.js

@@ -25,43 +25,49 @@ async function runSetup(opts) {
     ];
     const totalSteps = steps.length;
     const installed = [];
+    const already = [];
     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.step(`${step.name}`, i + 1, totalSteps);
+            const result = await (0, tools_js_1.installTool)(step.name, ctx);
+            if (result === 'already') {
+                logger_js_1.Logger.success(`${step.name} already installed`, stepTimer.elapsed());
+                already.push(step.name);
+            }
+            else if (result === true) {
+                logger_js_1.Logger.success(`${step.name} installed`, stepTimer.elapsed());
+                installed.push(step.name);
+            }
+            else {
                 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);
+            logger_js_1.Logger.step('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);
+            logger_js_1.Logger.step('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`');
+    logger_js_1.Logger.success(`${already.length + installed.length} tools verified`);
+    logger_js_1.Logger.success(`${installed.length} installed`);
+    if (warnings.length) {
+        logger_js_1.Logger.warn(`${warnings.length} warnings`);
+    }
+    else {
+        logger_js_1.Logger.success('0 warnings');
     }
 }

package/dist/lib/editor.js

@@ -8,23 +8,20 @@ async function setupEditor(editorConfig, dryRun) {
         logger_js_1.Logger.warn('Only VS Code is supported for now.');
         return;
     }
-    // Check if VS Code is already installed
+    // Check if VS Code is already installed (macOS: app bundle or 'code' in PATH)
     let vsCodeInstalled = false;
-    if (process.platform === 'darwin') {
-        // Check for app bundle
-        try {
+    try {
+        if (process.platform === 'darwin') {
             (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 { }
+    catch { }
+    try {
+        (0, child_process_1.execSync)('command -v code');
+        vsCodeInstalled = true;
     }
+    catch { }
     if (vsCodeInstalled) {
         logger_js_1.Logger.success('VS Code already installed');
     }
@@ -41,12 +38,10 @@ async function setupEditor(editorConfig, dryRun) {
         }
         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');
@@ -81,7 +76,6 @@ async function setupEditor(editorConfig, dryRun) {
         }
         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`);
             }

package/dist/lib/exec.js

@@ -4,11 +4,15 @@ 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}`);
+    // Only log command if verbose
+    const verbose = process.env.FORGE_VERBOSE === '1' || options.stdio === 'inherit';
+    if (verbose) {
+        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 });
+        (0, child_process_1.execSync)(command, { stdio: verbose ? 'inherit' : 'pipe', cwd: options.cwd });
         return true;
     }
     catch (e) {
@@ -16,6 +20,12 @@ function runCommand(command, options = {}) {
             'Check your internet connection',
             'Try running the command manually for more details.'
         ]);
+        if (!verbose && e?.stdout) {
+            logger_js_1.Logger.info(e.stdout.toString());
+        }
+        if (!verbose && e?.stderr) {
+            logger_js_1.Logger.info(e.stderr.toString());
+        }
         return false;
     }
 }

package/dist/lib/tools.js

@@ -10,8 +10,7 @@ const toolInstallers = {
     docker: (ctx) => installViaPkg('docker', ctx),
     zsh: (ctx) => installViaPkg('zsh', ctx),
 };
-function installViaPkg(tool, ctx) {
-    // Check if tool is already installed
+async function installViaPkg(tool, ctx) {
     let checkCmd = '';
     if (tool === 'python3' || tool === 'python')
         checkCmd = 'python3 --version';
@@ -24,8 +23,7 @@ function installViaPkg(tool, ctx) {
     }
     catch { }
     if (alreadyInstalled) {
-        logger_js_1.Logger.success(`${tool.replace('python3', 'python')} already installed`);
-        return true;
+        return 'already';
     }
     let cmd = '';
     if (ctx.pkg === 'brew')
@@ -36,29 +34,21 @@ function installViaPkg(tool, ctx) {
         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;
+            return 'already';
         }
-        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);
+        return await toolInstallers[tool](ctx);
     }
     else {
         logger_js_1.Logger.warn(`No installer for tool: ${tool}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ribershamoelias/forge",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "The standard way developers set up their machines.",
   "main": "dist/cli.js",
   "bin": {
@@ -24,6 +24,7 @@
     "ora": "^7.0.1"
   },
   "devDependencies": {
+    "@types/inquirer": "^9.0.9",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3"
   }