windowpp 0.1.5 → 0.1.7

package/bin/windowpp.js

@@ -58,6 +58,12 @@ switch (command) {
         break;
     }
 
+    case 'doctor': {
+        const { doctor } = require('../lib/doctor');
+        doctor();
+        break;
+    }
+
     case '--version':
     case '-v': {
         const pkg = require('../package.json');
@@ -73,11 +79,12 @@ Usage:
   windowpp create <app-name>   Scaffold a new WindowPP app
   windowpp dev                 Start dev mode (Vite + native binary)
   windowpp build               Build for production
+  windowpp doctor              Check environment (CMake, compiler, deps)
 
 Options:
   --app-dir <path>    App directory (default: cwd)
   --out-dir <path>    Output directory for 'create' (default: cwd)
-  --template <name>   Template name for 'create' (default: solid)
+  --template <name>   Template name for 'create' (default: prompt)
   --config <cfg>      CMake config for 'build', e.g. Release|Debug (default: Release)
   --port <n>          Vite dev server port (default: auto-detect or 3000)
   --clean             Clean build outputs before building

package/lib/doctor.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+// cli/lib/doctor.js — WindowPP environment checker
+//
+// Checks everything required to build and run WindowPP apps on the current
+// platform and reports status with fix instructions.
+//
+// Usage:  windowpp doctor
+
+'use strict';
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const IS_WINDOWS = process.platform === 'win32';
+const IS_MAC     = process.platform === 'darwin';
+const IS_LINUX   = process.platform === 'linux';
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function run(cmd) {
+    try {
+        return execSync(cmd, { stdio: 'pipe', encoding: 'utf8' }).trim();
+    } catch {
+        return null;
+    }
+}
+
+function which(name) {
+    const cmd = IS_WINDOWS ? `where ${name}` : `which ${name}`;
+    return run(cmd);
+}
+
+function versionOf(cmd) {
+    return run(`${cmd} --version`);
+}
+
+// ─── Check result builders ────────────────────────────────────────────────────
+
+function ok(label, detail) {
+    return { status: 'ok', label, detail };
+}
+
+function warn(label, detail, fix) {
+    return { status: 'warn', label, detail, fix };
+}
+
+function fail(label, detail, fixes) {
+    return { status: 'fail', label, detail, fixes: Array.isArray(fixes) ? fixes : [fixes] };
+}
+
+// ─── Individual checks ────────────────────────────────────────────────────────
+
+function checkNode() {
+    const v = process.version;
+    const major = parseInt(v.slice(1).split('.')[0], 10);
+    if (major >= 18) return ok('Node.js', v);
+    return warn('Node.js', v, `Upgrade to Node.js >=18: https://nodejs.org`);
+}
+
+function checkCMake() {
+    const v = run('cmake --version');
+    if (!v) {
+        if (IS_WINDOWS)
+            return fail('CMake', 'not found', [
+                'winget install Kitware.CMake',
+                '  or download from https://cmake.org/download/',
+            ]);
+        if (IS_MAC)
+            return fail('CMake', 'not found', 'brew install cmake');
+        return fail('CMake', 'not found', [
+            'sudo apt install cmake          # Debian/Ubuntu',
+            'sudo dnf install cmake          # Fedora/RHEL',
+        ]);
+    }
+    const match = v.match(/cmake version (\S+)/i);
+    return ok('CMake', match ? match[1] : v.split('\n')[0]);
+}
+
+function checkPython() {
+    // Try python3 first, then python (Windows often only has python)
+    let v = run('python3 --version') || run('python --version');
+    if (!v) {
+        if (IS_WINDOWS)
+            return fail('Python 3', 'not found', [
+                'winget install Python.Python.3',
+                '  or download from https://python.org/downloads/',
+            ]);
+        if (IS_MAC)
+            return fail('Python 3', 'not found', 'brew install python3');
+        return fail('Python 3', 'not found', [
+            'sudo apt install python3        # Debian/Ubuntu',
+            'sudo dnf install python3        # Fedora/RHEL',
+        ]);
+    }
+    const major = parseInt((v.match(/\d+/) || ['0'])[0], 10);
+    if (major < 3) return fail('Python 3', `found ${v}`, 'Install Python 3 from https://python.org');
+    return ok('Python 3', v.replace('Python ', ''));
+}
+
+function checkGit() {
+    const v = run('git --version');
+    if (!v) return warn('Git', 'not found (optional, needed for source clone)',
+        IS_WINDOWS ? 'winget install Git.Git' : IS_MAC ? 'brew install git' : 'sudo apt install git');
+    return ok('Git', v.replace('git version ', ''));
+}
+
+// ─── Platform-specific checks ─────────────────────────────────────────────────
+
+function checksWindows() {
+    const results = [];
+
+    // Visual Studio / Build Tools
+    const vsWhere = [
+        'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe',
+        'C:\\Program Files\\Microsoft Visual Studio\\Installer\\vswhere.exe',
+    ].find(p => fs.existsSync(p));
+
+    if (vsWhere) {
+        const info = run(`"${vsWhere}" -latest -format value -property displayName`);
+        results.push(ok('Visual Studio / Build Tools', info || 'found'));
+    } else {
+        // Fallback: check for cl.exe or ninja
+        const cl = run('where cl.exe');
+        if (cl) {
+            results.push(ok('MSVC Compiler', 'cl.exe found'));
+        } else {
+            results.push(fail('Visual Studio Build Tools', 'not found', [
+                'Install Visual Studio 2022 (Community is free):',
+                '  winget install Microsoft.VisualStudio.2022.Community',
+                '  or Build Tools only (no IDE):',
+                '  winget install Microsoft.VisualStudio.2022.BuildTools',
+                '  Make sure to select "Desktop development with C++" workload.',
+            ]));
+        }
+    }
+
+    // WebView2 Runtime (usually pre-installed on Windows 10/11)
+    const webview2Keys = [
+        'HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}',
+        'HKCU\\Software\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}',
+    ];
+    const wv2Found = webview2Keys.some(key => {
+        const r = run(`reg query "${key}" /v pv 2>nul`);
+        return r && r.includes('pv');
+    });
+    if (wv2Found) {
+        results.push(ok('WebView2 Runtime', 'installed'));
+    } else {
+        results.push(warn('WebView2 Runtime', 'not detected',
+            'Download from https://developer.microsoft.com/microsoft-edge/webview2/\n' +
+            '  (Usually pre-installed on Windows 10 22H2+ and Windows 11.)'));
+    }
+
+    return results;
+}
+
+function checksMac() {
+    const results = [];
+
+    // Xcode Command Line Tools
+    const xcodeSelect = run('xcode-select -p');
+    if (xcodeSelect && fs.existsSync(xcodeSelect)) {
+        results.push(ok('Xcode Command Line Tools', xcodeSelect));
+    } else {
+        results.push(fail('Xcode Command Line Tools', 'not found',
+            'xcode-select --install'));
+    }
+
+    // clang++
+    const clang = run('clang++ --version');
+    if (clang) {
+        results.push(ok('clang++', clang.split('\n')[0]));
+    } else {
+        results.push(fail('clang++', 'not found', 'xcode-select --install'));
+    }
+
+    return results;
+}
+
+function checksLinux() {
+    const results = [];
+
+    // C++ compiler
+    const gpp    = run('g++ --version');
+    const clangpp = run('clang++ --version');
+    if (gpp) {
+        results.push(ok('g++', gpp.split('\n')[0]));
+    } else if (clangpp) {
+        results.push(ok('clang++', clangpp.split('\n')[0]));
+    } else {
+        results.push(fail('C++ Compiler', 'g++ or clang++ not found', [
+            'sudo apt install build-essential   # Debian/Ubuntu',
+            'sudo dnf install gcc-c++           # Fedora/RHEL',
+        ]));
+    }
+
+    // pkg-config
+    if (!which('pkg-config')) {
+        results.push(fail('pkg-config', 'not found', [
+            'sudo apt install pkg-config        # Debian/Ubuntu',
+            'sudo dnf install pkgconf           # Fedora/RHEL',
+        ]));
+    } else {
+        results.push(ok('pkg-config', 'found'));
+    }
+
+    // webkit2gtk
+    const wk = run('pkg-config --modversion webkit2gtk-4.1 2>/dev/null') ||
+               run('pkg-config --modversion webkit2gtk-4.0 2>/dev/null');
+    if (wk) {
+        results.push(ok('WebKit2GTK', wk));
+    } else {
+        results.push(fail('WebKit2GTK', 'dev headers not found', [
+            'sudo apt install libwebkit2gtk-4.1-dev   # Ubuntu 22.04+',
+            'sudo apt install libwebkit2gtk-4.0-dev   # Ubuntu 20.04',
+            'sudo dnf install webkit2gtk4.1-devel     # Fedora/RHEL',
+        ]));
+    }
+
+    // GTK3
+    const gtk = run('pkg-config --modversion gtk+-3.0 2>/dev/null');
+    if (gtk) {
+        results.push(ok('GTK3', gtk));
+    } else {
+        results.push(fail('GTK3', 'dev headers not found', [
+            'sudo apt install libgtk-3-dev            # Debian/Ubuntu',
+            'sudo dnf install gtk3-devel              # Fedora/RHEL',
+        ]));
+    }
+
+    // XCB
+    const xcb = run('pkg-config --modversion xcb 2>/dev/null');
+    if (xcb) {
+        results.push(ok('XCB', xcb));
+    } else {
+        results.push(fail('XCB', 'dev headers not found', [
+            'sudo apt install libxcb1-dev libxcb-util-dev libxcb-randr0-dev \\',
+            '    libxcb-icccm4-dev libxcb-ewmh-dev libxcb-keysyms1-dev libxcb-xfixes0-dev',
+            'sudo dnf install libxcb-devel xcb-util-devel xcb-util-keysyms-devel',
+        ]));
+    }
+
+    return results;
+}
+
+// ─── Report printer ───────────────────────────────────────────────────────────
+
+function printResults(results) {
+    const icons = { ok: '✓', warn: '⚠', fail: '✗' };
+    const colors = {
+        ok:   s => `\x1B[32m${s}\x1B[0m`,
+        warn: s => `\x1B[33m${s}\x1B[0m`,
+        fail: s => `\x1B[31m${s}\x1B[0m`,
+    };
+    // Fallback for non-color terminals
+    const noColor = process.env.NO_COLOR || !process.stdout.isTTY;
+
+    const c = (status, s) => noColor ? s : colors[status](s);
+
+    for (const r of results) {
+        const icon  = icons[r.status];
+        const label = r.label.padEnd(28);
+        const detail = r.detail ? `  ${r.detail}` : '';
+        console.log(`  ${c(r.status, icon)} ${label}${detail}`);
+        if (r.status !== 'ok') {
+            const fixes = r.fixes ?? (r.fix ? [r.fix] : []);
+            if (fixes.length) {
+                console.log();
+                console.log(`      Fix:`);
+                for (const line of fixes) {
+                    for (const l of line.split('\n')) {
+                        console.log(`        ${l}`);
+                    }
+                }
+                console.log();
+            }
+        }
+    }
+}
+
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+function doctor() {
+    const platformLabel = IS_WINDOWS ? 'Windows' : IS_MAC ? 'macOS' : 'Linux';
+    console.log(`\n=== WindowPP Doctor (${platformLabel}) ===\n`);
+
+    const results = [
+        checkNode(),
+        checkCMake(),
+        checkPython(),
+        checkGit(),
+        ...(IS_WINDOWS ? checksWindows() :
+            IS_MAC     ? checksMac()     :
+                         checksLinux()),
+    ];
+
+    printResults(results);
+
+    const fails  = results.filter(r => r.status === 'fail');
+    const warns  = results.filter(r => r.status === 'warn');
+    const oks    = results.filter(r => r.status === 'ok');
+
+    console.log(`\n  ${oks.length} ok  |  ${warns.length} warning(s)  |  ${fails.length} error(s)\n`);
+
+    if (fails.length) {
+        console.log('  Fix the errors above before running windowpp build / windowpp dev.\n');
+        process.exitCode = 1;
+    } else if (warns.length) {
+        console.log('  Environment is usable, but review the warnings above.\n');
+    } else {
+        console.log('  Environment is ready. Run windowpp dev in your app directory.\n');
+    }
+}
+
+module.exports = { doctor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windowpp",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "WindowPP CLI — build, dev, and scaffold for WindowPP apps",
   "type": "commonjs",
   "bin": {

package/scripts/sync-templates.js

@@ -41,6 +41,12 @@ const TEMPLATE_SOURCES = [
         appName:     'windowpp-example',
         cmakeTarget: 'wpp_example',
         appTitle:    'WindowPP Example',
+        // Extra literal strings in main.cpp that need to become the app name/title
+        extraTokens: [
+            ['vite-template-solid',  '{{APP_NAME}}-frontend'],
+            ['"WindowPP Dev"',       '"{{APP_TITLE}}"'],
+            ['"WindowPP - Dev View"','\"{{APP_TITLE}}"'],
+        ],
         // Use the standalone-compatible versions from the solid base template
         useBase: [
             'CMakeLists.txt',
@@ -95,12 +101,16 @@ const TEXT_EXTENSIONS = new Set([
 //     Works because CMakeLists adds  target_include_directories(...PRIVATE "${WPP_FRAMEWORK_DIR}/src")
 
 function buildTokens(entry) {
+    const extra = entry.extraTokens ?? [];
     return [
         // ── Name tokens (longer strings first to avoid partial matches) ─────
         [entry.appName,      '{{APP_NAME}}'],
         [entry.cmakeTarget,  '{{CMAKE_TARGET}}'],
         [entry.appTitle,     '{{APP_TITLE}}'],
 
+        // ── Extra per-template literal substitutions ───────────────────────
+        ...extra,
+
         // ── TypeScript/TSX: monorepo-relative imports from frontend/src/ ────
         ["'../../../src/",   "'@wpp/"],
         ['"../../../src/',   '"@wpp/'],
@@ -140,8 +150,10 @@ function copySourceDir(src, dest, tokens, skipRelPaths, relPrefix) {
     fs.mkdirSync(dest, { recursive: true });
     for (const dirent of fs.readdirSync(src, { withFileTypes: true })) {
         const relPath = relPrefix ? `${relPrefix}/${dirent.name}` : dirent.name;
-        // Skip if matched by bare name OR by relative path
-        if (skipRelPaths.has(dirent.name) || skipRelPaths.has(relPath)) continue;
+        // Only match by full relative path — bare-name matching is intentionally
+        // avoided so that e.g. 'package.json' in useBase only skips the ROOT
+        // package.json and not frontend/package.json or any nested one.
+        if (skipRelPaths.has(relPath)) continue;
 
         const srcPath  = path.join(src, dirent.name);
         const destPath = path.join(dest, dirent.name);

package/templates/example/frontend/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "{{APP_NAME}}-frontend",
+  "version": "0.0.0",
+  "description": "",
+  "type": "module",
+  "scripts": {
+    "start": "vite",
+    "dev": "vite",
+    "build": "vite build",
+    "serve": "vite preview"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.1.13",
+    "solid-devtools": "^0.34.3",
+    "tailwindcss": "^4.1.13",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.4",
+    "vite-plugin-solid": "^2.11.8"
+  },
+  "dependencies": {
+    "@solidjs/router": "^0.16.1",
+    "solid-js": "^1.9.9"
+  }
+}

package/templates/example/main.cpp

@@ -28,7 +28,7 @@
 
 int main() {
     wpp::AppConfig app_config;
-    app_config.name = "WindowPP Dev";
+    app_config.name = "{{APP_TITLE}}";
     app_config.quit_on_last_close = true;
     app_config.tray_enabled = true;
 
@@ -38,7 +38,7 @@ int main() {
 
     wpp::WindowConfig main_win;
     main_win.id = "main";
-    main_win.title = "WindowPP - Dev View";
+    main_win.title = "{{APP_TITLE}}";
     main_win.width = 1280;
     main_win.height = 800;
     main_win.center = true;