kaven-cli 0.1.0-alpha.1 → 0.3.0

package/dist/core/ModuleDoctor.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModuleDoctor = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 class ModuleDoctor {
     constructor(projectRoot, markerService, manifestParser) {
         this.projectRoot = projectRoot;
@@ -17,6 +18,11 @@ class ModuleDoctor {
         results.push(...(await this.checkAnchors()));
         results.push(...(await this.checkMarkers()));
         results.push(...(await this.checkDependencies()));
+        results.push(...(await this.checkSchemaMerge()));
+        results.push(...(await this.checkEnvCompleteness()));
+        results.push(...(await this.checkLicense()));
+        results.push(...(await this.checkFrameworkVersion()));
+        results.push(...(await this.checkPrismaClientSync()));
         return results;
     }
     async checkAnchors() {
@@ -146,6 +152,286 @@ class ModuleDoctor {
         }
         return results;
     }
+    // ──────────────────────────────────────────────────────────
+    // C2.4: New enhanced checks
+    // ──────────────────────────────────────────────────────────
+    /** Check that the base Prisma schema exists and has no merge conflicts. */
+    async checkSchemaMerge() {
+        const results = [];
+        const baseSchemaPath = path_1.default.join(this.projectRoot, "packages/database/prisma/schema.base.prisma");
+        if (!(await fs_extra_1.default.pathExists(baseSchemaPath))) {
+            results.push({
+                type: "dependency",
+                severity: "warning",
+                message: "Prisma base schema not found: packages/database/prisma/schema.base.prisma",
+                file: "packages/database/prisma/schema.base.prisma",
+                fixable: false,
+            });
+            return results;
+        }
+        // Check for git merge conflict markers
+        const schemaDir = path_1.default.dirname(baseSchemaPath);
+        try {
+            const schemaFiles = await fs_extra_1.default.readdir(schemaDir);
+            for (const schemaFile of schemaFiles) {
+                if (!schemaFile.endsWith(".prisma"))
+                    continue;
+                const filePath = path_1.default.join(schemaDir, schemaFile);
+                const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+                if (content.includes("<<<<<<<")) {
+                    results.push({
+                        type: "marker",
+                        severity: "error",
+                        message: `Merge conflict detected in schema file: ${schemaFile}`,
+                        file: path_1.default.join("packages/database/prisma", schemaFile),
+                        fixable: false,
+                    });
+                }
+            }
+        }
+        catch {
+            // Non-critical
+        }
+        if (results.length === 0) {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: "Prisma schema integrity OK",
+                fixable: false,
+            });
+        }
+        return results;
+    }
+    /** Check that .env has all keys defined in .env.example (non-optional). */
+    async checkEnvCompleteness() {
+        const results = [];
+        const envExamplePath = path_1.default.join(this.projectRoot, ".env.example");
+        const envPath = path_1.default.join(this.projectRoot, ".env");
+        if (!(await fs_extra_1.default.pathExists(envExamplePath))) {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: ".env.example not found — skipping env completeness check",
+                fixable: false,
+            });
+            return results;
+        }
+        if (!(await fs_extra_1.default.pathExists(envPath))) {
+            results.push({
+                type: "dependency",
+                severity: "warning",
+                message: ".env file not found. Copy .env.example to .env and fill in values",
+                file: ".env",
+                fixable: false,
+            });
+            return results;
+        }
+        const exampleContent = await fs_extra_1.default.readFile(envExamplePath, "utf-8");
+        const envContent = await fs_extra_1.default.readFile(envPath, "utf-8");
+        // Parse keys: lines that are KEY=VALUE (not comments, not blank)
+        const parseKeys = (content) => {
+            const keys = new Set();
+            for (const line of content.split("\n")) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith("#") || !trimmed.includes("="))
+                    continue;
+                const key = trimmed.split("=")[0].trim();
+                if (key)
+                    keys.add(key);
+            }
+            return keys;
+        };
+        const exampleKeys = parseKeys(exampleContent);
+        const envKeys = parseKeys(envContent);
+        const missingKeys = [];
+        for (const key of exampleKeys) {
+            if (!envKeys.has(key)) {
+                missingKeys.push(key);
+            }
+        }
+        if (missingKeys.length > 0) {
+            results.push({
+                type: "dependency",
+                severity: "warning",
+                message: `Missing env vars in .env: ${missingKeys.join(", ")}`,
+                file: ".env",
+                fixable: true,
+            });
+        }
+        else {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: "Env vars completeness OK",
+                fixable: false,
+            });
+        }
+        return results;
+    }
+    /** Check if the stored license is present and not expired. */
+    async checkLicense() {
+        const results = [];
+        const licensePath = path_1.default.join(os_1.default.homedir(), ".kaven", "license.json");
+        if (!(await fs_extra_1.default.pathExists(licensePath))) {
+            results.push({
+                type: "dependency",
+                severity: "warning",
+                message: "No license found at ~/.kaven/license.json. Run 'kaven license status' to set up.",
+                fixable: false,
+            });
+            return results;
+        }
+        try {
+            const licenseData = await fs_extra_1.default.readJson(licensePath);
+            if (licenseData.expiresAt) {
+                const expiresAt = new Date(licenseData.expiresAt).getTime();
+                if (Date.now() > expiresAt) {
+                    results.push({
+                        type: "dependency",
+                        severity: "error",
+                        message: `License expired on ${licenseData.expiresAt}. Run 'kaven upgrade' to renew.`,
+                        fixable: false,
+                    });
+                    return results;
+                }
+            }
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: `License valid (tier: ${licenseData.tier || "unknown"})`,
+                fixable: false,
+            });
+        }
+        catch {
+            results.push({
+                type: "dependency",
+                severity: "warning",
+                message: "Could not read license file. Try 'kaven license status'.",
+                fixable: false,
+            });
+        }
+        return results;
+    }
+    /** Check if the framework version in package.json is compatible. */
+    async checkFrameworkVersion() {
+        const results = [];
+        const packageJsonPath = path_1.default.join(this.projectRoot, "package.json");
+        if (!(await fs_extra_1.default.pathExists(packageJsonPath))) {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: "package.json not found — skipping framework version check",
+                fixable: false,
+            });
+            return results;
+        }
+        try {
+            const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
+            const kavenCoreVersion = packageJson.dependencies?.["@kaven/core"] ||
+                packageJson.devDependencies?.["@kaven/core"];
+            if (!kavenCoreVersion) {
+                results.push({
+                    type: "dependency",
+                    severity: "info",
+                    message: "@kaven/core not found in dependencies — not a Kaven framework project",
+                    fixable: false,
+                });
+                return results;
+            }
+            // Minimum required semver range
+            const MINIMUM_VERSION = "1.0.0";
+            const versionStr = kavenCoreVersion.replace(/[\^~>=<]/, "").split(" ")[0];
+            const parts = versionStr.split(".").map(Number);
+            const minParts = MINIMUM_VERSION.split(".").map(Number);
+            let compatible = true;
+            for (let i = 0; i < 3; i++) {
+                if ((parts[i] || 0) > (minParts[i] || 0))
+                    break;
+                if ((parts[i] || 0) < (minParts[i] || 0)) {
+                    compatible = false;
+                    break;
+                }
+            }
+            if (!compatible) {
+                results.push({
+                    type: "dependency",
+                    severity: "warning",
+                    message: `@kaven/core version ${kavenCoreVersion} may be outdated. Minimum: ^${MINIMUM_VERSION}`,
+                    fixable: false,
+                });
+            }
+            else {
+                results.push({
+                    type: "dependency",
+                    severity: "info",
+                    message: `Framework version OK (${kavenCoreVersion})`,
+                    fixable: false,
+                });
+            }
+        }
+        catch {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: "Could not determine framework version",
+                fixable: false,
+            });
+        }
+        return results;
+    }
+    /** Check if Prisma client is generated and up-to-date. */
+    async checkPrismaClientSync() {
+        const results = [];
+        const prismaClientPath = path_1.default.join(this.projectRoot, "node_modules/@prisma/client");
+        const schemaPath = path_1.default.join(this.projectRoot, "prisma/schema.prisma");
+        if (!(await fs_extra_1.default.pathExists(prismaClientPath))) {
+            results.push({
+                type: "dependency",
+                severity: "warning",
+                message: "@prisma/client not found. Run 'npx prisma generate' to generate the client.",
+                fixable: true,
+            });
+            return results;
+        }
+        if (!(await fs_extra_1.default.pathExists(schemaPath))) {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: "prisma/schema.prisma not found — skipping Prisma sync check",
+                fixable: false,
+            });
+            return results;
+        }
+        try {
+            const schemaStat = await fs_extra_1.default.stat(schemaPath);
+            const clientStat = await fs_extra_1.default.stat(prismaClientPath);
+            if (schemaStat.mtime > clientStat.mtime) {
+                results.push({
+                    type: "dependency",
+                    severity: "warning",
+                    message: "Prisma schema was modified after client generation. Run 'npx prisma generate'.",
+                    fixable: true,
+                });
+            }
+            else {
+                results.push({
+                    type: "dependency",
+                    severity: "info",
+                    message: "Prisma client is up to date",
+                    fixable: false,
+                });
+            }
+        }
+        catch {
+            results.push({
+                type: "dependency",
+                severity: "info",
+                message: "Could not compare Prisma schema and client timestamps",
+                fixable: false,
+            });
+        }
+        return results;
+    }
     async readKavenConfig() {
         const configPath = path_1.default.join(this.projectRoot, "kaven.config.json");
         if (!(await fs_extra_1.default.pathExists(configPath))) {

package/dist/core/ModuleInstaller.js

@@ -1,18 +1,93 @@
 "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.ModuleInstaller = void 0;
 const TransactionalFileSystem_1 = require("../infrastructure/TransactionalFileSystem");
+const ScriptRunner_js_1 = require("./ScriptRunner.js");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
 class ModuleInstaller {
     constructor(projectRoot, markerService) {
         this.projectRoot = projectRoot;
         this.markerService = markerService;
     }
-    async install(manifest) {
+    /**
+     * Check whether the given module slug is already installed by scanning
+     * project files for its begin/end markers.
+     */
+    async isModuleInstalled(moduleName) {
+        try {
+            const filesToCheck = await this.findProjectFiles();
+            for (const filePath of filesToCheck) {
+                try {
+                    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
+                    if (this.markerService.hasModule(content, moduleName)) {
+                        return true;
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Find text-based project source files to check for markers. */
+    async findProjectFiles() {
+        const { glob } = await Promise.resolve().then(() => __importStar(require("glob")));
+        const patterns = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
+        const ignore = ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/build/**"];
+        const files = [];
+        for (const pattern of patterns) {
+            const found = await glob(pattern, {
+                cwd: this.projectRoot,
+                absolute: true,
+                ignore,
+            });
+            files.push(...found);
+        }
+        return [...new Set(files)];
+    }
+    async install(manifest, options) {
         const tx = new TransactionalFileSystem_1.TransactionalFileSystem(this.projectRoot);
         try {
             const filesToModify = Array.from(new Set(manifest.injections.map((inj) => inj.file)));
@@ -21,6 +96,36 @@ class ModuleInstaller {
                 await this.injectCode(injection);
             }
             await tx.commit();
+            // Run postInstall lifecycle scripts if defined in module.json
+            const moduleJson = await this.readManifest(this.projectRoot);
+            if (moduleJson?.scripts?.postInstall?.length) {
+                const runner = new ScriptRunner_js_1.ScriptRunner();
+                try {
+                    await runner.runScripts(moduleJson.scripts.postInstall.map((s) => ({ ...s, cwd: this.projectRoot })), 'postInstall', false);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.warn(chalk_1.default.yellow(`
+  ⚠ PostInstall script failed: ${errMsg}`));
+                    console.warn(chalk_1.default.dim('  The module is installed. Run the script manually if needed.'));
+                }
+            }
+            // Inject environment variables if defined in module.json
+            if (!options?.skipEnv && moduleJson?.env?.length) {
+                const { EnvManager } = await Promise.resolve().then(() => __importStar(require('./EnvManager.js')));
+                const envManager = new EnvManager();
+                const envVarDefs = moduleJson.env.map((e) => ({
+                    name: e.key,
+                    description: e.example ?? e.key,
+                    required: e.required ?? false,
+                }));
+                await envManager.injectEnvVars(manifest.name, envVarDefs, {
+                    projectDir: this.projectRoot,
+                    envFile: options?.envFile,
+                    skipEnv: options?.skipEnv,
+                    skipConfirmation: options?.yes,
+                });
+            }
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -30,11 +135,31 @@ class ModuleInstaller {
             throw error;
         }
     }
-    async uninstall(manifest) {
+    async uninstall(manifest, options) {
         const tx = new TransactionalFileSystem_1.TransactionalFileSystem(this.projectRoot);
         try {
             const filesToModify = Array.from(new Set(manifest.injections.map((inj) => inj.file)));
             await tx.backup(filesToModify);
+            // Remove environment variables before removing files
+            const { EnvManager } = await Promise.resolve().then(() => __importStar(require('./EnvManager.js')));
+            const envManager = new EnvManager();
+            envManager.removeEnvVars(manifest.name, {
+                projectDir: this.projectRoot,
+                skipEnv: options?.skipEnv,
+            });
+            // Run preRemove lifecycle scripts if defined in module.json
+            const moduleJson = await this.readManifest(this.projectRoot);
+            if (moduleJson?.scripts?.preRemove?.length) {
+                const runner = new ScriptRunner_js_1.ScriptRunner();
+                try {
+                    await runner.runScripts(moduleJson.scripts.preRemove.map((s) => ({ ...s, cwd: this.projectRoot })), 'preRemove', false);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.warn(chalk_1.default.yellow(`
+  ⚠ PreRemove script failed: ${errMsg}`));
+                }
+            }
             // Na desinstalação, removemos por arquivo para evitar múltiplas tentativas
             // de remover marcadores que o regex global já removeu.
             for (const fileName of filesToModify) {
@@ -62,5 +187,14 @@ class ModuleInstaller {
         const updated = this.markerService.removeModule(content, moduleName);
         await fs_extra_1.default.writeFile(filePath, updated);
     }
+    async readManifest(dir) {
+        try {
+            const raw = await fs_extra_1.default.readFile(path_1.default.join(dir, 'module.json'), 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
 }
 exports.ModuleInstaller = ModuleInstaller;

package/dist/core/ProjectInitializer.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectInitializer = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const TEMPLATE_REPO = "https://github.com/kaven-co/kaven-template.git";
+/** Run a shell command via spawn, returning exit code. */
+function runCommand(cmd, args, cwd, onData) {
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, args, { cwd, stdio: onData ? "pipe" : "inherit" });
+        if (onData && proc.stdout) {
+            proc.stdout.on("data", (d) => onData(d.toString()));
+        }
+        if (onData && proc.stderr) {
+            proc.stderr.on("data", (d) => onData(d.toString()));
+        }
+        proc.on("error", reject);
+        proc.on("close", (code) => resolve(code ?? 0));
+    });
+}
+class ProjectInitializer {
+    /** Validate that the project name only contains alphanumerics and hyphens. */
+    validateName(name) {
+        if (!name || name.trim().length === 0) {
+            return { valid: false, reason: "Project name cannot be empty" };
+        }
+        if (/\s/.test(name)) {
+            return { valid: false, reason: "Project name cannot contain spaces" };
+        }
+        if (!/^[a-z0-9-]+$/.test(name)) {
+            return {
+                valid: false,
+                reason: "Project name must only contain lowercase letters, numbers, and hyphens",
+            };
+        }
+        return { valid: true };
+    }
+    /** Clone the template repo with --depth 1 into targetDir. */
+    async cloneTemplate(targetDir) {
+        const exitCode = await runCommand("git", ["clone", "--depth", "1", TEMPLATE_REPO, targetDir], process.cwd());
+        if (exitCode !== 0) {
+            throw new Error(`git clone failed with exit code ${exitCode}`);
+        }
+    }
+    /** Remove the .git directory from the cloned project. */
+    async removeGitDir(targetDir) {
+        const gitDir = path_1.default.join(targetDir, ".git");
+        if (await fs_extra_1.default.pathExists(gitDir)) {
+            await fs_extra_1.default.remove(gitDir);
+        }
+    }
+    /** Replace placeholders in key project files. */
+    async replacePlaceholders(targetDir, values) {
+        const replacements = {
+            "{{PROJECT_NAME}}": values.projectName,
+            "{{DATABASE_URL}}": values.dbUrl,
+            "{{DEFAULT_LOCALE}}": values.locale,
+            "{{DEFAULT_CURRENCY}}": values.currency,
+        };
+        const filesToProcess = [
+            "package.json",
+            ".env.example",
+            "prisma/schema.prisma",
+            "apps/api/package.json",
+            "apps/admin/package.json",
+            "apps/tenant/package.json",
+        ];
+        for (const relFile of filesToProcess) {
+            const filePath = path_1.default.join(targetDir, relFile);
+            if (!(await fs_extra_1.default.pathExists(filePath)))
+                continue;
+            let content = await fs_extra_1.default.readFile(filePath, "utf-8");
+            for (const [placeholder, value] of Object.entries(replacements)) {
+                content = content.split(placeholder).join(value);
+            }
+            await fs_extra_1.default.writeFile(filePath, content, "utf-8");
+        }
+    }
+    /** Run pnpm install in the target directory. */
+    async runInstall(targetDir) {
+        const exitCode = await runCommand("pnpm", ["install"], targetDir);
+        if (exitCode !== 0) {
+            throw new Error(`pnpm install failed with exit code ${exitCode}`);
+        }
+    }
+    /** Initialize git and create an initial commit. */
+    async initGit(targetDir) {
+        await runCommand("git", ["init"], targetDir);
+        await runCommand("git", ["add", "."], targetDir);
+        await runCommand("git", ["commit", "-m", "chore: initial kaven setup"], targetDir);
+    }
+    /** Health check after project initialization. */
+    async healthCheck(targetDir) {
+        const issues = [];
+        // Check key files exist
+        const requiredFiles = ["package.json", ".env.example", "prisma/schema.prisma"];
+        for (const file of requiredFiles) {
+            if (!(await fs_extra_1.default.pathExists(path_1.default.join(targetDir, file)))) {
+                issues.push(`Missing required file: ${file}`);
+            }
+        }
+        // Check node_modules exists (if install was run)
+        const hasNodeModules = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "node_modules"));
+        if (!hasNodeModules) {
+            issues.push("Dependencies not installed. Run: pnpm install");
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+        };
+    }
+}
+exports.ProjectInitializer = ProjectInitializer;