kaven-cli 0.1.0-alpha.1

package/dist/infrastructure/TelemetryBuffer.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryBuffer = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+class TelemetryBuffer {
+    constructor() {
+        this.buffer = [];
+        this.logPath = path_1.default.join(os_1.default.homedir(), ".kaven", "telemetry.log");
+    }
+    static getInstance() {
+        if (!TelemetryBuffer.instance) {
+            TelemetryBuffer.instance = new TelemetryBuffer();
+        }
+        return TelemetryBuffer.instance;
+    }
+    /**
+     * Captura um evento de telemetria
+     */
+    capture(event, metadata, duration) {
+        const telemetryEvent = {
+            event,
+            timestamp: new Date().toISOString(),
+            metadata,
+            duration,
+        };
+        this.buffer.push(telemetryEvent);
+    }
+    /**
+     * Persiste os eventos do buffer no arquivo local
+     */
+    async flush() {
+        if (this.buffer.length === 0)
+            return;
+        try {
+            const logDir = path_1.default.dirname(this.logPath);
+            await fs_extra_1.default.ensureDir(logDir);
+            const lines = this.buffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+            await fs_extra_1.default.appendFile(this.logPath, lines, "utf8");
+            this.buffer = [];
+        }
+        catch (error) {
+            // Falha silenciosa na telemetria para não interromper fluxo principal
+            console.debug("Erro ao gravar telemetria:", error);
+        }
+    }
+    /**
+     * Recupera os últimos eventos registrados
+     */
+    async getRecentEvents(limit = 20) {
+        if (!(await fs_extra_1.default.pathExists(this.logPath)))
+            return [];
+        try {
+            const content = await fs_extra_1.default.readFile(this.logPath, "utf8");
+            return content
+                .trim()
+                .split("\n")
+                .reverse()
+                .slice(0, limit)
+                .map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.TelemetryBuffer = TelemetryBuffer;

package/dist/infrastructure/TransactionalFileSystem.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionalFileSystem = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+class TransactionalFileSystem {
+    constructor(projectRoot, backupDir = ".agent/backups") {
+        this.projectRoot = projectRoot;
+        this.filesToBackup = [];
+        this.backupDir = path_1.default.join(projectRoot, backupDir);
+        this.backupId = `backup_${Date.now()}`;
+    }
+    async backup(filePaths) {
+        const backupPath = path_1.default.join(this.backupDir, this.backupId);
+        await fs_extra_1.default.ensureDir(backupPath);
+        for (const file of filePaths) {
+            const absolutePath = path_1.default.resolve(this.projectRoot, file);
+            if (!(await fs_extra_1.default.pathExists(absolutePath))) {
+                throw new Error(`File not found for backup: ${file}`);
+            }
+            const relativePath = path_1.default.relative(this.projectRoot, absolutePath);
+            const backupFile = path_1.default.join(backupPath, relativePath);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(backupFile));
+            await fs_extra_1.default.copy(absolutePath, backupFile);
+            this.filesToBackup.push(absolutePath);
+        }
+        console.log(`📦 Backup created: ${this.backupId}`);
+    }
+    async rollback() {
+        const backupPath = path_1.default.join(this.backupDir, this.backupId);
+        if (!(await fs_extra_1.default.pathExists(backupPath))) {
+            throw new Error(`Backup not found: ${this.backupId}`);
+        }
+        const files = await (0, glob_1.glob)(`${backupPath}/**/*`, { nodir: true });
+        for (const backupFile of files) {
+            const relativePath = path_1.default.relative(backupPath, backupFile);
+            const targetFile = path_1.default.join(this.projectRoot, relativePath);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(targetFile));
+            await fs_extra_1.default.copy(backupFile, targetFile, { overwrite: true });
+        }
+        console.log(`♻️  Rollback complete: ${this.backupId}`);
+    }
+    async commit() {
+        const backupPath = path_1.default.join(this.backupDir, this.backupId);
+        if (await fs_extra_1.default.pathExists(backupPath)) {
+            await fs_extra_1.default.remove(backupPath);
+        }
+        console.log(`✅ Transaction committed`);
+    }
+    getBackupId() {
+        return this.backupId;
+    }
+    async cleanup() {
+        if (!(await fs_extra_1.default.pathExists(this.backupDir)))
+            return;
+        const backups = await fs_extra_1.default.readdir(this.backupDir);
+        const now = Date.now();
+        const weekInMs = 7 * 24 * 60 * 60 * 1000;
+        for (const backup of backups) {
+            const match = backup.match(/backup_(\d+)/);
+            if (match) {
+                const timestamp = parseInt(match[1]);
+                if (now - timestamp > weekInMs) {
+                    await fs_extra_1.default.remove(path_1.default.join(this.backupDir, backup));
+                }
+            }
+        }
+    }
+}
+exports.TransactionalFileSystem = TransactionalFileSystem;

package/dist/infrastructure/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/lib/config.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.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

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

@@ -0,0 +1,70 @@
+"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/manifest.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleManifestSchema = void 0;
+const zod_1 = require("zod");
+const DependencySchema = zod_1.z.object({
+    npm: zod_1.z.array(zod_1.z.string()).default([]),
+    peerModules: zod_1.z.array(zod_1.z.string()).default([]),
+    kavenVersion: zod_1.z.string().default(">=0.1.0"),
+});
+const FileSetSchema = zod_1.z.object({
+    source: zod_1.z.string(),
+    dest: zod_1.z.string(),
+});
+const FilesSchema = zod_1.z.object({
+    backend: zod_1.z.array(FileSetSchema).default([]),
+    frontend: zod_1.z.array(FileSetSchema).default([]),
+    database: zod_1.z.array(FileSetSchema).default([]),
+});
+const InjectionSchema = zod_1.z.object({
+    file: zod_1.z.string(),
+    anchor: zod_1.z.string(),
+    code: zod_1.z.string(),
+    moduleName: zod_1.z.string().optional(),
+});
+const ScriptsSchema = zod_1.z.object({
+    postInstall: zod_1.z.string().nullable().default(null),
+    preRemove: zod_1.z.string().nullable().default(null),
+});
+const EnvVarSchema = zod_1.z.object({
+    key: zod_1.z.string(),
+    required: zod_1.z.boolean().default(false),
+    example: zod_1.z.string().optional(),
+});
+exports.ModuleManifestSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: zod_1.z.string().optional(),
+    author: zod_1.z.string().default("Kaven"),
+    license: zod_1.z.string().default("Proprietary"),
+    dependencies: DependencySchema,
+    files: FilesSchema,
+    injections: zod_1.z.array(InjectionSchema),
+    scripts: ScriptsSchema,
+    env: zod_1.z.array(EnvVarSchema).default([]),
+});

package/dist/types/markers.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMarker = createMarker;
+function createMarker(moduleName) {
+    return {
+        moduleName,
+        beginMarker: `// [KAVEN_MODULE:${moduleName} BEGIN]`,
+        endMarker: `// [KAVEN_MODULE:${moduleName} END]`,
+    };
+}

package/dist/types/module.js

@@ -0,0 +1,49 @@
+"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(),
+});

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "kaven-cli",
+  "version": "0.1.0-alpha.1",
+  "description": "Kaven CLI - The official command line tool for Kaven",
+  "main": "dist/index.js",
+  "bin": {
+    "kaven": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "pnpm run build && pnpm run quality",
+    "lint": "eslint 'src/**/*.{ts,tsx}' --max-warnings 0",
+    "lint:fix": "eslint 'src/**/*.{ts,tsx}' --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "quality": "pnpm run lint && pnpm run typecheck && pnpm run test",
+    "quality:gate": "./.agent/scripts/quality-gate.sh",
+    "bootstrap": "./.agent/scripts/bootstrap.sh",
+    "evidence": "./.agent/scripts/evidence-bundle.sh",
+    "validate:evidence": "./.agent/scripts/validate-evidence.sh",
+    "create:pr": "./.agent/scripts/create-pr.sh",
+    "telemetry:view": "tail -f ~/.kaven/telemetry.log",
+    "telemetry:clear": "rm -f ~/.kaven/telemetry.log && touch ~/.kaven/telemetry.log"
+  },
+  "keywords": [
+    "kaven",
+    "cli",
+    "developer-tools",
+    "saas",
+    "boilerplate"
+  ],
+  "author": "Kaven",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KavenCompany/kaven-cli"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "fs-extra": "^11.3.3",
+    "glob": "^13.0.0",
+    "ora": "^9.1.0",
+    "zod": "^4.3.6"
+  }
+}