kaven-cli 0.4.0 → 0.4.2-alpha.0

package/dist/core/ConfigManager.js

@@ -1,166 +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.configManager = exports.ConfigManager = exports.configSchema = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const os_1 = __importDefault(require("os"));
-const zod_1 = require("zod");
-const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".kaven");
-const CONFIG_PATH = path_1.default.join(CONFIG_DIR, "config.json");
-exports.configSchema = zod_1.z.object({
-    registry: zod_1.z.string().url().default("https://marketplace.kaven.site"),
-    telemetry: zod_1.z.boolean().default(true),
-    theme: zod_1.z.enum(["light", "dark"]).default("dark"),
-    locale: zod_1.z.string().default("en-US"),
-    // Custom registry support
-    customRegistry: zod_1.z.string().url().optional(),
-    // For storing user preferences
-    lastLogin: zod_1.z.string().datetime().optional(),
-    projectDefaults: zod_1.z
-        .object({
-        dbUrl: zod_1.z.string().optional(),
-        emailProvider: zod_1.z.enum(["postmark", "resend", "ses", "smtp"]).optional(),
-        locale: zod_1.z.string().optional(),
-        currency: zod_1.z.string().optional(),
-    })
-        .optional(),
-});
-class ConfigManager {
-    config;
-    constructor() {
-        this.config = {
-            registry: "https://marketplace.kaven.site",
-            telemetry: true,
-            theme: "dark",
-            locale: "en-US",
-        };
-    }
-    async initialize() {
-        await fs_extra_1.default.ensureDir(CONFIG_DIR);
-        if (await fs_extra_1.default.pathExists(CONFIG_PATH)) {
-            try {
-                const raw = await fs_extra_1.default.readJson(CONFIG_PATH);
-                const parsed = exports.configSchema.safeParse(raw);
-                if (parsed.success) {
-                    this.config = parsed.data;
-                }
-                else {
-                    // If validation fails, use defaults
-                    this.config = {
-                        registry: "https://marketplace.kaven.site",
-                        telemetry: true,
-                        theme: "dark",
-                        locale: "en-US",
-                    };
-                }
-            }
-            catch {
-                // If file is corrupted, start fresh
-                this.config = {
-                    registry: "https://marketplace.kaven.site",
-                    telemetry: true,
-                    theme: "dark",
-                    locale: "en-US",
-                };
-            }
-        }
-        else {
-            // Initialize with defaults
-            this.config = {
-                registry: "https://marketplace.kaven.site",
-                telemetry: true,
-                theme: "dark",
-                locale: "en-US",
-            };
-            await this.persist();
-        }
-    }
-    /**
-     * Get config value with env var override support
-     * Priority: ENV VAR > config file > CLI arg > default
-     */
-    get(key, envVarName) {
-        // Check environment variable override
-        if (envVarName) {
-            const envValue = process.env[envVarName];
-            if (envValue !== undefined) {
-                return envValue;
-            }
-        }
-        // Check config file
-        const value = this.config[key];
-        if (value !== undefined) {
-            return value;
-        }
-        // Return default from schema
-        const defaults = exports.configSchema.parse({});
-        return defaults[key];
-    }
-    /**
-     * Set config value and persist to disk
-     */
-    async set(key, value) {
-        const updateObj = { [key]: value };
-        const updated = exports.configSchema.safeParse({ ...this.config, ...updateObj });
-        if (!updated.success) {
-            const errors = updated.error.issues
-                .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
-                .join(", ");
-            throw new Error(`Invalid config: ${errors}`);
-        }
-        this.config = updated.data;
-        await this.persist();
-    }
-    /**
-     * Get all config
-     */
-    getAll() {
-        return { ...this.config };
-    }
-    /**
-     * Reset config to defaults
-     */
-    async reset() {
-        this.config = {
-            registry: "https://marketplace.kaven.site",
-            telemetry: true,
-            theme: "dark",
-            locale: "en-US",
-        };
-        await this.persist();
-    }
-    /**
-     * Persist config to disk
-     */
-    async persist() {
-        await fs_extra_1.default.ensureDir(CONFIG_DIR);
-        await fs_extra_1.default.writeJson(CONFIG_PATH, this.config, { spaces: 2 });
-    }
-    /**
-     * Get registry URL (custom or default)
-     */
-    getRegistry() {
-        return (this.config.customRegistry || this.config.registry || "https://marketplace.kaven.site");
-    }
-    /**
-     * Check if telemetry is enabled (can be overridden by env var)
-     */
-    isTelemetryEnabled() {
-        if (process.env.KAVEN_TELEMETRY === "0") {
-            return false;
-        }
-        return this.config.telemetry !== false;
-    }
-    /**
-     * Get config directory path
-     */
-    getConfigDir() {
-        return CONFIG_DIR;
-    }
-}
-exports.ConfigManager = ConfigManager;
-// Export singleton instance
-exports.configManager = new ConfigManager();

package/dist/core/EnvManager.js

@@ -1,196 +0,0 @@
-"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.EnvManager = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const readline = __importStar(require("readline"));
-const chalk_1 = __importDefault(require("chalk"));
-class EnvManager {
-    async injectEnvVars(moduleSlug, envVars, options) {
-        if (options.skipEnv || !envVars || envVars.length === 0) {
-            return { added: 0, skipped: 0 };
-        }
-        const envFilePath = path.join(options.projectDir, options.envFile ?? '.env');
-        const existingContent = this.readEnvFile(envFilePath);
-        const existingVars = this.parseEnvFile(existingContent);
-        const newVars = [];
-        let skipped = 0;
-        console.log(chalk_1.default.bold(`\n  Environment variables for '${moduleSlug}':\n`));
-        for (const envDef of envVars) {
-            if (existingVars.has(envDef.name)) {
-                console.log(chalk_1.default.dim(`  ${envDef.name} — already set, skipping`));
-                skipped++;
-                continue;
-            }
-            let value;
-            if (envDef.sensitive) {
-                value = await this.promptPassword(`  ${envDef.name} (${envDef.description})${envDef.default ? ' [****]' : ''}: `);
-                if (!value && envDef.default)
-                    value = envDef.default;
-            }
-            else {
-                const defaultHint = envDef.default ? ` [${envDef.default}]` : '';
-                value = await this.promptInput(`  ${envDef.name} (${envDef.description})${defaultHint}: `, envDef.default);
-            }
-            if (envDef.required && !value) {
-                console.log(chalk_1.default.yellow(`  ${envDef.name} is required.`));
-                value = envDef.sensitive
-                    ? await this.promptPassword(`  ${envDef.name}: `)
-                    : await this.promptInput(`  ${envDef.name}: `);
-                if (!value) {
-                    console.log(chalk_1.default.yellow(`  Skipping ${envDef.name} — set it manually in .env`));
-                    skipped++;
-                    continue;
-                }
-            }
-            newVars.push({ name: envDef.name, value });
-        }
-        if (newVars.length === 0) {
-            console.log(chalk_1.default.dim('  No new environment variables to add.'));
-            return { added: 0, skipped };
-        }
-        const markerBlock = this.buildMarkerBlock(moduleSlug, newVars);
-        this.appendToEnvFile(envFilePath, existingContent, markerBlock);
-        console.log(chalk_1.default.green(`\n  Added ${newVars.length} environment variable(s) to ${options.envFile ?? '.env'}`));
-        return { added: newVars.length, skipped };
-    }
-    removeEnvVars(moduleSlug, options) {
-        const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
-        if (options.envFile)
-            envFiles.unshift(options.envFile);
-        let totalRemoved = 0;
-        for (const envFile of envFiles) {
-            const envFilePath = path.join(options.projectDir, envFile);
-            if (!fs.existsSync(envFilePath))
-                continue;
-            const content = fs.readFileSync(envFilePath, 'utf-8');
-            const beginMarker = `# [KAVEN_MODULE:${moduleSlug} BEGIN]`;
-            const endMarker = `# [KAVEN_MODULE:${moduleSlug} END]`;
-            const beginIdx = content.indexOf(beginMarker);
-            const endIdx = content.indexOf(endMarker);
-            if (beginIdx === -1 || endIdx === -1)
-                continue;
-            const block = content.substring(beginIdx, endIdx + endMarker.length);
-            const varCount = block.split('\n').filter(l => /^[A-Z_]+=/.test(l)).length;
-            const before = content.substring(0, beginIdx).replace(/\n+$/, '\n');
-            const after = content.substring(endIdx + endMarker.length + 1);
-            fs.writeFileSync(envFilePath, before + after);
-            totalRemoved += varCount;
-            if (varCount > 0) {
-                console.log(chalk_1.default.dim(`  Removed ${varCount} env var(s) from ${envFile}`));
-            }
-        }
-        return totalRemoved;
-    }
-    readEnvFile(filePath) {
-        try {
-            return fs.readFileSync(filePath, 'utf-8');
-        }
-        catch {
-            return '';
-        }
-    }
-    parseEnvFile(content) {
-        const vars = new Map();
-        for (const line of content.split('\n')) {
-            const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
-            if (match)
-                vars.set(match[1], match[2]);
-        }
-        return vars;
-    }
-    buildMarkerBlock(moduleSlug, vars) {
-        return [
-            `# [KAVEN_MODULE:${moduleSlug} BEGIN]`,
-            ...vars.map(v => `${v.name}=${v.value}`),
-            `# [KAVEN_MODULE:${moduleSlug} END]`,
-        ].join('\n');
-    }
-    appendToEnvFile(filePath, existingContent, block) {
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        const separator = existingContent.endsWith('\n') || existingContent === '' ? '\n' : '\n\n';
-        fs.writeFileSync(filePath, existingContent + separator + block + '\n');
-    }
-    promptInput(message, defaultValue) {
-        return new Promise(resolve => {
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            rl.question(message, answer => {
-                rl.close();
-                resolve(answer || defaultValue || '');
-            });
-        });
-    }
-    promptPassword(message) {
-        return new Promise(resolve => {
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            // Hide input by listening to keypress but readline doesn't natively support this
-            // For simplicity, use standard prompt (production would use a proper password lib)
-            process.stdout.write(message);
-            process.stdin.setRawMode?.(true);
-            process.stdin.resume();
-            let password = '';
-            const handler = (key) => {
-                const char = key.toString();
-                if (char === '\r' || char === '\n') {
-                    process.stdin.setRawMode?.(false);
-                    process.stdin.pause();
-                    process.stdin.removeListener('data', handler);
-                    process.stdout.write('\n');
-                    rl.close();
-                    resolve(password);
-                }
-                else if (char === '\u0003') {
-                    process.exit();
-                }
-                else if (char === '\u007f') {
-                    password = password.slice(0, -1);
-                    process.stdout.clearLine(0);
-                    process.stdout.cursorTo(0);
-                    process.stdout.write(message + '*'.repeat(password.length));
-                }
-                else {
-                    password += char;
-                    process.stdout.write('*');
-                }
-            };
-            process.stdin.on('data', handler);
-        });
-    }
-}
-exports.EnvManager = EnvManager;

package/dist/core/ErrorRecovery.js

@@ -1,192 +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.ErrorRecovery = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const os_1 = __importDefault(require("os"));
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-/**
- * C2.7: Error recovery and validation system
- */
-class ErrorRecovery {
-    backupDir;
-    constructor() {
-        this.backupDir = path_1.default.join(os_1.default.homedir(), ".kaven", "backups");
-    }
-    /**
-     * Create a backup of the project state before operation
-     */
-    async createBackup(projectPath, operationName) {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-").substring(0, 19);
-        const backupName = `${operationName}-${timestamp}`;
-        const backupPath = path_1.default.join(this.backupDir, backupName);
-        try {
-            await fs_extra_1.default.ensureDir(this.backupDir);
-            // Backup key files
-            const files = ["package.json", "pnpm-lock.yaml", ".env", "prisma/schema.prisma"];
-            for (const file of files) {
-                const source = path_1.default.join(projectPath, file);
-                const dest = path_1.default.join(backupPath, file);
-                if (await fs_extra_1.default.pathExists(source)) {
-                    await fs_extra_1.default.ensureDir(path_1.default.dirname(dest));
-                    await fs_extra_1.default.copy(source, dest);
-                }
-            }
-            return backupPath;
-        }
-        catch (error) {
-            throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Rollback from backup
-     */
-    async rollback(projectPath, backupPath) {
-        try {
-            if (!(await fs_extra_1.default.pathExists(backupPath))) {
-                throw new Error(`Backup not found at ${backupPath}`);
-            }
-            const files = ["package.json", "pnpm-lock.yaml", ".env", "prisma/schema.prisma"];
-            for (const file of files) {
-                const source = path_1.default.join(backupPath, file);
-                const dest = path_1.default.join(projectPath, file);
-                if (await fs_extra_1.default.pathExists(source)) {
-                    await fs_extra_1.default.copy(source, dest, { overwrite: true });
-                }
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to rollback: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Pre-operation validation
-     */
-    async validatePreConditions(projectPath) {
-        const errors = [];
-        // Check package.json exists
-        if (!(await fs_extra_1.default.pathExists(path_1.default.join(projectPath, "package.json")))) {
-            errors.push("package.json not found");
-        }
-        // Check node_modules exists
-        if (!(await fs_extra_1.default.pathExists(path_1.default.join(projectPath, "node_modules")))) {
-            errors.push("Dependencies not installed. Run: pnpm install");
-        }
-        // Check if git repo (for safety)
-        const gitDir = path_1.default.join(projectPath, ".git");
-        if (!(await fs_extra_1.default.pathExists(gitDir))) {
-            errors.push("Not a git repository. Initialize with: git init && git add . && git commit");
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-        };
-    }
-    /**
-     * Post-operation health check
-     */
-    async validatePostConditions(projectPath) {
-        const issues = [];
-        // Check package.json is valid JSON
-        try {
-            const packageJson = await fs_extra_1.default.readJson(path_1.default.join(projectPath, "package.json"));
-            if (!packageJson.name) {
-                issues.push("package.json missing name field");
-            }
-        }
-        catch {
-            issues.push("package.json is invalid JSON");
-        }
-        // Check prisma schema if it exists
-        const schemaPath = path_1.default.join(projectPath, "prisma", "schema.prisma");
-        if (await fs_extra_1.default.pathExists(schemaPath)) {
-            const content = await fs_extra_1.default.readFile(schemaPath, "utf-8");
-            if (!content.includes("datasource db")) {
-                issues.push("prisma/schema.prisma missing datasource");
-            }
-        }
-        // Check .env exists or .env.example exists
-        const envPath = path_1.default.join(projectPath, ".env");
-        const envExamplePath = path_1.default.join(projectPath, ".env.example");
-        if (!(await fs_extra_1.default.pathExists(envPath)) && !(await fs_extra_1.default.pathExists(envExamplePath))) {
-            issues.push("No .env or .env.example file found");
-        }
-        return {
-            healthy: issues.length === 0,
-            issues,
-        };
-    }
-    /**
-     * Run operation with automatic rollback on failure
-     */
-    async withRollback(projectPath, operationName, operation) {
-        // Pre-validation
-        const preCheck = await this.validatePreConditions(projectPath);
-        if (!preCheck.valid) {
-            throw new Error(`Pre-conditions not met:\n${preCheck.errors.map((e) => `  - ${e}`).join("\n")}`);
-        }
-        // Create backup
-        const spinner = (0, ora_1.default)("Creating backup...").start();
-        const backupPath = await this.createBackup(projectPath, operationName);
-        spinner.succeed(`Backup created at ${backupPath}`);
-        try {
-            // Run operation
-            const result = await operation();
-            // Post-validation
-            const postCheck = await this.validatePostConditions(projectPath);
-            if (!postCheck.healthy) {
-                spinner.warn("Post-operation issues detected:");
-                for (const issue of postCheck.issues) {
-                    console.log(chalk_1.default.yellow(`  ⚠ ${issue}`));
-                }
-            }
-            return result;
-        }
-        catch (error) {
-            // Rollback on failure
-            spinner.start("Rolling back...");
-            try {
-                await this.rollback(projectPath, backupPath);
-                spinner.succeed("Rolled back successfully");
-            }
-            catch (rollbackError) {
-                spinner.fail(`Rollback failed: ${rollbackError}`);
-                console.error(chalk_1.default.red("Manual intervention required:"));
-                console.error(chalk_1.default.gray(`Backup available at: ${backupPath}`));
-            }
-            throw error;
-        }
-    }
-    /**
-     * List available backups
-     */
-    async listBackups() {
-        if (!(await fs_extra_1.default.pathExists(this.backupDir))) {
-            return [];
-        }
-        const entries = await fs_extra_1.default.readdir(this.backupDir);
-        return entries.map((name) => ({
-            name,
-            path: path_1.default.join(this.backupDir, name),
-            timestamp: name.substring(name.lastIndexOf("-") + 1),
-        }));
-    }
-    /**
-     * Clean old backups (keep last N)
-     */
-    async cleanupBackups(keepCount = 5) {
-        const backups = await this.listBackups();
-        if (backups.length <= keepCount) {
-            return;
-        }
-        const toDelete = backups.slice(keepCount);
-        for (const backup of toDelete) {
-            await fs_extra_1.default.remove(backup.path);
-        }
-    }
-}
-exports.ErrorRecovery = ErrorRecovery;

package/dist/core/LicenseService.js

@@ -1,83 +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.LicenseService = void 0;
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const CACHE_FILE = path_1.default.join(os_1.default.homedir(), '.kaven', 'cache', 'licenses.json');
-const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
-class LicenseService {
-    cacheDir = path_1.default.join(os_1.default.homedir(), '.kaven', 'cache');
-    /** Luhn mod-31 checksum format check (KAVEN-{TIER}-{8RANDOM}-{CHECKSUM}) */
-    isValidFormat(licenseKey) {
-        const pattern = /^KAVEN-(STARTER|COMPLETE|PRO|ENTERPRISE)-[A-Z0-9]{8}-[A-Z0-9]{2}$/;
-        return pattern.test(licenseKey);
-    }
-    async readCache() {
-        try {
-            const raw = await promises_1.default.readFile(CACHE_FILE, 'utf-8');
-            return JSON.parse(raw);
-        }
-        catch {
-            return {};
-        }
-    }
-    async writeCache(cache) {
-        await promises_1.default.mkdir(this.cacheDir, { recursive: true });
-        await promises_1.default.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
-    }
-    isCacheValid(entry) {
-        return Date.now() - entry.validatedAt < CACHE_TTL_MS;
-    }
-    async getCached(licenseKey) {
-        const cache = await this.readCache();
-        const entry = cache[licenseKey];
-        if (entry && this.isCacheValid(entry))
-            return entry;
-        return null;
-    }
-    async setCached(entry) {
-        const cache = await this.readCache();
-        cache[entry.key] = { ...entry, validatedAt: Date.now() };
-        await this.writeCache(cache);
-    }
-    async validateLicense(licenseKey, requiredTier) {
-        // 1. Check cache first
-        const cached = await this.getCached(licenseKey);
-        if (cached) {
-            return { valid: true, tier: cached.tier, expiresAt: cached.expiresAt, source: 'cache' };
-        }
-        // 2. Format check (offline Luhn-style)
-        if (!this.isValidFormat(licenseKey)) {
-            throw new Error('Invalid license key format');
-        }
-        // 3. API validation
-        const { MarketplaceClient } = await import('../infrastructure/MarketplaceClient.js');
-        const client = new MarketplaceClient();
-        const result = await client.validateLicense(licenseKey, requiredTier);
-        // Cache on success
-        await this.setCached({
-            key: licenseKey,
-            tier: result.tier,
-            expiresAt: result.expiresAt,
-            validatedAt: Date.now(),
-        });
-        return { ...result, source: 'api' };
-    }
-    async getLicenseStatus(licenseKey) {
-        const { MarketplaceClient } = await import('../infrastructure/MarketplaceClient.js');
-        const client = new MarketplaceClient();
-        return client.getLicenseStatus(licenseKey);
-    }
-    tierLevel(tier) {
-        const levels = { STARTER: 1, COMPLETE: 2, PRO: 3, ENTERPRISE: 4 };
-        return levels[tier.toUpperCase()] ?? 0;
-    }
-    userHasRequiredTier(userTier, requiredTier) {
-        return this.tierLevel(userTier) >= this.tierLevel(requiredTier);
-    }
-}
-exports.LicenseService = LicenseService;

package/dist/core/ManifestParser.js

@@ -1,52 +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.ManifestParser = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const manifest_1 = require("../types/manifest");
-const zod_1 = require("zod");
-class ManifestParser {
-    async parse(manifestPath) {
-        if (!(await fs_extra_1.default.pathExists(manifestPath))) {
-            throw new Error(`Manifest not found: ${manifestPath}`);
-        }
-        const content = await fs_extra_1.default.readFile(manifestPath, "utf-8");
-        let json;
-        try {
-            json = JSON.parse(content);
-        }
-        catch {
-            throw new Error(`Failed to parse manifest JSON: ${manifestPath}`);
-        }
-        try {
-            return manifest_1.ModuleManifestSchema.parse(json);
-        }
-        catch (error) {
-            if (error instanceof zod_1.ZodError) {
-                throw new Error(`Invalid manifest: \n${this.formatZodError(error)}`);
-            }
-            throw error;
-        }
-    }
-    async validate(manifestPath) {
-        try {
-            await this.parse(manifestPath);
-            return { valid: true, errors: [] };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-                valid: false,
-                errors: [errorMessage],
-            };
-        }
-    }
-    formatZodError(error) {
-        return error.issues
-            .map((err) => `  - ${err.path.map(String).join(".")}: ${err.message}`)
-            .join("\n");
-    }
-}
-exports.ManifestParser = ManifestParser;