wmx-os-generators 0.1.0 → 0.1.1

package/dist/deployGenerator.d.ts

@@ -0,0 +1,18 @@
+interface WmxConfig {
+    projectName?: string;
+    framework?: string;
+    packageManager?: string;
+    frontend?: {
+        framework?: string;
+        dir?: string;
+    };
+    backend?: {
+        framework?: string;
+        dir?: string;
+    };
+    database?: string;
+}
+export declare function generateVercelConfig(config: WmxConfig): object;
+export declare function generateRenderConfig(config: WmxConfig): string;
+export declare function generateNetlifyConfig(config: WmxConfig): string;
+export {};

package/dist/deployGenerator.js

@@ -0,0 +1,106 @@
+import fse from 'fs-extra';
+import path from 'path';
+const BACKEND_FRAMEWORKS = ['express', 'nestjs', 'fastify', 'koa'];
+function hasBackend(config) {
+    return !!(config.backend && BACKEND_FRAMEWORKS.includes(config.backend.framework ?? ''));
+}
+export function generateVercelConfig(config) {
+    const frontendDir = config.frontend?.dir ?? 'frontend';
+    const backendDir = config.backend?.dir ?? 'backend';
+    if (hasBackend(config)) {
+        return {
+            version: 2,
+            builds: [
+                {
+                    src: `${frontendDir}/package.json`,
+                    use: '@vercel/static-build',
+                    config: { distDir: 'dist' },
+                },
+                { src: `${backendDir}/package.json`, use: '@vercel/node' },
+            ],
+            routes: [
+                { src: '/api/(.*)', dest: `/${backendDir}` },
+                { src: '/(.*)', dest: `/${frontendDir}` },
+            ],
+        };
+    }
+    return {
+        version: 2,
+        builds: [
+            {
+                src: `${frontendDir}/package.json`,
+                use: '@vercel/static-build',
+                config: { distDir: 'dist' },
+            },
+        ],
+    };
+}
+export function generateRenderConfig(config) {
+    const frontendDir = config.frontend?.dir ?? 'frontend';
+    const backendDir = config.backend?.dir ?? 'backend';
+    const projectName = config.projectName ?? 'my-app';
+    const envExamplePath = path.join(process.cwd(), '.env.example');
+    let envKeys = [];
+    if (fse.pathExistsSync(envExamplePath)) {
+        const content = fse.readFileSync(envExamplePath, 'utf-8');
+        envKeys = content
+            .split('\n')
+            .filter(line => line.includes('=') && !line.trimStart().startsWith('#'))
+            .map(line => line.split('=')[0].trim())
+            .filter(Boolean);
+    }
+    if (hasBackend(config)) {
+        const envSection = envKeys.length > 0
+            ? `\n        envVars:\n${envKeys.map(k => `          - key: ${k}\n            value: placeholder`).join('\n')}`
+            : '';
+        return `services:
+      - type: web
+        name: ${projectName}-backend
+        runtime: node
+        rootDir: ${backendDir}
+        buildCommand: npm install && npm run build
+        startCommand: npm start${envSection}
+
+      - type: static
+        name: ${projectName}-frontend
+        rootDir: ${frontendDir}
+        buildCommand: npm install && npm run build
+        staticPublishPath: dist
+`;
+    }
+    return `services:
+      - type: static
+        name: ${projectName}-frontend
+        rootDir: ${frontendDir}
+        buildCommand: npm install && npm run build
+        staticPublishPath: dist
+`;
+}
+export function generateNetlifyConfig(config) {
+    const frontendDir = config.frontend?.dir ?? 'frontend';
+    const framework = config.frontend?.framework ?? '';
+    let buildCommand;
+    let publish;
+    if (framework === 'next') {
+        buildCommand = 'npm run build';
+        publish = '.next';
+    }
+    else if (framework === 'nuxt') {
+        buildCommand = 'npm run generate';
+        publish = 'dist';
+    }
+    else {
+        buildCommand = 'npm run build';
+        publish = 'dist';
+    }
+    return `[build]
+  base    = "${frontendDir}"
+  command = "${buildCommand}"
+  publish = "${publish}"
+
+[[redirects]]
+  from   = "/*"
+  to     = "/index.html"
+  status = 200
+`;
+}

package/dist/docsGenerator.d.ts

@@ -0,0 +1,5 @@
+import type { AnalysisResult, RouteEntry } from 'wmx-os-scanners';
+export declare function generateAnalysis(result: AnalysisResult, outputDir: string): Promise<void>;
+export declare function generateReadme(cwd: string): Promise<string>;
+export declare function generateArchitectureDocs(analysis: AnalysisResult): string;
+export declare function generateApiDocs(routes: RouteEntry[]): string;

package/dist/docsGenerator.js

@@ -0,0 +1,283 @@
+import fs from 'fs-extra';
+import path from 'path';
+// ── Existing helpers ──────────────────────────────────────────────────────────
+function topImports(imports, n = 10) {
+    const counts = new Map();
+    for (const imp of imports) {
+        counts.set(imp.to, (counts.get(imp.to) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, n)
+        .map(([module, count]) => ({ module, count }));
+}
+export async function generateAnalysis(result, outputDir) {
+    await fs.ensureDir(outputDir);
+    const top = topImports(result.imports);
+    const routeTable = result.routes.length > 0
+        ? [
+            '| Method | Path | File | Line |',
+            '|--------|------|------|------|',
+            ...result.routes.map(r => `| \`${r.method}\` | \`${r.path}\` | ${r.file} | ${r.line} |`)
+        ].join('\n')
+        : '_No Express or Next.js routes detected._';
+    const importList = top.length > 0
+        ? top.map((t, i) => `${i + 1}. \`${t.module}\` — imported **${t.count}** time${t.count === 1 ? '' : 's'}`).join('\n')
+        : '_No imports detected._';
+    const md = `# Project Architecture
+
+_Generated by wmx analyze on ${new Date().toISOString()}_
+
+## Folder Structure
+
+\`\`\`
+${result.folderTree}
+\`\`\`
+
+## API Routes
+
+${routeTable}
+
+## Top Imports
+
+${importList}
+
+## Exports Summary
+
+Total exported symbols: **${result.exports.length}**
+
+| Type | Count |
+|------|-------|
+| Functions | ${result.exports.filter(e => e.type === 'function').length} |
+| Classes | ${result.exports.filter(e => e.type === 'class').length} |
+| Constants | ${result.exports.filter(e => e.type === 'const').length} |
+| Types | ${result.exports.filter(e => e.type === 'type').length} |
+`;
+    await fs.writeFile(path.join(outputDir, 'analysis.md'), md, 'utf8');
+    await fs.writeFile(path.join(outputDir, 'analysis.json'), JSON.stringify(result, null, 2), 'utf8');
+}
+// ── Project structure tree helper (for generateReadme) ────────────────────────
+const PROJ_IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', '.wmx']);
+const PROJ_IGNORE_FILES = new Set(['.env', '.env.example']);
+async function buildProjectStructure(dir, maxDepth, depth = 0) {
+    if (depth >= maxDepth)
+        return '';
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return '';
+    }
+    const filtered = entries.filter(e => {
+        if (PROJ_IGNORE_DIRS.has(e))
+            return false;
+        if (PROJ_IGNORE_FILES.has(e))
+            return false;
+        if (/\.lock$/.test(e))
+            return false;
+        return true;
+    });
+    filtered.sort();
+    const indent = '  '.repeat(depth);
+    const lines = [];
+    for (const entry of filtered) {
+        const fullPath = path.join(dir, entry);
+        let isDir = false;
+        try {
+            const stat = await fs.stat(fullPath);
+            isDir = stat.isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir) {
+            lines.push(`${indent}${entry}/`);
+            const sub = await buildProjectStructure(fullPath, maxDepth, depth + 1);
+            if (sub)
+                lines.push(sub);
+        }
+        else {
+            lines.push(`${indent}${entry}`);
+        }
+    }
+    return lines.join('\n');
+}
+// ── generateReadme ────────────────────────────────────────────────────────────
+export async function generateReadme(cwd) {
+    // Read package.json
+    let pkg = {};
+    try {
+        const raw = await fs.readFile(path.join(cwd, 'package.json'), 'utf8');
+        pkg = JSON.parse(raw);
+    }
+    catch { /* missing or invalid — use defaults */ }
+    // Read .wmxrc.json
+    let wmxrc = {};
+    try {
+        const raw = await fs.readFile(path.join(cwd, '.wmxrc.json'), 'utf8');
+        wmxrc = JSON.parse(raw);
+    }
+    catch { /* missing — use defaults */ }
+    // Read .env.example
+    let envExampleRaw = '';
+    try {
+        envExampleRaw = await fs.readFile(path.join(cwd, '.env.example'), 'utf8');
+    }
+    catch { /* missing — handled below */ }
+    // 1. Title
+    const title = pkg.name ?? 'My Project';
+    // 2. Description
+    const description = pkg.description ?? 'A project built with wmx';
+    // 3. Tech Stack
+    const deps = pkg.dependencies ?? {};
+    const devDeps = pkg.devDependencies ?? {};
+    const allDeps = { ...deps, ...devDeps };
+    const techMap = [
+        ['react', 'React'],
+        ['express', 'Express'],
+        ['mongoose', 'MongoDB'],
+        ['next', 'Next.js'],
+        ['pg', 'PostgreSQL'],
+        ['vue', 'Vue'],
+    ];
+    const detectedTech = techMap
+        .filter(([key]) => key in allDeps)
+        .map(([, label]) => `- ${label}`);
+    const techStackSection = detectedTech.length > 0
+        ? detectedTech.join('\n')
+        : '_No tech stack detected._';
+    // 4. Prerequisites
+    const packageManager = wmxrc.packageManager;
+    const prereqItems = ['- Node.js >= 18', ...(packageManager ? [`- ${packageManager}`] : [])];
+    const prerequisitesSection = prereqItems.join('\n');
+    // 5. Installation
+    const repoObj = pkg.repository;
+    const repoUrl = typeof repoObj === 'string'
+        ? repoObj
+        : (repoObj?.url ?? 'https://github.com/your-org/your-repo');
+    const projectName = pkg.name ?? 'your-project';
+    const installCmd = packageManager === 'pnpm' ? 'pnpm install'
+        : packageManager === 'bun' ? 'bun install'
+            : packageManager === 'yarn' ? 'yarn install'
+                : 'npm install';
+    // 6. Environment Variables
+    const envKeys = envExampleRaw
+        .split('\n')
+        .filter(line => line.includes('=') && !line.trimStart().startsWith('#'))
+        .map(line => line.split('=')[0].trim())
+        .filter(Boolean);
+    const envSection = envKeys.length > 0
+        ? '```bash\n' + envKeys.map(k => `${k}=`).join('\n') + '\n```'
+        : '_No environment variables required._';
+    // 7. Available Scripts
+    const scripts = pkg.scripts ?? {};
+    const scriptEntries = Object.entries(scripts);
+    const scriptsSection = scriptEntries.length > 0
+        ? scriptEntries.map(([key, val]) => `- \`npm run ${key}\` — ${val}`).join('\n')
+        : '_No scripts defined._';
+    // 8. Project Structure (2 levels deep)
+    const structure = await buildProjectStructure(cwd, 2);
+    // 9. License
+    const license = pkg.license ?? 'MIT';
+    return `# ${title}
+
+${description}
+
+## Tech Stack
+
+${techStackSection}
+
+## Prerequisites
+
+${prerequisitesSection}
+
+## Installation
+
+\`\`\`bash
+1. git clone ${repoUrl}
+2. cd ${projectName}
+3. ${installCmd}
+\`\`\`
+
+## Environment Variables
+
+${envSection}
+
+## Available Scripts
+
+${scriptsSection}
+
+## Project Structure
+
+\`\`\`
+${structure}
+\`\`\`
+
+## License
+
+This project is licensed under the ${license} license.
+`;
+}
+// ── generateArchitectureDocs ──────────────────────────────────────────────────
+export function generateArchitectureDocs(analysis) {
+    // Derive a unique source-file count from the data available in AnalysisResult
+    const uniqueFiles = new Set([
+        ...analysis.imports.map(i => i.from),
+        ...analysis.exports.map(e => e.file),
+        ...analysis.routes.map(r => r.file),
+    ]).size;
+    // API Routes table
+    const routeTable = analysis.routes.length > 0
+        ? [
+            '| Method | Endpoint | File | Description |',
+            '|--------|----------|------|-------------|',
+            ...analysis.routes.map(r => `| \`${r.method}\` | \`${r.path}\` | ${r.file} |  |`)
+        ].join('\n')
+        : '_No API routes detected._';
+    // Key Dependencies — external (non-relative) import targets, deduped
+    const externalDeps = [...new Set(analysis.imports
+            .map(i => i.to)
+            .filter(m => !m.startsWith('.') && !m.startsWith('/')))].sort();
+    const depsSection = externalDeps.length > 0
+        ? externalDeps.map(d => `- \`${d}\``).join('\n')
+        : '_No external dependencies detected._';
+    return `# Project Architecture
+
+## Overview
+
+This document describes the architecture of the project.
+
+Analyzed **${uniqueFiles}** source files.
+
+## Folder Structure
+
+\`\`\`
+${analysis.folderTree}
+\`\`\`
+
+## API Routes
+
+${routeTable}
+
+## Key Dependencies
+
+${depsSection}
+`;
+}
+// ── generateApiDocs ───────────────────────────────────────────────────────────
+export function generateApiDocs(routes) {
+    const routeTable = routes.length > 0
+        ? [
+            '| Method | Endpoint | File | Description |',
+            '|--------|----------|------|-------------|',
+            ...routes.map(r => `| \`${r.method}\` | \`${r.path}\` | ${r.file} |  |`)
+        ].join('\n')
+        : '_No routes detected._';
+    return `# API Reference
+
+${routeTable}
+
+_Update the Description column with endpoint-specific documentation._
+`;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ScaffoldGenerator } from "./scaffold.js";
+export { generateAnalysis, generateReadme, generateArchitectureDocs, generateApiDocs } from "./docsGenerator.js";
+export { generateVercelConfig, generateRenderConfig, generateNetlifyConfig } from "./deployGenerator.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { ScaffoldGenerator } from "./scaffold.js";
+export { generateAnalysis, generateReadme, generateArchitectureDocs, generateApiDocs } from "./docsGenerator.js";
+export { generateVercelConfig, generateRenderConfig, generateNetlifyConfig } from "./deployGenerator.js";

package/dist/scaffold.d.ts

@@ -0,0 +1,15 @@
+interface ScaffoldAnswers {
+    projectName: string;
+    framework: string;
+    backend: string;
+    database: string;
+    packageManager: string;
+    features?: string[];
+    [key: string]: unknown;
+}
+export declare class ScaffoldGenerator {
+    static generate(answers: ScaffoldAnswers): Promise<void>;
+    private static resolveTemplate;
+    private static replaceInAllFiles;
+}
+export {};

package/dist/scaffold.js

@@ -0,0 +1,89 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class ScaffoldGenerator {
+    static async generate(answers) {
+        const templateName = ScaffoldGenerator.resolveTemplate(answers);
+        const templatesDir = path.join(__dirname, '..', 'templates');
+        const templatePath = path.join(templatesDir, templateName);
+        const targetPath = path.join(process.cwd(), answers.projectName);
+        if (!(await fs.pathExists(templatePath))) {
+            throw new Error(`Template not found: ${templateName} (looked in ${templatePath})`);
+        }
+        if (await fs.pathExists(targetPath)) {
+            throw new Error(`Directory already exists: ${targetPath}`);
+        }
+        console.log(`\nScaffolding "${answers.projectName}" from template "${templateName}"...`);
+        await fs.copy(templatePath, targetPath);
+        await ScaffoldGenerator.replaceInAllFiles(targetPath, '__PROJECT_NAME__', answers.projectName);
+        const wmxrc = {
+            projectName: answers.projectName,
+            framework: answers.framework,
+            backend: answers.backend,
+            database: answers.database,
+            packageManager: answers.packageManager,
+            features: answers.features ?? [],
+            scaffoldedAt: new Date().toISOString(),
+            template: templateName
+        };
+        await fs.writeJson(path.join(targetPath, '.wmxrc.json'), wmxrc, { spaces: 2 });
+        console.log(`\nRunning ${answers.packageManager} install...`);
+        try {
+            if (templateName === 'react-express-mongo') {
+                await execa(answers.packageManager, ['install'], {
+                    cwd: path.join(targetPath, 'frontend'),
+                    stdio: 'inherit'
+                });
+                await execa(answers.packageManager, ['install'], {
+                    cwd: path.join(targetPath, 'backend'),
+                    stdio: 'inherit'
+                });
+            }
+            else {
+                await execa(answers.packageManager, ['install'], {
+                    cwd: targetPath,
+                    stdio: 'inherit'
+                });
+            }
+        }
+        catch (err) {
+            console.warn(`\nPackage install failed (you can run it manually): ${err.message}`);
+        }
+        console.log(`\n✅ Project "${answers.projectName}" created at ${targetPath}`);
+        console.log(`   cd ${answers.projectName} and follow the README to get started.\n`);
+    }
+    static resolveTemplate(answers) {
+        const fw = answers.framework?.toLowerCase() ?? '';
+        const be = answers.backend?.toLowerCase() ?? '';
+        const db = answers.database?.toLowerCase() ?? '';
+        if (fw.includes('next'))
+            return 'nextjs-postgres';
+        if (fw.includes('react') && be.includes('express') && db.includes('mongo'))
+            return 'react-express-mongo';
+        return 'react-express-mongo';
+    }
+    static async replaceInAllFiles(dir, search, replacement) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await ScaffoldGenerator.replaceInAllFiles(fullPath, search, replacement);
+            }
+            else {
+                try {
+                    const content = await fs.readFile(fullPath, 'utf8');
+                    if (content.includes(search)) {
+                        const updated = content.split(search).join(replacement);
+                        await fs.writeFile(fullPath, updated, 'utf8');
+                    }
+                }
+                catch {
+                    // Skip binary files silently
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wmx-os-generators",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,14 +9,19 @@
     "dev": "tsc --project tsconfig.json --watch"
   },
   "dependencies": {
-    "wmx-os-core": "workspace:*",
-    "wmx-os-scanners": "workspace:*",
     "execa": "^8.0.0",
-    "fs-extra": "^11.0.0"
+    "fs-extra": "^11.0.0",
+    "wmx-os-core": "^0.1.3",
+    "wmx-os-scanners": "^0.1.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.0",
     "@types/node": "^20.0.0",
     "typescript": "^5.4.0"
-  }
+  },
+  "files": [
+    "dist",
+    "src",
+    "package.json"
+  ]
 }

package/src/deployGenerator.d.ts

@@ -0,0 +1,18 @@
+interface WmxConfig {
+    projectName?: string;
+    framework?: string;
+    packageManager?: string;
+    frontend?: {
+        framework?: string;
+        dir?: string;
+    };
+    backend?: {
+        framework?: string;
+        dir?: string;
+    };
+    database?: string;
+}
+export declare function generateVercelConfig(config: WmxConfig): object;
+export declare function generateRenderConfig(config: WmxConfig): string;
+export declare function generateNetlifyConfig(config: WmxConfig): string;
+export {};

package/src/deployGenerator.js

@@ -0,0 +1,106 @@
+import fse from 'fs-extra';
+import path from 'path';
+const BACKEND_FRAMEWORKS = ['express', 'nestjs', 'fastify', 'koa'];
+function hasBackend(config) {
+    return !!(config.backend && BACKEND_FRAMEWORKS.includes(config.backend.framework ?? ''));
+}
+export function generateVercelConfig(config) {
+    const frontendDir = config.frontend?.dir ?? 'frontend';
+    const backendDir = config.backend?.dir ?? 'backend';
+    if (hasBackend(config)) {
+        return {
+            version: 2,
+            builds: [
+                {
+                    src: `${frontendDir}/package.json`,
+                    use: '@vercel/static-build',
+                    config: { distDir: 'dist' },
+                },
+                { src: `${backendDir}/package.json`, use: '@vercel/node' },
+            ],
+            routes: [
+                { src: '/api/(.*)', dest: `/${backendDir}` },
+                { src: '/(.*)', dest: `/${frontendDir}` },
+            ],
+        };
+    }
+    return {
+        version: 2,
+        builds: [
+            {
+                src: `${frontendDir}/package.json`,
+                use: '@vercel/static-build',
+                config: { distDir: 'dist' },
+            },
+        ],
+    };
+}
+export function generateRenderConfig(config) {
+    const frontendDir = config.frontend?.dir ?? 'frontend';
+    const backendDir = config.backend?.dir ?? 'backend';
+    const projectName = config.projectName ?? 'my-app';
+    const envExamplePath = path.join(process.cwd(), '.env.example');
+    let envKeys = [];
+    if (fse.pathExistsSync(envExamplePath)) {
+        const content = fse.readFileSync(envExamplePath, 'utf-8');
+        envKeys = content
+            .split('\n')
+            .filter(line => line.includes('=') && !line.trimStart().startsWith('#'))
+            .map(line => line.split('=')[0].trim())
+            .filter(Boolean);
+    }
+    if (hasBackend(config)) {
+        const envSection = envKeys.length > 0
+            ? `\n        envVars:\n${envKeys.map(k => `          - key: ${k}\n            value: placeholder`).join('\n')}`
+            : '';
+        return `services:
+      - type: web
+        name: ${projectName}-backend
+        runtime: node
+        rootDir: ${backendDir}
+        buildCommand: npm install && npm run build
+        startCommand: npm start${envSection}
+
+      - type: static
+        name: ${projectName}-frontend
+        rootDir: ${frontendDir}
+        buildCommand: npm install && npm run build
+        staticPublishPath: dist
+`;
+    }
+    return `services:
+      - type: static
+        name: ${projectName}-frontend
+        rootDir: ${frontendDir}
+        buildCommand: npm install && npm run build
+        staticPublishPath: dist
+`;
+}
+export function generateNetlifyConfig(config) {
+    const frontendDir = config.frontend?.dir ?? 'frontend';
+    const framework = config.frontend?.framework ?? '';
+    let buildCommand;
+    let publish;
+    if (framework === 'next') {
+        buildCommand = 'npm run build';
+        publish = '.next';
+    }
+    else if (framework === 'nuxt') {
+        buildCommand = 'npm run generate';
+        publish = 'dist';
+    }
+    else {
+        buildCommand = 'npm run build';
+        publish = 'dist';
+    }
+    return `[build]
+  base    = "${frontendDir}"
+  command = "${buildCommand}"
+  publish = "${publish}"
+
+[[redirects]]
+  from   = "/*"
+  to     = "/index.html"
+  status = 200
+`;
+}