kaven-cli 0.4.0 → 0.5.0

package/dist/core/MarkerService.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarkerService = void 0;
-const markers_1 = require("../types/markers");
-class MarkerService {
-    hasModule(fileContent, moduleName) {
-        const marker = (0, markers_1.createMarker)(moduleName);
-        return (fileContent.includes(marker.beginMarker) &&
-            fileContent.includes(marker.endMarker));
-    }
-    detectMarkers(fileContent, moduleName) {
-        const marker = (0, markers_1.createMarker)(moduleName);
-        const lines = fileContent.split("\n");
-        let beginLine;
-        let endLine;
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i].includes(marker.beginMarker)) {
-                beginLine = i;
-            }
-            if (lines[i].includes(marker.endMarker)) {
-                endLine = i;
-                break;
-            }
-        }
-        if (beginLine !== undefined && endLine !== undefined) {
-            const content = lines.slice(beginLine + 1, endLine).join("\n");
-            return {
-                found: true,
-                beginLine,
-                endLine,
-                content,
-            };
-        }
-        return { found: false };
-    }
-    injectModule(fileContent, anchor, moduleName, code) {
-        if (this.hasModule(fileContent, moduleName)) {
-            throw new Error(`Module ${moduleName} already injected`);
-        }
-        if (!fileContent.includes(anchor)) {
-            throw new Error(`Anchor not found: ${anchor}`);
-        }
-        const marker = (0, markers_1.createMarker)(moduleName);
-        const markedCode = `\n${marker.beginMarker}\n${code}\n${marker.endMarker}\n`;
-        return fileContent.replace(anchor, `${anchor}${markedCode}`);
-    }
-    removeModule(fileContent, moduleName) {
-        const marker = (0, markers_1.createMarker)(moduleName);
-        const beginMarker = this.escapeRegex(marker.beginMarker);
-        const endMarker = this.escapeRegex(marker.endMarker);
-        const regex = new RegExp(`\\n?${beginMarker}[\\s\\S]*?${endMarker}\\n?`, "g");
-        const result = fileContent.replace(regex, "");
-        if (result === fileContent) {
-            throw new Error(`Module ${moduleName} not found in file`);
-        }
-        return result;
-    }
-    escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }
-}
-exports.MarkerService = MarkerService;

package/dist/core/ModuleDoctor.js

@@ -1,451 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-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 {
-    projectRoot;
-    markerService;
-    manifestParser;
-    constructor(projectRoot, markerService, manifestParser) {
-        this.projectRoot = projectRoot;
-        this.markerService = markerService;
-        this.manifestParser = manifestParser;
-    }
-    async checkAll() {
-        const results = [];
-        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() {
-        const results = [];
-        const expectedAnchors = [
-            { file: "apps/api/src/app.ts", anchor: "// [KAVEN_MODULE_IMPORTS]" },
-            { file: "apps/api/src/app.ts", anchor: "// [KAVEN_MODULE_HOOKS]" },
-            { file: "apps/api/src/app.ts", anchor: "// [KAVEN_MODULE_REGISTRATION]" },
-        ];
-        for (const { file, anchor } of expectedAnchors) {
-            const filePath = path_1.default.join(this.projectRoot, file);
-            if (!(await fs_extra_1.default.pathExists(filePath))) {
-                results.push({
-                    type: "anchor",
-                    severity: "warning",
-                    message: `File not found: ${file}`,
-                    file,
-                    fixable: false,
-                });
-                continue;
-            }
-            const content = await fs_extra_1.default.readFile(filePath, "utf-8");
-            if (!content.includes(anchor)) {
-                results.push({
-                    type: "anchor",
-                    severity: "error",
-                    message: `Missing anchor: ${anchor}`,
-                    file,
-                    fixable: false,
-                });
-            }
-        }
-        return results;
-    }
-    async checkMarkers() {
-        const results = [];
-        const config = await this.readKavenConfig();
-        const installedModules = config.modules.filter((m) => m.installed);
-        for (const module of installedModules) {
-            const manifestPath = path_1.default.join(this.projectRoot, ".kaven/modules", module.name, "module.json");
-            if (!(await fs_extra_1.default.pathExists(manifestPath))) {
-                results.push({
-                    type: "marker",
-                    severity: "error",
-                    message: `Manifest not found for installed module: ${module.name}`,
-                    fixable: false,
-                });
-                continue;
-            }
-            try {
-                const manifest = await this.manifestParser.parse(manifestPath);
-                for (const injection of manifest.injections) {
-                    const filePath = path_1.default.join(this.projectRoot, injection.file);
-                    if (!(await fs_extra_1.default.pathExists(filePath))) {
-                        results.push({
-                            type: "marker",
-                            severity: "error",
-                            message: `Injection target not found: ${injection.file}`,
-                            file: injection.file,
-                            fixable: false,
-                        });
-                        continue;
-                    }
-                    const content = await fs_extra_1.default.readFile(filePath, "utf-8");
-                    const moduleName = injection.moduleName || module.name;
-                    const detection = this.markerService.detectMarkers(content, moduleName);
-                    if (!detection.found) {
-                        results.push({
-                            type: "marker",
-                            severity: "error",
-                            message: `Module ${module.name} not injected in ${injection.file}`,
-                            file: injection.file,
-                            fixable: true,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                results.push({
-                    type: "marker",
-                    severity: "error",
-                    message: `Invalid manifest for module ${module.name}: ${error instanceof Error ? error.message : String(error)}`,
-                    fixable: false,
-                });
-            }
-        }
-        return results;
-    }
-    async checkDependencies() {
-        const results = [];
-        const config = await this.readKavenConfig();
-        const installedModules = config.modules.filter((m) => m.installed);
-        const packageJsonPath = path_1.default.join(this.projectRoot, "package.json");
-        if (!(await fs_extra_1.default.pathExists(packageJsonPath))) {
-            results.push({
-                type: "dependency",
-                severity: "error",
-                message: "package.json not found",
-                fixable: false,
-            });
-            return results;
-        }
-        const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
-        for (const module of installedModules) {
-            const manifestPath = path_1.default.join(this.projectRoot, ".kaven/modules", module.name, "module.json");
-            if (!(await fs_extra_1.default.pathExists(manifestPath)))
-                continue;
-            try {
-                const manifest = await this.manifestParser.parse(manifestPath);
-                for (const dep of manifest.dependencies.npm) {
-                    const [name] = dep.split("@");
-                    const hasInDeps = packageJson.dependencies?.[name];
-                    const hasInDevDeps = packageJson.devDependencies?.[name];
-                    if (!hasInDeps && !hasInDevDeps) {
-                        results.push({
-                            type: "dependency",
-                            severity: "warning",
-                            message: `Missing npm dependency: ${dep}`,
-                            fixable: true,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Ignorar erros de manifest aqui, já tratados em checkMarkers
-            }
-        }
-        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.json");
-        if (!(await fs_extra_1.default.pathExists(configPath))) {
-            return { modules: [] };
-        }
-        try {
-            return await fs_extra_1.default.readJSON(configPath);
-        }
-        catch {
-            return { modules: [] };
-        }
-    }
-}
-exports.ModuleDoctor = ModuleDoctor;

package/dist/core/ModuleInstaller.js

@@ -1,169 +0,0 @@
-"use strict";
-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 {
-    projectRoot;
-    markerService;
-    constructor(projectRoot, markerService) {
-        this.projectRoot = projectRoot;
-        this.markerService = markerService;
-    }
-    /**
-     * 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 import("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)));
-            await tx.backup(filesToModify);
-            for (const injection of manifest.injections) {
-                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 import('./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);
-            console.error(`❌ Installation failed: ${errorMessage}`);
-            console.log(`🔄 Rolling back...`);
-            await tx.rollback();
-            throw error;
-        }
-    }
-    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 import('./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) {
-                await this.removeCode(fileName, manifest.name);
-            }
-            await tx.commit();
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`❌ Removal failed: ${errorMessage}`);
-            console.log(`🔄 Rolling back...`);
-            await tx.rollback();
-            throw error;
-        }
-    }
-    async injectCode(injection) {
-        const filePath = path_1.default.join(this.projectRoot, injection.file);
-        const content = await fs_extra_1.default.readFile(filePath, "utf-8");
-        const updated = this.markerService.injectModule(content, injection.anchor, injection.moduleName || "unnamed", injection.code);
-        await fs_extra_1.default.writeFile(filePath, updated);
-    }
-    async removeCode(fileName, moduleName) {
-        const filePath = path_1.default.join(this.projectRoot, fileName);
-        const content = await fs_extra_1.default.readFile(filePath, "utf-8");
-        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;