kaven-cli 0.1.0-alpha.1

package/dist/commands/module/remove.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleRemove = moduleRemove;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const ModuleInstaller_1 = require("../../core/ModuleInstaller");
+const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
+const MarkerService_1 = require("../../core/MarkerService");
+async function moduleRemove(moduleName, projectRoot) {
+    const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
+    const startTime = Date.now();
+    telemetry.capture("cli.module.remove.start", { moduleName });
+    const root = projectRoot || process.cwd();
+    const spinner = (0, ora_1.default)(`Removendo módulo ${moduleName}...`).start();
+    try {
+        const markerService = new MarkerService_1.MarkerService();
+        const installer = new ModuleInstaller_1.ModuleInstaller(root, markerService);
+        // 1. Verificar se o módulo está na config
+        const configPath = path_1.default.join(root, "kaven.json");
+        if (!(await fs_extra_1.default.pathExists(configPath))) {
+            throw new Error("Arquivo kaven.json não encontrado. Este é um projeto Kaven?");
+        }
+        const config = await fs_extra_1.default.readJson(configPath);
+        if (!config.modules || !config.modules[moduleName]) {
+            throw new Error(`O módulo ${moduleName} não está instalado.`);
+        }
+        // 2. Carregar manifest do cache
+        const manifestPath = path_1.default.join(root, ".kaven", "modules", moduleName, "module.json");
+        if (!(await fs_extra_1.default.pathExists(manifestPath))) {
+            throw new Error(`Cache do manifest para ${moduleName} não encontrado em ${manifestPath}. A remoção precisa do manifest original.`);
+        }
+        const manifest = await fs_extra_1.default.readJson(manifestPath);
+        // 3. Desinstalar
+        spinner.text = `Removendo injeções de ${moduleName}...`;
+        await installer.uninstall(manifest);
+        // 4. Atualizar config
+        spinner.text = "Atualizando configuração do projeto...";
+        delete config.modules[moduleName];
+        await fs_extra_1.default.writeJson(configPath, config, { spaces: 2 });
+        // 5. Limpar cache do manifest
+        await fs_extra_1.default.remove(path_1.default.dirname(manifestPath));
+        (0, ora_1.default)().succeed(chalk_1.default.green(`Módulo ${moduleName} removido com sucesso!`));
+        telemetry.capture("cli.module.remove.success", { moduleName }, Date.now() - startTime);
+        await telemetry.flush();
+    }
+    catch (error) {
+        telemetry.capture("cli.module.remove.error", { error: error.message }, Date.now() - startTime);
+        await telemetry.flush();
+        (0, ora_1.default)().fail(chalk_1.default.red(`Falha ao remover módulo ${moduleName}:`));
+        spinner.fail(chalk_1.default.red(`${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
+}

package/dist/commands/modules/add.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const ModuleManager_1 = require("../../core/modules/ModuleManager");
+const ModuleInstaller_1 = require("../../core/modules/ModuleInstaller");
+const logger_1 = require("../../lib/logger");
+exports.addCommand = new commander_1.Command('add')
+    .description('Install a module')
+    .argument('<slug>', 'Module slug to install')
+    .action(async (slug) => {
+    try {
+        const projectRoot = process.cwd();
+        // Locate modules source: 
+        // In dev: ./modules
+        // In prod (installed): ../modules relative to dist
+        // For now, assume we run from CLI root or use logic to find 'modules' folder.
+        // Ideally CLI should be installed in a way that 'modules' folder is known.
+        // Fallback logic for finding modules source:
+        // 1. Env var KAVEN_MODULES_PATH
+        // 2. Local ./modules
+        // 3. Resolve relative to __dirname (dist) -> ../modules
+        let modulesSource = process.env.KAVEN_MODULES_PATH;
+        if (!modulesSource) {
+            if (await fs_extra_1.default.pathExists(path_1.default.resolve('modules'))) {
+                modulesSource = path_1.default.resolve('modules');
+            }
+            else {
+                modulesSource = path_1.default.resolve(__dirname, '../../modules');
+            }
+        }
+        if (!await fs_extra_1.default.pathExists(modulesSource)) {
+            logger_1.Logger.error(`Module source not found at ${modulesSource}`);
+            return;
+        }
+        const manifestPath = path_1.default.join(modulesSource, slug, 'module.json');
+        if (!await fs_extra_1.default.pathExists(manifestPath)) {
+            logger_1.Logger.error(`Module ${slug} not found in catalog.`);
+            return;
+        }
+        const manifest = await ModuleManager_1.ModuleManager.loadManifest(manifestPath);
+        await ModuleInstaller_1.ModuleInstaller.install(manifest, projectRoot, modulesSource);
+    }
+    catch (error) {
+        logger_1.Logger.error('Failed to add module', error);
+        process.exit(1);
+    }
+});

package/dist/commands/modules/list.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const ModuleManager_1 = require("../../core/modules/ModuleManager");
+const logger_1 = require("../../lib/logger");
+const chalk_1 = __importDefault(require("chalk"));
+exports.listCommand = new commander_1.Command('list')
+    .description('List available modules')
+    .action(async () => {
+    try {
+        logger_1.Logger.startSpinner('Loading modules...');
+        // By default, Kaven CLI looks for modules in the current project's ./kaven-cli/modules
+        // OR internal modules directory. For dev/bootstrap, we use the local 'modules' dir relative to CWD or __dirname.
+        // Strategy: 
+        // 1. Check local repo structure (dev mode): ./modules
+        // 2. Check installed structure (production): ../modules
+        const modulesPath = path_1.default.resolve('modules');
+        const modules = await ModuleManager_1.ModuleManager.listAvailableModules(modulesPath);
+        logger_1.Logger.stopSpinner();
+        if (modules.length === 0) {
+            logger_1.Logger.warn('No modules found in ' + modulesPath);
+            return;
+        }
+        logger_1.Logger.info(`Found ${modules.length} modules:`);
+        modules.forEach(mod => {
+            console.log('');
+            console.log(chalk_1.default.bold.cyan(mod.displayName) + ' ' + chalk_1.default.dim(`(${mod.slug})`));
+            console.log(chalk_1.default.white(mod.description));
+            console.log(chalk_1.default.dim(`Version: ${mod.version}`));
+        });
+    }
+    catch (error) {
+        logger_1.Logger.error('Failed to list modules', error);
+    }
+});

package/dist/commands/modules/remove.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeCommand = void 0;
+const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const ModuleManager_1 = require("../../core/modules/ModuleManager");
+const ModuleRemover_1 = require("../../core/modules/ModuleRemover");
+const logger_1 = require("../../lib/logger");
+exports.removeCommand = new commander_1.Command('remove')
+    .description('Remove a module')
+    .argument('<slug>', 'Module slug to remove')
+    .action(async (slug) => {
+    try {
+        const projectRoot = process.cwd();
+        // For removal, we need the manifest to know what to eject.
+        // We look for the installed module first?
+        // Doc 3: "The engine behaves as if it’s 'playing back' the manifest in reverse."
+        // We need the manifest. Where do we get it?
+        // Option A: From the installed module directory (if we copied the manifest there).
+        // Option B: From the store (but what if version changed?).
+        // Best practice: We should have copied module.json to the installed location.
+        // Current Installer (Phase 2) does NOT copy module.json to installed location explicitly (it copies `api` folder content).
+        // Let's check `ModuleInstaller.ts`:
+        // if (manifest.slug) -> copy `api` to `modules/slug`.
+        // Does `api` contain `module.json`? No, `module.json` is at root of module source.
+        // FIX REQUIRED: We should probably look up the manifest from the *store* (catalog) matching the installed version,
+        // OR we should store the manifest upon installation.
+        // For MVP (Phase 3), let's assume we can find the manifest in the same Store logic as `add`.
+        let modulesSource = process.env.KAVEN_MODULES_PATH;
+        if (!modulesSource) {
+            if (await fs_extra_1.default.pathExists(path_1.default.resolve('modules'))) {
+                modulesSource = path_1.default.resolve('modules');
+            }
+            else {
+                modulesSource = path_1.default.resolve(__dirname, '../../modules');
+            }
+        }
+        const manifestPath = path_1.default.join(modulesSource, slug, 'module.json');
+        if (!await fs_extra_1.default.pathExists(manifestPath)) {
+            logger_1.Logger.error(`Module manifest not found in store for ${slug}. Cannot safely remove.`);
+            return;
+        }
+        const manifest = await ModuleManager_1.ModuleManager.loadManifest(manifestPath);
+        await ModuleRemover_1.ModuleRemover.remove(manifest, projectRoot);
+    }
+    catch (error) {
+        logger_1.Logger.error('Failed to remove module', error);
+        process.exit(1);
+    }
+});

package/dist/commands/telemetry/view.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetryView = telemetryView;
+const chalk_1 = __importDefault(require("chalk"));
+const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
+async function telemetryView(limit = 10) {
+    const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
+    const events = await telemetry.getRecentEvents(limit);
+    if (events.length === 0) {
+        console.log(chalk_1.default.yellow("\nNenhum evento de telemetria encontrado localmente.\n"));
+        return;
+    }
+    console.log(chalk_1.default.blue.bold(`\n📊 Últimos ${events.length} eventos de telemetria:\n`));
+    events.forEach((e) => {
+        const time = chalk_1.default.gray(`[${new Date(e.timestamp).toLocaleTimeString()}]`);
+        const status = e.event.includes("error") ? chalk_1.default.red("✖") : chalk_1.default.green("✔");
+        const duration = e.duration ? chalk_1.default.yellow(` (${e.duration}ms)`) : "";
+        console.log(`${time} ${status} ${chalk_1.default.cyan(e.event)}${duration}`);
+        if (e.metadata && Object.keys(e.metadata).length > 0) {
+            console.log(chalk_1.default.gray(`   > ${JSON.stringify(e.metadata)}`));
+        }
+    });
+    console.log(chalk_1.default.gray("\nLog local: ~/.kaven/telemetry.log\n"));
+}

package/dist/core/AuthService.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+class AuthService {
+    constructor() {
+        this.configPath = path_1.default.join(os_1.default.homedir(), ".kaven", "auth.json");
+    }
+    async storeToken(token) {
+        const configDir = path_1.default.dirname(this.configPath);
+        await fs_extra_1.default.ensureDir(configDir);
+        // Salvar token em JSON
+        await fs_extra_1.default.writeJson(this.configPath, { token }, { spaces: 2 });
+        // Definir permissões restritas (0600 - leitura/escrita apenas pelo dono) no Linux
+        if (process.platform !== "win32") {
+            await fs_extra_1.default.chmod(this.configPath, 0o600);
+        }
+    }
+    async getToken() {
+        if (!(await fs_extra_1.default.pathExists(this.configPath))) {
+            return null;
+        }
+        try {
+            const data = await fs_extra_1.default.readJson(this.configPath);
+            return data.token || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async clearToken() {
+        if (await fs_extra_1.default.pathExists(this.configPath)) {
+            await fs_extra_1.default.remove(this.configPath);
+        }
+    }
+    async isAuthenticated() {
+        const token = await this.getToken();
+        return !!token;
+    }
+    /**
+     * Mock decoding of JWT for now.
+     * In a real implementation, we would use a library like 'jsonwebtoken'.
+     */
+    async getUserInfo() {
+        const token = await this.getToken();
+        if (!token)
+            return null;
+        // Simulate decoding (mocked)
+        return {
+            id: "usr-mock-123",
+            email: "user@example.com",
+            name: "Kaven Explorador",
+        };
+    }
+}
+exports.AuthService = AuthService;

package/dist/core/ManifestParser.js

@@ -0,0 +1,52 @@
+"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

@@ -0,0 +1,62 @@
+"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

@@ -0,0 +1,162 @@
+"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"));
+class ModuleDoctor {
+    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()));
+        return results;
+    }
+    async checkAnchors() {
+        const results = [];
+        const expectedAnchors = [
+            { file: "apps/api/src/index.ts", anchor: "// [ANCHOR:ROUTES]" },
+            { file: "apps/api/src/index.ts", anchor: "// [ANCHOR:MIDDLEWARE]" },
+            { file: "apps/admin/app/layout.tsx", anchor: "// [ANCHOR:NAV_ITEMS]" },
+        ];
+        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;
+    }
+    async readKavenConfig() {
+        const configPath = path_1.default.join(this.projectRoot, "kaven.config.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

@@ -0,0 +1,66 @@
+"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 fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+class ModuleInstaller {
+    constructor(projectRoot, markerService) {
+        this.projectRoot = projectRoot;
+        this.markerService = markerService;
+    }
+    async install(manifest) {
+        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();
+        }
+        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) {
+        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);
+            // 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);
+    }
+}
+exports.ModuleInstaller = ModuleInstaller;