@iselect/select 1.0.0 → 1.0.1

package/bin/select.js

@@ -33,7 +33,7 @@ program
     .option('-t, --template <template>', 'Project template (react, vue, vanilla)', 'react')
     .action(init);
 
-// select - Interactive platform selection
+// slct select - Interactive platform selection
 program
     .command('select')
     .alias('s')
@@ -47,6 +47,8 @@ program
     .option('--tauri', 'Use Tauri for desktop (default)')
     .option('--electron', 'Use Electron for desktop')
     .option('--release', 'Build for production release')
+    .option('--static', 'Copy files directly without bundling (vanilla HTML/CSS/JS)')
+    .option('--inline', 'Inline CSS and JS into a single HTML file')
     .action(build);
 
 // slct deploy - Deploy to Select marketplace
@@ -65,3 +67,4 @@ program
 
 // Parse arguments
 program.parse();
+

package/lib/commands/build.js

@@ -55,25 +55,268 @@ async function build(target, options) {
     }
 }
 
+// ==================== PROJECT TYPE DETECTION ====================
+async function detectProjectType(projectPath) {
+    const hasPackageJson = await fs.pathExists(path.join(projectPath, 'package.json'));
+    const hasViteConfig = await fs.pathExists(path.join(projectPath, 'vite.config.js')) ||
+        await fs.pathExists(path.join(projectPath, 'vite.config.ts'));
+    const hasIndexHtml = await fs.pathExists(path.join(projectPath, 'index.html'));
+    const hasSrcMain = await fs.pathExists(path.join(projectPath, 'src', 'main.js')) ||
+        await fs.pathExists(path.join(projectPath, 'src', 'main.jsx')) ||
+        await fs.pathExists(path.join(projectPath, 'src', 'main.ts')) ||
+        await fs.pathExists(path.join(projectPath, 'src', 'main.tsx'));
+
+    // Check if package.json has a build script
+    let hasBuildScript = false;
+    if (hasPackageJson) {
+        try {
+            const pkg = await fs.readJson(path.join(projectPath, 'package.json'));
+            hasBuildScript = !!(pkg.scripts && pkg.scripts.build);
+        } catch { }
+    }
+
+    // Static site: has index.html but no package.json or no build script
+    if (hasIndexHtml && (!hasPackageJson || !hasBuildScript)) {
+        return 'static';
+    }
+
+    // Vite project
+    if (hasViteConfig) {
+        return 'vite';
+    }
+
+    // Has package.json with build script
+    if (hasPackageJson && hasBuildScript) {
+        return 'bundled';
+    }
+
+    // Default to static if just has HTML
+    if (hasIndexHtml) {
+        return 'static';
+    }
+
+    return 'unknown';
+}
+
+// ==================== INLINE BUILD ====================
+async function buildInline(projectPath, outputDir) {
+    const spinner = ora('Building inline HTML...').start();
+
+    // Ensure output dir exists
+    await fs.ensureDir(outputDir);
+
+    // Read index.html
+    const indexPath = path.join(projectPath, 'index.html');
+    if (!await fs.pathExists(indexPath)) {
+        spinner.fail('No index.html found');
+        throw new Error('index.html not found in project root');
+    }
+
+    let html = await fs.readFile(indexPath, 'utf8');
+
+    // Inline CSS files
+    const cssLinkRegex = /<link[^>]+rel=["']stylesheet["'][^>]+href=["']([^"']+)["'][^>]*>/gi;
+    const cssLinks = [];
+    let match;
+    while ((match = cssLinkRegex.exec(html)) !== null) {
+        cssLinks.push({ full: match[0], href: match[1] });
+    }
+
+    for (const link of cssLinks) {
+        const cssPath = path.join(projectPath, link.href);
+        if (await fs.pathExists(cssPath)) {
+            const cssContent = await fs.readFile(cssPath, 'utf8');
+            html = html.replace(link.full, `<style>\n${cssContent}\n</style>`);
+        }
+    }
+
+    // Inline JS files
+    const jsScriptRegex = /<script[^>]+src=["']([^"']+)["'][^>]*><\/script>/gi;
+    const jsScripts = [];
+    while ((match = jsScriptRegex.exec(html)) !== null) {
+        jsScripts.push({ full: match[0], src: match[1] });
+    }
+
+    for (const script of jsScripts) {
+        const jsPath = path.join(projectPath, script.src);
+        if (await fs.pathExists(jsPath)) {
+            const jsContent = await fs.readFile(jsPath, 'utf8');
+            html = html.replace(script.full, `<script>\n${jsContent}\n</script>`);
+        }
+    }
+
+    // Write output
+    await fs.writeFile(path.join(outputDir, 'index.html'), html);
+
+    spinner.succeed(`Created single-file HTML (${cssLinks.length} CSS, ${jsScripts.length} JS inlined)`);
+
+    return { cssInlined: cssLinks.length, jsInlined: jsScripts.length };
+}
+
+// ==================== STATIC FILE COPY ====================
+async function copyStaticFiles(projectPath, outputDir) {
+    const spinner = ora('Copying static files...').start();
+
+    // Ensure output dir exists and is clean
+    await fs.emptyDir(outputDir);
+
+    // Files and folders to copy
+    const filesToCopy = ['index.html', 'style.css', 'styles.css', 'main.css', 'app.css'];
+    const foldersToCheck = ['assets', 'css', 'js', 'images', 'fonts', 'src'];
+
+    let copiedFiles = 0;
+    let cssFound = false;
+
+    // Copy individual files
+    for (const file of filesToCopy) {
+        const srcPath = path.join(projectPath, file);
+        if (await fs.pathExists(srcPath)) {
+            await fs.copy(srcPath, path.join(outputDir, file));
+            copiedFiles++;
+            if (file.endsWith('.css')) cssFound = true;
+        }
+    }
+
+    // Copy .js files from root
+    const rootFiles = await fs.readdir(projectPath);
+    for (const file of rootFiles) {
+        if (file.endsWith('.js') && !file.includes('.config.')) {
+            await fs.copy(path.join(projectPath, file), path.join(outputDir, file));
+            copiedFiles++;
+        }
+        if (file.endsWith('.css')) {
+            await fs.copy(path.join(projectPath, file), path.join(outputDir, file));
+            copiedFiles++;
+            cssFound = true;
+        }
+    }
+
+    // Copy folders
+    for (const folder of foldersToCheck) {
+        const srcPath = path.join(projectPath, folder);
+        if (await fs.pathExists(srcPath)) {
+            await fs.copy(srcPath, path.join(outputDir, folder));
+            copiedFiles++;
+
+            // Check for CSS in folders
+            const folderFiles = await fs.readdir(srcPath);
+            if (folderFiles.some(f => f.endsWith('.css'))) {
+                cssFound = true;
+            }
+        }
+    }
+
+    spinner.succeed(`Copied ${copiedFiles} files/folders to ${outputDir}`);
+
+    // Warning if no CSS found
+    if (!cssFound) {
+        console.log(chalk.yellow('\n⚠️  Warning: No CSS files found in build output'));
+        console.log(chalk.gray('   Ensure your HTML links to the CSS file correctly\n'));
+    }
+
+    return { copiedFiles, cssFound };
+}
+
 // ==================== WEB BUILD ====================
 async function buildWeb(config, options) {
     console.log(chalk.blue('\n📦 Building for Web...\n'));
 
+    const projectPath = process.cwd();
+    const outputDir = path.resolve(projectPath, config.build?.outDir || 'dist');
+
+    // Check for --static flag
+    if (options.static) {
+        console.log(chalk.gray('   Mode: Static (--static flag)'));
+        await copyStaticFiles(projectPath, outputDir);
+        console.log(chalk.green('\n✅ Static web build complete!'));
+        console.log(chalk.gray(`   Output: ${outputDir}/\n`));
+        return;
+    }
+
+    // Check for --inline flag
+    if (options.inline) {
+        console.log(chalk.gray('   Mode: Inline (--inline flag)'));
+        await buildInline(projectPath, outputDir);
+        console.log(chalk.green('\n✅ Inline web build complete!'));
+        console.log(chalk.gray(`   Output: ${outputDir}/index.html (single file)\n`));
+        return;
+    }
+
+    // Auto-detect project type
+    const projectType = await detectProjectType(projectPath);
+    console.log(chalk.gray(`   Detected: ${projectType} project`));
+
+    if (projectType === 'static') {
+        console.log(chalk.gray('   Mode: Static site (copying files directly)\n'));
+        await copyStaticFiles(projectPath, outputDir);
+        console.log(chalk.green('\n✅ Static web build complete!'));
+        console.log(chalk.gray(`   Output: ${outputDir}/\n`));
+        return;
+    }
+
+    if (projectType === 'unknown') {
+        console.log(chalk.yellow('\n⚠️  Could not detect project type'));
+        console.log(chalk.gray('   No index.html or package.json found'));
+        console.log(chalk.gray('   Try: slct build web --static\n'));
+        process.exit(1);
+    }
+
+    // Run build command for bundled projects
     const spinner = ora('Running build command...').start();
 
     try {
-        execSync(config.build?.command || 'npm run build', {
+        const buildCommand = config.build?.command || 'npm run build';
+        execSync(buildCommand, {
             stdio: 'inherit',
-            cwd: process.cwd()
+            cwd: projectPath
         });
         spinner.succeed('Web build complete!');
-        console.log(chalk.gray(`   Output: ${config.build?.outDir || 'dist'}/\n`));
+
+        // Validate output
+        await validateBuildOutput(outputDir);
+
+        console.log(chalk.gray(`   Output: ${outputDir}/\n`));
     } catch (error) {
         spinner.fail('Web build failed');
         throw error;
     }
 }
 
+// ==================== BUILD VALIDATION ====================
+async function validateBuildOutput(outputDir) {
+    if (!await fs.pathExists(outputDir)) {
+        console.log(chalk.yellow('\n⚠️  Warning: Output directory not found'));
+        return;
+    }
+
+    const files = await fs.readdir(outputDir);
+
+    // Check for index.html
+    if (!files.includes('index.html')) {
+        console.log(chalk.yellow('\n⚠️  Warning: No index.html found in build output'));
+    }
+
+    // Check for CSS
+    const hasCss = files.some(f => f.endsWith('.css'));
+    const hasAssetsFolder = files.includes('assets');
+
+    if (!hasCss && hasAssetsFolder) {
+        const assetsPath = path.join(outputDir, 'assets');
+        if (await fs.pathExists(assetsPath)) {
+            const assetFiles = await fs.readdir(assetsPath);
+            if (assetFiles.some(f => f.endsWith('.css'))) {
+                return; // CSS is in assets folder, all good
+            }
+        }
+    }
+
+    if (!hasCss) {
+        console.log(chalk.yellow('\n⚠️  Warning: No CSS files found in build output'));
+        console.log(chalk.gray('   If using vanilla CSS, ensure it\'s imported in your JS entry point'));
+        console.log(chalk.gray('   Or use: slct build web --static\n'));
+    }
+}
+
 // ==================== DESKTOP BUILD ====================
 async function buildDesktop(config, options) {
     const framework = options.electron ? 'electron' : (config.desktop?.framework || 'tauri');

package/lib/commands/deploy.js

@@ -39,8 +39,8 @@ async function deploy(options) {
             type: 'list',
             name: 'category',
             message: 'Category:',
-            choices: ['Productivity', 'Finance', 'Developer Tools', 'Education', 'Entertainment', 'Utilities', 'Other'],
-            default: config.category || 'Productivity'
+            choices: ['productivity', 'finance', 'developer-tools', 'education', 'entertainment', 'utilities', 'games', 'ai-tools', 'experiments'],
+            default: config.category || 'productivity'
         },
         {
             type: 'password',
@@ -66,7 +66,7 @@ async function deploy(options) {
         ...config,
         name: answers.name,
         tagline: answers.tagline,
-        category: answers.category.toLowerCase().replace(' ', '-'),
+        category: answers.category,
         platforms: []
     };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@iselect/select",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "Build and deploy apps for web, desktop, and mobile from a single codebase",
     "main": "lib/index.js",
     "bin": {