archforge-x 1.0.2 → 1.0.3

package/dist/cli/commands/sync.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.syncCommand = syncCommand;
+const validator_1 = require("../../core/architecture/validator");
+const chalk_1 = __importDefault(require("chalk"));
+async function syncCommand() {
+    const projectRoot = process.cwd();
+    const validator = new validator_1.ArchitectureValidator();
+    console.log(chalk_1.default.blue("🔄 Syncing architecture with archforge.yaml..."));
+    const result = await validator.validate(projectRoot);
+    if (result.success) {
+        console.log(chalk_1.default.green.bold("✅ Architecture is valid and in sync!"));
+    }
+    else {
+        console.log(chalk_1.default.red.bold("❌ Architecture violations found:"));
+        result.errors.forEach(err => console.log(chalk_1.default.red(`   - ${err}`)));
+        process.exit(1);
+    }
+}

package/dist/cli/interactive.js

@@ -52,13 +52,47 @@ async function interactiveCLI() {
             { title: "Hexagonal Architecture", value: "hexagonal" },
         ],
     });
+    const ormResponse = await (0, prompts_1.default)({
+        type: "select",
+        name: "orm",
+        message: "Select ORM:",
+        choices: langResponse.language === "ts" || langResponse.language === "js"
+            ? [
+                { title: "Prisma", value: "prisma" },
+                { title: "TypeORM", value: "typeorm" },
+                { title: "Sequelize", value: "sequelize" },
+                { title: "Drizzle", value: "drizzle" },
+                { title: "None", value: "none" },
+            ]
+            : langResponse.language === "py"
+                ? [
+                    { title: "SQLAlchemy", value: "sqlalchemy" },
+                    { title: "Django ORM", value: "django" },
+                    { title: "None", value: "none" },
+                ]
+                : [
+                    { title: "GORM", value: "gorm" },
+                    { title: "SQLC", value: "sqlc" },
+                    { title: "None", value: "none" },
+                ],
+    });
+    const dbResponse = await (0, prompts_1.default)({
+        type: ormResponse.orm === "none" ? null : "select",
+        name: "database",
+        message: "Select Database:",
+        choices: [
+            { title: "PostgreSQL", value: "postgresql" },
+            { title: "MySQL", value: "mysql" },
+            { title: "SQLite", value: "sqlite" },
+            { title: "MongoDB", value: "mongodb" },
+        ],
+    });
     const modulesResponse = await (0, prompts_1.default)({
         type: "multiselect",
         name: "modules",
         message: "Select optional modules:",
         choices: [
             { title: "Authentication (JWT)", value: "auth" },
-            { title: "Database (ORM setup)", value: "db" },
             { title: "Caching (Redis)", value: "cache" },
             { title: "Docker Support", value: "docker" },
             { title: "CI/CD (GitHub Actions)", value: "ci" },
@@ -73,12 +107,14 @@ async function interactiveCLI() {
     });
     console.log(chalk_1.default.yellow("\n🔧 Generating project..."));
     const options = {
-        mode: 'professional',
+        // mode: 'professional',
         language: langResponse.language,
         framework: frameworkResponse.framework,
         architecture: archResponse.architecture,
         modules: modulesResponse.modules,
         projectName: projectNameResp.projectName,
+        orm: ormResponse.orm,
+        database: dbResponse.database,
     };
     // Create a dummy arch definition for the generator
     const dummyArch = {
@@ -92,7 +128,9 @@ async function interactiveCLI() {
             type: archResponse.architecture,
             language: langResponse.language,
             framework: frameworkResponse.framework,
-            modules: modulesResponse.modules
+            modules: modulesResponse.modules,
+            orm: ormResponse.orm,
+            database: dbResponse.database
         },
         layers: []
     };

package/dist/core/architecture/schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.architectureSchema = exports.metadataSchema = exports.layerSchema = void 0;
+exports.architectureSchema = exports.customStructureSchema = exports.rulesSchema = exports.namingSchema = exports.metadataSchema = exports.layerSchema = void 0;
 // src/core/architecture/schema.ts
 const zod_1 = require("zod");
 exports.layerSchema = zod_1.z.object({
@@ -9,15 +9,33 @@ exports.layerSchema = zod_1.z.object({
     description: zod_1.z.string().optional(),
     allowedImports: zod_1.z.array(zod_1.z.string()).optional(),
     forbiddenImports: zod_1.z.array(zod_1.z.string()).optional(),
+    canImport: zod_1.z.array(zod_1.z.string()).optional(),
     strict: zod_1.z.boolean().optional(),
 });
 exports.metadataSchema = zod_1.z.object({
-    type: zod_1.z.enum(['clean', 'ddd', 'layered', 'hexagonal', 'microservices']),
+    type: zod_1.z.enum(['clean', 'ddd', 'layered', 'hexagonal', 'microservices', 'mvc']),
     language: zod_1.z.enum(['ts', 'js', 'py', 'go']),
     framework: zod_1.z.string().optional(),
+    orm: zod_1.z.string().optional(),
+    database: zod_1.z.string().optional(),
     modules: zod_1.z.array(zod_1.z.string()).optional(),
     version: zod_1.z.string().optional(),
 });
+exports.namingSchema = zod_1.z.object({
+    services: zod_1.z.string().optional(),
+    repositories: zod_1.z.string().optional(),
+    controllers: zod_1.z.string().optional(),
+    entities: zod_1.z.string().optional(),
+});
+exports.rulesSchema = zod_1.z.object({
+    forbidDirectDbAccess: zod_1.z.boolean().optional(),
+    forbidFrameworkInDomain: zod_1.z.boolean().optional(),
+    enforceLayerBoundaries: zod_1.z.boolean().optional(),
+});
+exports.customStructureSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean(),
+    folders: zod_1.z.array(zod_1.z.object({ path: zod_1.z.string() })),
+});
 exports.architectureSchema = zod_1.z.object({
     version: zod_1.z.string().default("1.0"),
     name: zod_1.z.string(),
@@ -28,5 +46,8 @@ exports.architectureSchema = zod_1.z.object({
     }),
     metadata: exports.metadataSchema,
     layers: zod_1.z.array(exports.layerSchema),
+    naming: exports.namingSchema.optional(),
+    rules: exports.rulesSchema.optional(),
+    customStructure: exports.customStructureSchema.optional(),
     strict: zod_1.z.boolean().optional(),
 });

package/dist/core/architecture/validator.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchitectureValidator = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class ArchitectureValidator {
+    async validate(projectRoot) {
+        const configPath = path_1.default.join(projectRoot, "archforge.yaml");
+        if (!fs_extra_1.default.existsSync(configPath)) {
+            return { success: false, errors: ["archforge.yaml not found"], warnings: [] };
+        }
+        const config = js_yaml_1.default.load(fs_extra_1.default.readFileSync(configPath, "utf8"));
+        const errors = [];
+        const warnings = [];
+        // 1. Validate Folder Structure
+        if (config.layers) {
+            for (const [name, layer] of Object.entries(config.layers)) {
+                const layerPath = path_1.default.join(projectRoot, layer.path);
+                if (!fs_extra_1.default.existsSync(layerPath)) {
+                    errors.push(`Layer "${name}" path not found: ${layer.path}`);
+                }
+            }
+        }
+        // 2. Validate Custom Folders
+        if (config.customStructure?.enabled && config.customStructure.folders) {
+            for (const folder of config.customStructure.folders) {
+                const folderPath = path_1.default.join(projectRoot, folder.path);
+                if (!fs_extra_1.default.existsSync(folderPath)) {
+                    errors.push(`Custom folder not found: ${folder.path}`);
+                }
+            }
+        }
+        // 3. Validate Naming Conventions
+        if (config.naming) {
+            this.validateNamingConventions(projectRoot, config.naming, errors);
+        }
+        // 4. Validate Layer Imports (Basic check for forbidden imports in files)
+        if (config.layers && config.rules?.enforceLayerBoundaries) {
+            this.validateLayerImports(projectRoot, config.layers, errors);
+        }
+        return {
+            success: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    validateNamingConventions(root, naming, errors) {
+        // Simple check: scan src and verify file suffixes
+        const scanDir = (dir) => {
+            if (!fs_extra_1.default.existsSync(dir))
+                return;
+            const files = fs_extra_1.default.readdirSync(dir);
+            for (const file of files) {
+                const fullPath = path_1.default.join(dir, file);
+                if (fs_extra_1.default.statSync(fullPath).isDirectory()) {
+                    scanDir(fullPath);
+                }
+                else {
+                    const lowerFile = file.toLowerCase();
+                    if (dir.includes("services") && naming.services) {
+                        const pattern = naming.services.replace("*", "").toLowerCase();
+                        if (!lowerFile.includes(pattern)) {
+                            errors.push(`Naming violation: Service file "${file}" does not match pattern "${naming.services}"`);
+                        }
+                    }
+                    if (dir.includes("repositories") && naming.repositories) {
+                        const pattern = naming.repositories.replace("*", "").toLowerCase();
+                        if (!lowerFile.includes(pattern)) {
+                            errors.push(`Naming violation: Repository file "${file}" does not match pattern "${naming.repositories}"`);
+                        }
+                    }
+                }
+            }
+        };
+        scanDir(path_1.default.join(root, "src"));
+    }
+    validateLayerImports(root, layers, errors) {
+        // This is a complex task for a simple validator, but we can do a basic grep-like check
+        // for forbidden layer paths in files of other layers.
+        for (const [name, layer] of Object.entries(layers)) {
+            const layerPath = path_1.default.join(root, layer.path);
+            if (!fs_extra_1.default.existsSync(layerPath))
+                continue;
+            const canImport = layer.canImport || [];
+            const forbiddenLayers = Object.keys(layers).filter(l => l !== name && !canImport.includes(l));
+            const scanFiles = (dir) => {
+                const files = fs_extra_1.default.readdirSync(dir);
+                for (const file of files) {
+                    const fullPath = path_1.default.join(dir, file);
+                    if (fs_extra_1.default.statSync(fullPath).isDirectory()) {
+                        scanFiles(fullPath);
+                    }
+                    else if (file.endsWith(".ts") || file.endsWith(".py") || file.endsWith(".go")) {
+                        const content = fs_extra_1.default.readFileSync(fullPath, "utf8");
+                        for (const forbidden of forbiddenLayers) {
+                            const forbiddenPath = layers[forbidden].path.replace("src/", "");
+                            if (content.includes(forbiddenPath) && !content.includes(`from .`)) {
+                                errors.push(`Architecture violation: Layer "${name}" (${file}) imports from forbidden layer "${forbidden}"`);
+                            }
+                        }
+                    }
+                }
+            };
+            scanFiles(layerPath);
+        }
+    }
+}
+exports.ArchitectureValidator = ArchitectureValidator;

package/dist/generators/base.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGenerator = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class BaseGenerator {
+    async generate(arch, options) {
+        const projectName = options.projectName || arch.project.name || "generated-project";
+        const root = path_1.default.resolve(projectName);
+        console.log(chalk_1.default.blueBright(`🚀 Starting ${this.getGeneratorName()} generation for ${projectName}...`));
+        if (!fs_extra_1.default.existsSync(root)) {
+            fs_extra_1.default.mkdirpSync(root);
+        }
+        await this.generateProjectStructure(root, arch, options);
+        this.generateArchForgeConfig(root, arch, options);
+        // Ensure all layer and custom folders exist
+        const config = js_yaml_1.default.load(fs_extra_1.default.readFileSync(path_1.default.join(root, "archforge.yaml"), "utf8"));
+        if (config.layers) {
+            for (const layer of Object.values(config.layers)) {
+                this.createDir(root, layer.path);
+            }
+        }
+        if (config.customStructure?.enabled && config.customStructure.folders) {
+            for (const folder of config.customStructure.folders) {
+                this.createDir(root, folder.path);
+            }
+        }
+        if (options.modules?.includes("docker")) {
+            console.log(chalk_1.default.blue("   🐳 Generating Docker configuration..."));
+            this.generateDocker(root, options);
+        }
+        if (options.modules?.includes("ci")) {
+            console.log(chalk_1.default.blue("   👷 Generating CI/CD workflows..."));
+            this.generateCI(root, options);
+        }
+        this.generateProductionDocs(root, arch, options);
+        this.ensureNoEmptyFolders(root);
+        console.log(chalk_1.default.green.bold(`\n✅ ${this.getGeneratorName()} project ${projectName} successfully generated!`));
+    }
+    generateProductionDocs(root, arch, options) {
+        this.writeFile(root, "docs/architecture.md", `
+# Architecture Guide
+
+This project follows the **${options.architecture || arch.metadata.type}** architecture style.
+
+## Layers
+${arch.layers.map(l => `- **${l.name}**: ${l.description || 'Located at ' + l.path}`).join('\n')}
+
+## Rules
+- **Layer Boundaries**: Enforced via \`archforge.yaml\`.
+- **Naming**: Services must end with \`Service\`, Repositories with \`Repository\`.
+        `);
+        this.writeFile(root, "docs/database.md", `
+# Database Guide
+
+- **ORM**: ${options.orm || arch.metadata.orm}
+- **Database**: ${options.database || arch.metadata.database}
+
+## Setup
+1. Ensure Docker is running.
+2. Run \`docker-compose up -d\`.
+3. Migrations are handled automatically on startup.
+        `);
+        this.writeFile(root, "docs/caching.md", `
+# Caching Guide
+
+This project implements a first-class caching layer.
+
+## Strategies
+- **Redis**: Used in production for distributed caching.
+- **In-Memory**: Used for local development or as a fallback.
+
+## Usage
+Inject the \`ICache\` interface into your services.
+        `);
+        this.writeFile(root, "docs/rules.md", `
+# ArchForge Rules
+
+This project uses \`archforge.yaml\` to enforce architectural standards.
+
+## How to Sync
+Run \`npx archforge sync\` to validate the structure.
+        `);
+    }
+    ensureNoEmptyFolders(root) {
+        const scan = (dir) => {
+            const files = fs_extra_1.default.readdirSync(dir);
+            if (files.length === 0) {
+                this.writeFile(dir, "README.md", `# ${path_1.default.basename(dir)}\n\nThis folder is part of the architectural structure.`);
+            }
+            else {
+                for (const file of files) {
+                    const fullPath = path_1.default.join(dir, file);
+                    if (fs_extra_1.default.statSync(fullPath).isDirectory()) {
+                        scan(fullPath);
+                    }
+                }
+            }
+        };
+        scan(path_1.default.join(root, "src"));
+    }
+    generateArchForgeConfig(root, arch, options) {
+        const config = {
+            architecture: options.architecture || arch.metadata.type,
+            stack: options.framework || arch.metadata.framework,
+            orm: options.orm || arch.metadata.orm || "none",
+            database: options.database || arch.metadata.database || "none",
+            layers: arch.layers.length > 0 ? arch.layers.reduce((acc, layer) => {
+                acc[layer.name] = {
+                    path: layer.path,
+                    canImport: layer.canImport || layer.allowedImports || []
+                };
+                return acc;
+            }, {}) : this.getDefaultLayers(options.architecture || "clean"),
+            naming: arch.naming || {
+                services: "*Service",
+                repositories: "*Repository",
+                controllers: "*Controller"
+            },
+            rules: arch.rules || {
+                forbidDirectDbAccess: true,
+                forbidFrameworkInDomain: true,
+                enforceLayerBoundaries: true
+            },
+            customStructure: arch.customStructure || {
+                enabled: true,
+                folders: [
+                    { path: "src/modules" },
+                    { path: "src/shared" }
+                ]
+            }
+        };
+        this.writeFile(root, "archforge.yaml", `
+# ArchForge X Configuration
+# This file is the single source of truth for your project architecture.
+${require('js-yaml').dump(config)}
+        `.trim());
+    }
+    getDefaultLayers(arch) {
+        if (arch === "clean") {
+            return {
+                domain: { path: "src/domain", canImport: [] },
+                application: { path: "src/application", canImport: ["domain"] },
+                infrastructure: { path: "src/infrastructure", canImport: ["application", "domain"] },
+                presentation: { path: "src/presentation", canImport: ["application"] }
+            };
+        }
+        // Add other defaults as needed
+        return {};
+    }
+    writeFile(root, filePath, content) {
+        const fullPath = path_1.default.join(root, filePath);
+        fs_extra_1.default.mkdirpSync(path_1.default.dirname(fullPath));
+        fs_extra_1.default.writeFileSync(fullPath, content.trim());
+    }
+    createDir(root, dirPath) {
+        const fullPath = path_1.default.join(root, dirPath);
+        fs_extra_1.default.mkdirpSync(fullPath);
+    }
+}
+exports.BaseGenerator = BaseGenerator;