kaven-cli 0.3.0 → 0.3.5

package/dist/core/api/KavenApiClient.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KavenApiClient = exports.ApiError = void 0;
-const AuthManager_1 = require("../auth/AuthManager");
-const errors_1 = require("../../lib/errors");
-class ApiError extends errors_1.KavenError {
-    constructor(message, status) {
-        super(message, 'API_ERROR');
-        this.status = status;
-        this.name = 'ApiError';
-    }
-}
-exports.ApiError = ApiError;
-class KavenApiClient {
-    static async fetch(endpoint, options = {}) {
-        const url = `${this.baseUrl}${endpoint}`;
-        const headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
-            ...options.headers,
-        };
-        // Inject token if available
-        const session = await AuthManager_1.AuthManager.getSession();
-        if (session?.accessToken) {
-            headers['Authorization'] = `Bearer ${session.accessToken}`;
-        }
-        try {
-            // We rely on Global Fetch (Node 20+)
-            const response = await fetch(url, { ...options, headers });
-            if (!response.ok) {
-                throw new ApiError(`Request failed: ${response.statusText}`, response.status);
-            }
-            // Check if response is JSON
-            const contentType = response.headers.get('content-type');
-            if (contentType && contentType.includes('application/json')) {
-                return await response.json();
-            }
-            return {}; // Return empty object for 204 or non-json
-        }
-        catch (error) {
-            if (error instanceof ApiError)
-                throw error;
-            throw new ApiError(`Network error: ${error instanceof Error ? error.message : String(error)}`, 0);
-        }
-    }
-    // --- Endpoints ---
-    static async listMarketplaceModules() {
-        return this.fetch('/modules');
-    }
-    static async initiateDeviceFlow() {
-        return this.fetch('/auth/device/code', { method: 'POST' });
-    }
-    static async pollToken(deviceCode) {
-        return this.fetch('/auth/token', {
-            method: 'POST',
-            body: JSON.stringify({ device_code: deviceCode, grant_type: 'urn:ietf:params:oauth:grant-type:device_code' })
-        });
-    }
-}
-exports.KavenApiClient = KavenApiClient;
-KavenApiClient.baseUrl = process.env.KAVEN_API_URL || 'https://api.kaven.dev';

package/dist/core/auth/AuthManager.js

@@ -1,91 +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.AuthManager = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const logger_1 = require("../../lib/logger");
-const KavenApiClient_1 = require("../api/KavenApiClient");
-class AuthManager {
-    static setConfigDir(dir) {
-        this.configDir = dir;
-        this.credentialsFile = path_1.default.join(dir, 'credentials.json');
-    }
-    static async getSession() {
-        if (!await fs_extra_1.default.pathExists(this.credentialsFile)) {
-            return null;
-        }
-        try {
-            return await fs_extra_1.default.readJson(this.credentialsFile);
-        }
-        catch {
-            return null;
-        }
-    }
-    static async isAuthenticated() {
-        const session = await this.getSession();
-        return !!session?.accessToken;
-    }
-    static async saveSession(session) {
-        await fs_extra_1.default.ensureDir(this.configDir);
-        await fs_extra_1.default.writeJson(this.credentialsFile, session, { spaces: 2 });
-    }
-    static async logout() {
-        await fs_extra_1.default.remove(this.credentialsFile);
-        logger_1.Logger.success('Logged out successfully');
-    }
-    static async login() {
-        try {
-            const { device_code, user_code, verification_uri, expires_in } = await KavenApiClient_1.KavenApiClient.initiateDeviceFlow();
-            logger_1.Logger.box('Device Authentication', [
-                `1. Open: ${verification_uri}`,
-                `2. Code: ${user_code}`,
-            ]);
-            logger_1.Logger.startSpinner('Waiting for authentication...');
-            // Poll logic with simple linear backoff/timeout inside polling loop logic
-            // Real impl implies KavenApiClient.pollToken loops or we loop here.
-            // KavenApiClient.pollToken signature above suggests single call, so we loop here.
-            const start = Date.now();
-            const timeout = expires_in * 1000;
-            while (Date.now() - start < timeout) {
-                try {
-                    // In real world, pollToken throws "pending" or 400 until done.
-                    // For this stub/MVP, we assume pollToken either waits or returns immediately.
-                    // If we are simulating "real" behavior, pollToken would fail multiple times.
-                    await new Promise(r => setTimeout(r, 2000)); // Sleep 2s
-                    const tokens = await KavenApiClient_1.KavenApiClient.pollToken(device_code);
-                    if (tokens.access_token) {
-                        await this.saveSession({
-                            accessToken: tokens.access_token,
-                            refreshToken: tokens.refresh_token,
-                        });
-                        logger_1.Logger.succeedSpinner('Authenticated successfully!');
-                        return true;
-                    }
-                }
-                catch (error) {
-                    // Ignore pending errors, propagate others
-                    const msg = error instanceof Error ? error.message : String(error);
-                    if (!msg.includes('authorization_pending')) {
-                        // If we can't distinguish, we might break early. For now, we assume simulated env (see test).
-                        // If simulated, it succeeds immediately.
-                    }
-                }
-            }
-            logger_1.Logger.stopSpinner();
-            logger_1.Logger.error('Authentication timed out');
-            return false;
-        }
-        catch (error) {
-            logger_1.Logger.stopSpinner();
-            logger_1.Logger.error('Login failed', error);
-            return false;
-        }
-    }
-}
-exports.AuthManager = AuthManager;
-AuthManager.configDir = process.env.KAVEN_CONFIG_DIR || path_1.default.join(os_1.default.homedir(), '.kaven');
-AuthManager.credentialsFile = path_1.default.join(AuthManager.configDir, 'credentials.json');

package/dist/core/modules/Injector.js

@@ -1,86 +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.Injector = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const logger_1 = require("../../lib/logger");
-class Injector {
-    /**
-     * Injects content into a file relative to an anchor.
-     * Idempotency is guaranteed by checking if content is already present.
-     */
-    static async inject(targetPath, anchor, content, strategy = 'append') {
-        if (!await fs_extra_1.default.pathExists(targetPath)) {
-            logger_1.Logger.warn(`Injector target not found: ${targetPath}`);
-            return false;
-        }
-        const fileContent = await fs_extra_1.default.readFile(targetPath, 'utf8');
-        // 1. Check idempotency (is content already there?)
-        if (fileContent.includes(content)) {
-            // Content already exists, skip
-            return true;
-        }
-        // 2. Find anchor
-        // We assume anchor is like "KAVEN_MODULE_IMPORTS" and exists in file as "// [KAVEN_MODULE_IMPORTS]"
-        // But the manifest only provides the raw string info.
-        // Doc 3 standardizes anchors as `// [NAME]`. 
-        // However, for maximum compatibility with current manifest (which just says "KAVEN_MODULE_IMPORTS"),
-        // we construct the search string.
-        const anchorPattern = `// [${anchor}]`;
-        if (!fileContent.includes(anchorPattern) && !fileContent.includes(anchor)) {
-            logger_1.Logger.warn(`Injector anchor '${anchor}' not found in ${targetPath}`);
-            return false;
-        }
-        // Use the exact string found in file if possible, or default to constructed one
-        const anchorString = fileContent.includes(anchorPattern) ? anchorPattern : anchor;
-        let newContent = fileContent;
-        if (strategy === 'append') {
-            // Padrão: <Conteudo Injetado>\n<Anchor>
-            // Ou seja, insere ANTES do anchor para preservar o anchor no final do bloco?
-            // Doc 3: "O CLI injeta conteúdo substituindo o anchor por: <snippet>\n<anchor>"
-            // Isso significa que o anchor é empurrado para baixo.
-            newContent = fileContent.replace(anchorString, `${content}\n${anchorString}`);
-        }
-        else if (strategy === 'prepend') {
-            newContent = fileContent.replace(anchorString, `${anchorString}\n${content}`);
-        }
-        else if (strategy === 'replace') {
-            newContent = fileContent.replace(anchorString, content);
-        }
-        await fs_extra_1.default.writeFile(targetPath, newContent, 'utf8');
-        return true;
-    }
-    /**
-     * Removes content from a file.
-     */
-    static async eject(targetPath, content) {
-        if (!await fs_extra_1.default.pathExists(targetPath)) {
-            logger_1.Logger.warn(`Injector target not found: ${targetPath}`);
-            return false;
-        }
-        const fileContent = await fs_extra_1.default.readFile(targetPath, 'utf8');
-        if (!fileContent.includes(content)) {
-            // Content not present, nothing to do
-            return false;
-        }
-        // Attempt to remove content + newline before or after
-        // Strategy: Replace content literal. 
-        // We try to clean up surrounding newlines too if possible, but safely.
-        // For now, simple replacement is safest to start.
-        // We also need to handle the case where content was injected with a newline appended/prepended.
-        // Ideally we match exactly what was injected. 
-        // Since `inject` does `${content}\n${anchorString}`, checks if we can remove `${content}\n`.
-        let newContent = fileContent.replace(content + '\n', '');
-        if (newContent === fileContent) {
-            newContent = fileContent.replace('\n' + content, '');
-        }
-        if (newContent === fileContent) {
-            newContent = fileContent.replace(content, '');
-        }
-        await fs_extra_1.default.writeFile(targetPath, newContent, 'utf8');
-        return true;
-    }
-}
-exports.Injector = Injector;

package/dist/core/modules/ModuleInstaller.js

@@ -1,63 +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 path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const Injector_1 = require("./Injector");
-const config_1 = require("../../lib/config");
-const logger_1 = require("../../lib/logger");
-const errors_1 = require("../../lib/errors");
-class ModuleInstaller {
-    static async install(manifest, projectRoot, modulesSourceRoot) {
-        logger_1.Logger.startSpinner(`Installing module: ${manifest.displayName}...`);
-        try {
-            // 1. Validation (Env vars, Compat)
-            // TODO: Env check against .env.example or interactive prompt
-            // 2. Copy Files
-            const moduleSourceDir = path_1.default.join(modulesSourceRoot, manifest.slug);
-            // 2a. API
-            if (await fs_extra_1.default.pathExists(path_1.default.join(moduleSourceDir, 'api'))) {
-                const dest = path_1.default.join(projectRoot, 'apps/api/src/modules', manifest.slug);
-                await fs_extra_1.default.copy(path_1.default.join(moduleSourceDir, 'api'), dest);
-            }
-            // 2b. Admin
-            if (await fs_extra_1.default.pathExists(path_1.default.join(moduleSourceDir, 'admin'))) {
-                const dest = path_1.default.join(projectRoot, 'apps/admin/app/[locale]/(dashboard)', manifest.slug);
-                await fs_extra_1.default.copy(path_1.default.join(moduleSourceDir, 'admin'), dest);
-            }
-            // 3. Injections
-            for (const injection of manifest.injections) {
-                const targetPath = path_1.default.join(projectRoot, injection.targetFile);
-                await Injector_1.Injector.inject(targetPath, injection.anchor, injection.content, injection.strategy);
-            }
-            // 4. Update Config
-            if (await config_1.ConfigManager.exists(projectRoot)) {
-                const config = await config_1.ConfigManager.load(projectRoot);
-                // Add to optional modules
-                if (!config.kaven.modules.optional)
-                    config.kaven.modules.optional = {};
-                config.kaven.modules.optional[manifest.slug] = true;
-                // Add to customizations
-                if (!config.kaven.customizations.addedModules.includes(manifest.slug)) {
-                    config.kaven.customizations.addedModules.push(manifest.slug);
-                }
-                // Remove from removedModules
-                config.kaven.customizations.removedModules = config.kaven.customizations.removedModules.filter(m => m !== manifest.slug);
-                await config_1.ConfigManager.save(projectRoot, config);
-            }
-            else {
-                logger_1.Logger.warn('kaven.config.json not found, skipping config update.');
-            }
-            logger_1.Logger.succeedSpinner(`Module ${manifest.displayName} installed successfully.`);
-        }
-        catch (error) {
-            logger_1.Logger.stopSpinner();
-            logger_1.Logger.error(`Failed to install module ${manifest.slug}`, error);
-            throw new errors_1.ModuleError(`Installation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-exports.ModuleInstaller = ModuleInstaller;

package/dist/core/modules/ModuleManager.js

@@ -1,59 +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.ModuleManager = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const zod_1 = require("zod");
-const module_1 = require("../../types/module");
-const errors_1 = require("../../lib/errors");
-const logger_1 = require("../../lib/logger");
-class ModuleManager {
-    /**
-     * Loads and validates a module.json file.
-     */
-    static async loadManifest(manifestPath) {
-        if (!await fs_extra_1.default.pathExists(manifestPath)) {
-            throw new errors_1.ModuleError(`Manifest not found at ${manifestPath}`);
-        }
-        try {
-            const content = await fs_extra_1.default.readJson(manifestPath);
-            return module_1.ModuleManifestSchema.parse(content);
-        }
-        catch (error) {
-            if (error instanceof zod_1.z.ZodError) {
-                throw new errors_1.ModuleError(`Invalid manifest at ${manifestPath}: ${error.issues.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ')}`);
-            }
-            throw new errors_1.ModuleError(`Failed to read manifest: ${error}`);
-        }
-    }
-    /**
-     * Scans a directory for available modules (modules that have module.json).
-     * @param sourcePath Directory containing module folders
-     */
-    static async listAvailableModules(sourcePath) {
-        if (!await fs_extra_1.default.pathExists(sourcePath)) {
-            return [];
-        }
-        const entries = await fs_extra_1.default.readdir(sourcePath, { withFileTypes: true });
-        const modules = [];
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const manifestPath = path_1.default.join(sourcePath, entry.name, 'module.json');
-                if (await fs_extra_1.default.pathExists(manifestPath)) {
-                    try {
-                        const manifest = await this.loadManifest(manifestPath);
-                        modules.push(manifest);
-                    }
-                    catch (error) {
-                        logger_1.Logger.warn(`Skipping invalid module in ${entry.name}: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-            }
-        }
-        return modules;
-    }
-}
-exports.ModuleManager = ModuleManager;

package/dist/core/modules/ModuleRemover.js

@@ -1,60 +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.ModuleRemover = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const Injector_1 = require("./Injector");
-const config_1 = require("../../lib/config");
-const logger_1 = require("../../lib/logger");
-const errors_1 = require("../../lib/errors");
-class ModuleRemover {
-    static async remove(manifest, projectRoot) {
-        logger_1.Logger.startSpinner(`Removing module: ${manifest.displayName}...`);
-        try {
-            // 1. Eject Code
-            // We process injections in reverse order to minimize drift issues (LIFO)?
-            // Actually order shouldn't matter if logic is precise, but reverse is safer for nested injections.
-            const injections = [...manifest.injections].reverse();
-            for (const injection of injections) {
-                const targetPath = path_1.default.join(projectRoot, injection.targetFile);
-                await Injector_1.Injector.eject(targetPath, injection.content);
-            }
-            // 2. Remove Files
-            // 2a. API
-            const apiDest = path_1.default.join(projectRoot, 'apps/api/src/modules', manifest.slug);
-            if (await fs_extra_1.default.pathExists(apiDest)) {
-                await fs_extra_1.default.remove(apiDest);
-            }
-            // 2b. Admin
-            const adminDest = path_1.default.join(projectRoot, 'apps/admin/app/[locale]/(dashboard)', manifest.slug);
-            if (await fs_extra_1.default.pathExists(adminDest)) {
-                await fs_extra_1.default.remove(adminDest);
-            }
-            // 3. Update Config
-            if (await config_1.ConfigManager.exists(projectRoot)) {
-                const config = await config_1.ConfigManager.load(projectRoot);
-                // Remove from optional modules
-                if (config.kaven.modules.optional && config.kaven.modules.optional[manifest.slug]) {
-                    config.kaven.modules.optional[manifest.slug] = false;
-                }
-                // Add to removedModules
-                if (!config.kaven.customizations.removedModules.includes(manifest.slug)) {
-                    config.kaven.customizations.removedModules.push(manifest.slug);
-                }
-                // Remove from addedModules
-                config.kaven.customizations.addedModules = config.kaven.customizations.addedModules.filter(m => m !== manifest.slug);
-                await config_1.ConfigManager.save(projectRoot, config);
-            }
-            logger_1.Logger.succeedSpinner(`Module ${manifest.displayName} removed successfully.`);
-        }
-        catch (error) {
-            logger_1.Logger.stopSpinner();
-            logger_1.Logger.error(`Failed to remove module ${manifest.slug}`, error);
-            throw new errors_1.ModuleError(`Removal failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-exports.ModuleRemover = ModuleRemover;

package/dist/lib/config.js

@@ -1,66 +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.KavenConfigSchema = void 0;
-const zod_1 = require("zod");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const errors_1 = require("./errors");
-exports.KavenConfigSchema = zod_1.z.object({
-    name: zod_1.z.string(),
-    version: zod_1.z.string(),
-    kaven: zod_1.z.object({
-        version: zod_1.z.string(),
-        features: zod_1.z.object({
-            multiTenant: zod_1.z.boolean().default(true),
-            database: zod_1.z.enum(['postgresql', 'mysql']).default('postgresql'),
-            payment: zod_1.z.enum(['stripe', 'paddle', 'pix', 'none']).default('none').optional(),
-        }),
-        modules: zod_1.z.object({
-            core: zod_1.z.record(zod_1.z.boolean()).default({}),
-            optional: zod_1.z.record(zod_1.z.boolean()).default({}),
-        }),
-        customizations: zod_1.z.object({
-            addedModules: zod_1.z.array(zod_1.z.string()).default([]),
-            removedModules: zod_1.z.array(zod_1.z.string()).default([]),
-        }).default({
-            addedModules: [],
-            removedModules: [],
-        }),
-    }),
-});
-const CONFIG_FILENAME = 'kaven.config.json';
-class ConfigManager {
-    static async load(projectRoot) {
-        const configPath = path_1.default.join(projectRoot, CONFIG_FILENAME);
-        if (!await fs_extra_1.default.pathExists(configPath)) {
-            throw new errors_1.ConfigError(`Configuration file not found at ${configPath}`);
-        }
-        try {
-            const content = await fs_extra_1.default.readJson(configPath);
-            return exports.KavenConfigSchema.parse(content);
-        }
-        catch (error) {
-            if (error instanceof zod_1.z.ZodError) {
-                throw new errors_1.ConfigError(`Invalid configuration: ${error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`);
-            }
-            throw new errors_1.ConfigError(`Failed to read configuration: ${error}`);
-        }
-    }
-    static async save(projectRoot, config) {
-        const configPath = path_1.default.join(projectRoot, CONFIG_FILENAME);
-        try {
-            const validated = exports.KavenConfigSchema.parse(config);
-            await fs_extra_1.default.writeJson(configPath, validated, { spaces: 2 });
-        }
-        catch (error) {
-            throw new errors_1.ConfigError(`Failed to save configuration: ${error}`);
-        }
-    }
-    static async exists(projectRoot) {
-        return fs_extra_1.default.pathExists(path_1.default.join(projectRoot, CONFIG_FILENAME));
-    }
-}
-exports.ConfigManager = ConfigManager;

package/dist/lib/errors.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthError = exports.ModuleError = exports.ConfigError = exports.KavenError = void 0;
-class KavenError extends Error {
-    constructor(message, code = 'KAVEN_ERROR') {
-        super(message);
-        this.code = code;
-        this.name = 'KavenError';
-    }
-}
-exports.KavenError = KavenError;
-class ConfigError extends KavenError {
-    constructor(message) {
-        super(message, 'CONFIG_ERROR');
-        this.name = 'ConfigError';
-    }
-}
-exports.ConfigError = ConfigError;
-class ModuleError extends KavenError {
-    constructor(message) {
-        super(message, 'MODULE_ERROR');
-        this.name = 'ModuleError';
-    }
-}
-exports.ModuleError = ModuleError;
-class AuthError extends KavenError {
-    constructor(message) {
-        super(message, 'AUTH_ERROR');
-        this.name = 'AuthError';
-    }
-}
-exports.AuthError = AuthError;

package/dist/lib/logger.js

@@ -1,70 +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.Logger = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-class Logger {
-    static info(message) {
-        console.log(chalk_1.default.blue('ℹ'), message);
-    }
-    static succeedSpinner(message) {
-        this.success(message);
-    }
-    static success(message) {
-        if (this.spinner) {
-            this.spinner.succeed(chalk_1.default.green(message));
-            this.spinner = null;
-        }
-        else {
-            console.log(chalk_1.default.green('✔'), message);
-        }
-    }
-    static warn(message) {
-        console.log(chalk_1.default.yellow('⚠'), message);
-    }
-    static error(message, error) {
-        if (this.spinner) {
-            this.spinner.fail(chalk_1.default.red(message));
-            this.spinner = null;
-        }
-        else {
-            console.error(chalk_1.default.red('✖'), message);
-        }
-        if (error instanceof Error) {
-            console.error(chalk_1.default.dim(error.stack));
-        }
-        else if (error) {
-            console.error(chalk_1.default.dim(JSON.stringify(error)));
-        }
-    }
-    static startSpinner(text) {
-        if (this.spinner) {
-            this.spinner.text = text;
-        }
-        else {
-            this.spinner = (0, ora_1.default)(text).start();
-        }
-    }
-    static stopSpinner() {
-        if (this.spinner) {
-            this.spinner.stop();
-            this.spinner = null;
-        }
-    }
-    static box(title, lines) {
-        const width = Math.max(title.length + 4, ...lines.map(l => l.length + 4));
-        const border = '─'.repeat(width);
-        console.log(chalk_1.default.cyan(`┌${border}┐`));
-        console.log(chalk_1.default.cyan(`│ ${chalk_1.default.bold(title.padEnd(width - 2))} │`));
-        console.log(chalk_1.default.cyan(`│${border}│`));
-        lines.forEach(line => {
-            console.log(chalk_1.default.cyan(`│ ${line.padEnd(width - 2)} │`));
-        });
-        console.log(chalk_1.default.cyan(`└${border}┘`));
-    }
-}
-exports.Logger = Logger;
-Logger.spinner = null;

package/dist/types/module.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleManifestSchema = exports.InjectionSchema = void 0;
-const zod_1 = require("zod");
-exports.InjectionSchema = zod_1.z.object({
-    targetFile: zod_1.z.string(), // relative to project root
-    anchor: zod_1.z.string(), // e.g. "KAVEN_MODULE_IMPORTS"
-    content: zod_1.z.string(), // content to inject
-    strategy: zod_1.z.enum(['append', 'prepend', 'replace']).default('append'),
-});
-exports.ModuleManifestSchema = zod_1.z.object({
-    id: zod_1.z.string().uuid().optional(), // optional for local dev
-    slug: zod_1.z.string().min(3).regex(/^[a-z0-9-]+$/),
-    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+.*$/), // SemVer
-    displayName: zod_1.z.string(),
-    description: zod_1.z.string(),
-    category: zod_1.z.string().default('features'),
-    publisher: zod_1.z.string().default('kaven'),
-    // Compatibility
-    compat: zod_1.z.object({
-        kaven: zod_1.z.string(), // SemVer range e.g. "^2.0.0"
-        node: zod_1.z.string().optional(),
-    }),
-    // Dependencies
-    dependencies: zod_1.z.record(zod_1.z.string()).optional(), // npm deps
-    devDependencies: zod_1.z.record(zod_1.z.string()).optional(),
-    peerModules: zod_1.z.record(zod_1.z.string()).optional(), // other kaven modules
-    // Configuration Requirements (Env Vars)
-    env: zod_1.z.array(zod_1.z.object({
-        key: zod_1.z.string(),
-        description: zod_1.z.string(),
-        required: zod_1.z.boolean().default(true),
-        defaultValue: zod_1.z.string().optional(),
-    })).default([]),
-    // File Copying mappings (TO-BE: flexible mappings)
-    // For AS-IS compatibility, we assume standard structure (api/admin)
-    // Injections
-    injections: zod_1.z.array(exports.InjectionSchema).default([]),
-    // Database
-    database: zod_1.z.object({
-        schemaPath: zod_1.z.string().optional(), // path to schema.prisma fragment
-        migrations: zod_1.z.boolean().default(false),
-    }).optional(),
-    // Tasks (hooks)
-    hooks: zod_1.z.object({
-        postInstall: zod_1.z.array(zod_1.z.string()).default([]),
-        preRemove: zod_1.z.array(zod_1.z.string()).default([]),
-    }).optional(),
-});