kaven-cli 0.4.1-alpha.0 → 0.5.0

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;

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;