@aetherionfw/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cristian Londoño
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin/aetherion.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/aetherion.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const init_1 = require("../commands/init");
+const synth_1 = require("../commands/synth");
+const deploy_1 = require("../commands/deploy");
+const docs_1 = require("../commands/docs");
+const program = new commander_1.Command();
+program
+    .name('aetherion')
+    .description(chalk_1.default.blue('Aetherion Serverless Framework CLI'))
+    .version('1.0.0');
+program
+    .command('init <project-name>')
+    .description('Initialize a new Aetherion project')
+    .action(init_1.initCommand);
+program
+    .command('synth')
+    .description('Synthesize the infrastructure to CDKTF JSON')
+    .action(synth_1.synthCommand);
+program
+    .command('deploy')
+    .description('Deploy the infrastructure to AWS')
+    .action(deploy_1.deployCommand);
+program
+    .command('docs')
+    .description('Generate OpenAPI documentation')
+    .option('-s, --serve', 'Serve the documentation using Scalar UI locally')
+    .action(docs_1.docsCommand);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1 @@
+export declare function deployCommand(): Promise<void>;

package/dist/commands/deploy.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = deployCommand;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+async function deployCommand() {
+    const spinner = (0, ora_1.default)('Deploying infrastructure to AWS...').start();
+    try {
+        // Using inherit to show CDKTF output directly to the user
+        spinner.stop();
+        console.log(chalk_1.default.blue('Running cdktf deploy...'));
+        (0, child_process_1.execSync)('cdktf deploy --auto-approve', { stdio: 'inherit' });
+        console.log(chalk_1.default.green('\nDeploy completed successfully.'));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red('\nDeploy failed.'));
+        process.exit(1);
+    }
+}

package/dist/commands/docs.d.ts

@@ -0,0 +1 @@
+export declare function docsCommand(options: any): Promise<void>;

package/dist/commands/docs.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.docsCommand = docsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+// Assuming the CLI runs in an environment where @aetherionfw/docs is accessible
+// For a global CLI, we might need to dynamically import it from the user's workspace
+const docs_1 = require("@aetherionfw/docs");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+async function docsCommand(options) {
+    const isServe = options.serve;
+    const spinner = (0, ora_1.default)('Preparing OpenAPI documentation...').start();
+    try {
+        // Dynamically register ts-node to load TS files from the user project
+        require('ts-node').register({
+            transpileOnly: true,
+            compilerOptions: { module: 'commonjs' }
+        });
+        // Load the root app.module from the user's project
+        const appModulePath = path.resolve(process.cwd(), 'src/app.module.ts');
+        if (fs.existsSync(appModulePath)) {
+            require(appModulePath);
+        }
+        else {
+            spinner.warn(chalk_1.default.yellow('src/app.module.ts not found. API documentation might be empty.'));
+        }
+        if (isServe) {
+            spinner.succeed(chalk_1.default.green('Starting Scalar API Reference Server...'));
+            (0, docs_1.startScalarServer)(3000);
+            // Keep process alive
+        }
+        else {
+            (0, docs_1.generateStaticDocs)(process.cwd());
+            spinner.succeed(chalk_1.default.green('Documentation generated at openapi.json'));
+        }
+    }
+    catch (err) {
+        spinner.fail(chalk_1.default.red('Failed to process documentation.'));
+        console.error(err.message);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(projectName: string): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+async function initCommand(projectName) {
+    const spinner = (0, ora_1.default)(`Initializing project ${chalk_1.default.cyan(projectName)}...`).start();
+    try {
+        const projectPath = path.resolve(process.cwd(), projectName);
+        if (fs.existsSync(projectPath)) {
+            spinner.fail(`Directory ${chalk_1.default.red(projectName)} already exists.`);
+            return;
+        }
+        // 1. Copy the entire template directory
+        // Assuming this file runs from `dist/commands/init.js`, the template is at `../../template`
+        // Depending on the build setup, we might need to adjust this path.
+        const templatePath = path.resolve(__dirname, '../../template');
+        if (!fs.existsSync(templatePath)) {
+            spinner.fail(`Template directory not found at ${templatePath}`);
+            return;
+        }
+        await fs.copy(templatePath, projectPath);
+        // 2. Generate package.json dynamically
+        const packageJson = {
+            name: projectName,
+            version: "1.0.0",
+            scripts: {
+                "build": "tsc",
+                "synth": "aetherion synth",
+                "deploy": "aetherion deploy",
+                "docs": "aetherion docs",
+                "test": "vitest run"
+            },
+            dependencies: {
+                "@aetherionfw/core": "latest",
+                "@aetherionfw/infra": "latest",
+                "@aetherionfw/docs": "latest"
+            },
+            devDependencies: {
+                "typescript": "^5.5.4",
+                "vitest": "^2.0.5"
+            }
+        };
+        await fs.writeJson(path.join(projectPath, 'package.json'), packageJson, { spaces: 2 });
+        spinner.succeed(`Project ${chalk_1.default.green(projectName)} created successfully.`);
+        console.log(chalk_1.default.blue(`\nNext steps:`));
+        console.log(`  $ cd ${projectName}`);
+        console.log(`  $ pnpm install`);
+        console.log(`  $ pnpm test`);
+        console.log(`  $ aetherion synth`);
+    }
+    catch (err) {
+        spinner.fail(`Failed to create project: ${err.message}`);
+    }
+}

package/dist/commands/synth.d.ts

@@ -0,0 +1 @@
+export declare function synthCommand(): Promise<void>;

package/dist/commands/synth.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthCommand = synthCommand;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+async function synthCommand() {
+    const spinner = (0, ora_1.default)('Synthesizing CDKTF infrastructure...').start();
+    try {
+        // In a real scenario, this would dynamically resolve the infra entrypoint.
+        // Assuming the user runs this in their project root and there's a cdktf project.
+        (0, child_process_1.execSync)('cdktf synth', { stdio: 'pipe' });
+        spinner.succeed(chalk_1.default.green('Infrastructure synthesized successfully.'));
+    }
+    catch (err) {
+        spinner.fail(chalk_1.default.red('Synthesis failed.'));
+        console.error(err.message);
+    }
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@aetherionfw/cli",
+  "version": "1.0.0",
+  "description": "CLI for Aetherion Framework",
+  "bin": {
+    "aetherion": "dist/bin/aetherion.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "fs-extra": "^11.1.1",
+    "ora": "^5.4.1",
+    "ts-node": "^10.9.2",
+    "@aetherionfw/docs": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.1",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5",
+    "@aetherionfw/core": "1.0.0",
+    "@aetherionfw/infra": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "template",
+    "package.json",
+    "README.md"
+  ],
+  "author": "CrisD3v",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  }
+}

package/template/infra/main.ts

@@ -0,0 +1,10 @@
+// Import the modules to register them in the MetadataRegistry
+import '../src/app.module';
+
+import { App } from 'cdktf';
+import { FrameworkStack } from '@aetherionfw/infra';
+
+const app = new App();
+// This automatically synthesizes all Lambdas, API Gateways, etc.
+new FrameworkStack(app, 'initial-dev');
+app.synth();

package/template/src/app.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@aetherionfw/core';
+import { InitialModule } from './initial/initial.module';
+
+@Module({
+  name: 'AppModule',
+  imports: [InitialModule],
+})
+export class AppModule {}

package/template/src/initial/application/initial-health.service.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@aetherionfw/core';
+import { InitialHealth } from '../domain/initial-health.entity';
+
+@Injectable()
+export class InitialHealthService {
+  getHealth(): InitialHealth {
+    return new InitialHealth(
+      'ok',
+      'Aetherion framework initial template is running',
+      'Aetherion',
+      '0.1.0',
+    );
+  }
+}

package/template/src/initial/controllers/initial.lambda.ts

@@ -0,0 +1,42 @@
+import {
+  LambdaController,
+  Handle,
+  Route,
+  IamPermissions,
+} from '@aetherionfw/core';
+import {
+  ApiTag,
+  ApiOperation,
+  ApiResponse,
+} from '@aetherionfw/docs';
+import { InitialHealthService } from '../application/initial-health.service';
+import { InitialHealthResponseDto } from '../dto/initial-health.response.dto';
+import initialIamPermissions from '../infra/iam/initial.permissions.json';
+
+@ApiTag('Initial', 'Template inicial de salud del framework Aetherion')
+@LambdaController({
+  lambdaName: 'initial-api',
+  runtime: 'nodejs22.x',
+  memorySize: 128,
+  timeout: 5,
+})
+export class InitialLambdaController {
+  constructor(private readonly health: InitialHealthService) {}
+
+  @Handle()
+  @Route({ method: 'GET', path: '/initial/health' })
+  @IamPermissions(initialIamPermissions.initialHealth)
+  @ApiOperation({
+    summary: 'Health check inicial',
+    description: 'Devuelve el estado básico del framework Aetherion (template inicial).',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Health OK',
+    type: InitialHealthResponseDto,
+  })
+  async getHealth(): Promise<InitialHealthResponseDto> {
+    const health = this.health.getHealth();
+    return InitialHealthResponseDto.fromEntity(health);
+  }
+}

package/template/src/initial/domain/initial-health.entity.ts

@@ -0,0 +1,8 @@
+export class InitialHealth {
+  constructor(
+    readonly status: 'ok',
+    readonly message: string,
+    readonly framework: string,
+    readonly version: string,
+  ) {}
+}

package/template/src/initial/dto/initial-health.response.dto.ts

@@ -0,0 +1,28 @@
+import { ApiProperty } from '@aetherionfw/docs';
+import { InitialHealth } from '../domain/initial-health.entity';
+
+export class InitialHealthResponseDto {
+  @ApiProperty({ description: 'Estado de salud del sistema', example: 'ok' })
+  status!: 'ok';
+
+  @ApiProperty({
+    description: 'Mensaje descriptivo del estado',
+    example: 'Aetherion framework initial template is running',
+  })
+  message!: string;
+
+  @ApiProperty({ description: 'Nombre del framework', example: 'Aetherion' })
+  framework!: string;
+
+  @ApiProperty({ description: 'Versión del framework', example: '0.1.0' })
+  version!: string;
+
+  static fromEntity(entity: InitialHealth): InitialHealthResponseDto {
+    const dto = new InitialHealthResponseDto();
+    dto.status = entity.status;
+    dto.message = entity.message;
+    dto.framework = entity.framework;
+    dto.version = entity.version;
+    return dto;
+  }
+}

package/template/src/initial/infra/iam/initial.permissions.json

@@ -0,0 +1,18 @@
+{
+  "initialHealth": {
+    "logs": [
+      {
+        "action": "logs:CreateLogGroup",
+        "resource": "*"
+      },
+      {
+        "action": "logs:CreateLogStream",
+        "resource": "*"
+      },
+      {
+        "action": "logs:PutLogEvents",
+        "resource": "*"
+      }
+    ]
+  }
+}

package/template/src/initial/infra/initial.infra.ts

@@ -0,0 +1,10 @@
+import { Infra } from '@aetherionfw/core';
+// Using generic HttpApi decorators if available, or just mocking for the template
+// Since we only added standard decorators like @Vpc, @S3Bucket, etc. earlier, we'll use a placeholder or generic @Infra config
+
+@Infra()
+export class InitialInfra {
+  // Example definition
+  // @ApiGatewayHttpApi({ name: 'initial-api', description: 'Initial health API for Aetherion framework' })
+  // api!: any;
+}

package/template/src/initial/initial.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@aetherionfw/core';
+import { InitialInfra } from './infra/initial.infra';
+import { InitialLambdaController } from './controllers/initial.lambda';
+import { InitialHealthService } from './application/initial-health.service';
+
+@Module({
+  name: 'InitialModule',
+  providers: [InitialHealthService],
+  controllers: [InitialLambdaController],
+  infra: [InitialInfra],
+})
+export class InitialModule {}

package/template/src/tests/initial.controller.spec.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { InitialLambdaController } from '../initial/controllers/initial.lambda';
+import { InitialHealthService } from '../initial/application/initial-health.service';
+
+describe('InitialLambdaController', () => {
+  it('should return initial health status', async () => {
+    const service = new InitialHealthService();
+    const controller = new InitialLambdaController(service);
+
+    const response = await controller.getHealth();
+
+    expect(response.status).toBe('ok');
+    expect(response.framework).toBe('Aetherion');
+  });
+});

package/template/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src"]
+}

package/template/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/tests/**/*.spec.ts']
+  }
+});