aiwf 0.3.1 → 0.3.3

package/.aiwf/templates/api-server/template/src/controllers/authController.ts

@@ -0,0 +1,128 @@
+import { Request, Response, NextFunction } from 'express';
+import { validationResult } from 'express-validator';
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+
+interface User {
+  id: string;
+  email: string;
+  password: string;
+  name: string;
+}
+
+// 임시 메모리 저장소 (실제로는 데이터베이스 사용)
+const users: User[] = [];
+
+export const authController = {
+  register: async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const errors = validationResult(req);
+      if (!errors.isEmpty()) {
+        return res.status(400).json({ 
+          success: false, 
+          errors: errors.array() 
+        });
+      }
+
+      const { email, password, name } = req.body;
+
+      // 중복 체크
+      const existingUser = users.find(u => u.email === email);
+      if (existingUser) {
+        return res.status(409).json({
+          success: false,
+          error: { message: 'Email already exists' }
+        });
+      }
+
+      // 비밀번호 해싱
+      const hashedPassword = await bcrypt.hash(
+        password, 
+        parseInt(process.env.BCRYPT_ROUNDS || '10')
+      );
+
+      // 사용자 생성
+      const newUser: User = {
+        id: Date.now().toString(),
+        email,
+        password: hashedPassword,
+        name,
+      };
+      users.push(newUser);
+
+      // JWT 토큰 생성
+      const token = jwt.sign(
+        { id: newUser.id, email: newUser.email },
+        process.env.JWT_SECRET || 'secret',
+        { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
+      );
+
+      res.status(201).json({
+        success: true,
+        data: {
+          user: {
+            id: newUser.id,
+            email: newUser.email,
+            name: newUser.name,
+          },
+          token,
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  login: async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const errors = validationResult(req);
+      if (!errors.isEmpty()) {
+        return res.status(400).json({ 
+          success: false, 
+          errors: errors.array() 
+        });
+      }
+
+      const { email, password } = req.body;
+
+      // 사용자 찾기
+      const user = users.find(u => u.email === email);
+      if (!user) {
+        return res.status(401).json({
+          success: false,
+          error: { message: 'Invalid credentials' }
+        });
+      }
+
+      // 비밀번호 확인
+      const isPasswordValid = await bcrypt.compare(password, user.password);
+      if (!isPasswordValid) {
+        return res.status(401).json({
+          success: false,
+          error: { message: 'Invalid credentials' }
+        });
+      }
+
+      // JWT 토큰 생성
+      const token = jwt.sign(
+        { id: user.id, email: user.email },
+        process.env.JWT_SECRET || 'secret',
+        { expiresIn: process.env.JWT_EXPIRES_IN || '7d' }
+      );
+
+      res.json({
+        success: true,
+        data: {
+          user: {
+            id: user.id,
+            email: user.email,
+            name: user.name,
+          },
+          token,
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

package/.aiwf/templates/api-server/template/src/controllers/statusController.ts

@@ -0,0 +1,28 @@
+import { Request, Response } from 'express';
+import os from 'os';
+
+export const statusController = {
+  getStatus: (req: Request, res: Response) => {
+    res.json({
+      success: true,
+      data: {
+        service: '{{projectName}}',
+        version: process.env.npm_package_version || '0.0.1',
+        environment: process.env.NODE_ENV || 'development',
+        uptime: process.uptime(),
+        timestamp: new Date().toISOString(),
+        system: {
+          platform: os.platform(),
+          release: os.release(),
+          totalMemory: os.totalmem(),
+          freeMemory: os.freemem(),
+          cpus: os.cpus().length,
+        },
+        aiwf: {
+          enabled: process.env.AIWF_ENABLED === 'true',
+          compressionLevel: process.env.AIWF_COMPRESSION_LEVEL || 'balanced',
+        },
+      },
+    });
+  },
+};

package/.aiwf/templates/api-server/template/src/index.ts

@@ -0,0 +1,28 @@
+import 'dotenv/config';
+import app from './app';
+import logger from '@utils/logger';
+
+const PORT = process.env.PORT || 3000;
+const HOST = process.env.HOST || 'localhost';
+
+const server = app.listen(PORT, () => {
+  logger.info(`🚀 Server is running on http://${HOST}:${PORT}`);
+  logger.info(`📚 API Documentation available at http://${HOST}:${PORT}/docs`);
+  logger.info(`🤖 AIWF Integration enabled`);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  logger.info('SIGTERM signal received: closing HTTP server');
+  server.close(() => {
+    logger.info('HTTP server closed');
+    process.exit(0);
+  });
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  // Application specific logging, throwing an error, or other logic here
+});
+
+export default server;

package/.aiwf/templates/api-server/template/src/middleware/aiwfMiddleware.ts

@@ -0,0 +1,50 @@
+import { Request, Response, NextFunction } from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+
+interface AiwfRequest extends Request {
+  aiwf?: {
+    featureId?: string;
+    persona?: string;
+    tokenUsage?: number;
+  };
+}
+
+export const aiwfMiddleware = async (
+  req: AiwfRequest,
+  res: Response,
+  next: NextFunction
+) => {
+  // AIWF 헤더 체크
+  const featureId = req.headers['x-aiwf-feature-id'] as string;
+  const persona = req.headers['x-aiwf-persona'] as string;
+
+  req.aiwf = {
+    featureId,
+    persona: persona || 'backend-engineer',
+    tokenUsage: 0,
+  };
+
+  // Feature 추적
+  if (featureId && process.env.AIWF_ENABLED === 'true') {
+    try {
+      const ledgerPath = path.join(process.cwd(), '.aiwf', 'feature-ledger.json');
+      const ledgerData = await fs.readFile(ledgerPath, 'utf-8');
+      const ledger = JSON.parse(ledgerData);
+      
+      // API 엔드포인트 추적 로직
+      const endpoint = `${req.method} ${req.route?.path || req.path}`;
+      const feature = ledger.features.find((f: any) => f.id === featureId);
+      
+      if (feature && !feature.endpoints?.includes(endpoint)) {
+        feature.endpoints = feature.endpoints || [];
+        feature.endpoints.push(endpoint);
+        await fs.writeFile(ledgerPath, JSON.stringify(ledger, null, 2));
+      }
+    } catch (error) {
+      // 에러 무시 (AIWF 기능이 없어도 API는 동작해야 함)
+    }
+  }
+
+  next();
+};

package/.aiwf/templates/api-server/template/src/middleware/authMiddleware.ts

@@ -0,0 +1,41 @@
+import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+
+interface AuthRequest extends Request {
+  user?: {
+    id: string;
+    email: string;
+  };
+}
+
+export const authMiddleware = (
+  req: AuthRequest,
+  res: Response,
+  next: NextFunction
+) => {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({
+      success: false,
+      error: { message: 'No token provided' }
+    });
+  }
+
+  const token = authHeader.substring(7);
+
+  try {
+    const decoded = jwt.verify(
+      token,
+      process.env.JWT_SECRET || 'secret'
+    ) as { id: string; email: string };
+
+    req.user = decoded;
+    next();
+  } catch (error) {
+    return res.status(401).json({
+      success: false,
+      error: { message: 'Invalid token' }
+    });
+  }
+};

package/.aiwf/templates/api-server/template/src/middleware/errorHandler.ts

@@ -0,0 +1,42 @@
+import { Request, Response, NextFunction } from 'express';
+import logger from '@utils/logger';
+
+interface CustomError extends Error {
+  statusCode?: number;
+  status?: string;
+  isOperational?: boolean;
+}
+
+export const errorHandler = (
+  err: CustomError,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  let { statusCode = 500, message } = err;
+
+  logger.error({
+    error: err,
+    request: {
+      method: req.method,
+      url: req.url,
+      headers: req.headers,
+      body: req.body,
+    },
+  });
+
+  // Don't leak error details in production
+  if (process.env.NODE_ENV === 'production' && statusCode === 500) {
+    message = 'Internal Server Error';
+  }
+
+  res.status(statusCode).json({
+    success: false,
+    error: {
+      statusCode,
+      message,
+      ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
+    },
+    timestamp: new Date().toISOString(),
+  });
+};

package/.aiwf/templates/api-server/template/src/middleware/notFoundHandler.ts

@@ -0,0 +1,14 @@
+import { Request, Response } from 'express';
+
+export const notFoundHandler = (req: Request, res: Response) => {
+  res.status(404).json({
+    success: false,
+    error: {
+      statusCode: 404,
+      message: 'Resource not found',
+      path: req.url,
+      method: req.method,
+    },
+    timestamp: new Date().toISOString(),
+  });
+};

package/.aiwf/templates/api-server/template/src/middleware/requestLogger.ts

@@ -0,0 +1,20 @@
+import { Request, Response, NextFunction } from 'express';
+import logger from '@utils/logger';
+
+export const requestLogger = (req: Request, res: Response, next: NextFunction) => {
+  const start = Date.now();
+
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    logger.info({
+      method: req.method,
+      url: req.url,
+      status: res.statusCode,
+      duration: `${duration}ms`,
+      ip: req.ip,
+      userAgent: req.get('user-agent'),
+    });
+  });
+
+  next();
+};

package/.aiwf/templates/api-server/template/src/routes/aiwf.ts

@@ -0,0 +1,42 @@
+import { Router } from 'express';
+import { aiwfController } from '@controllers/aiwfController';
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/aiwf/features:
+ *   get:
+ *     summary: Feature Ledger 조회
+ *     tags: [AIWF]
+ *     responses:
+ *       200:
+ *         description: Feature 목록
+ */
+router.get('/features', aiwfController.getFeatures);
+
+/**
+ * @swagger
+ * /api/aiwf/token-usage:
+ *   get:
+ *     summary: 토큰 사용량 조회
+ *     tags: [AIWF]
+ *     responses:
+ *       200:
+ *         description: 토큰 사용 현황
+ */
+router.get('/token-usage', aiwfController.getTokenUsage);
+
+/**
+ * @swagger
+ * /api/aiwf/context:
+ *   get:
+ *     summary: Context 상태 조회
+ *     tags: [AIWF]
+ *     responses:
+ *       200:
+ *         description: Context 압축 상태
+ */
+router.get('/context', aiwfController.getContextStatus);
+
+export default router;

package/.aiwf/templates/api-server/template/src/routes/index.ts

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import v1Routes from './v1';
+import aiwfRoutes from './aiwf';
+
+const router = Router();
+
+// API 버전 라우팅
+router.use('/v1', v1Routes);
+
+// AIWF 전용 라우트
+router.use('/aiwf', aiwfRoutes);
+
+export default router;

package/.aiwf/templates/api-server/template/src/routes/v1/index.ts

@@ -0,0 +1,67 @@
+import { Router } from 'express';
+import { statusController } from '@controllers/statusController';
+import { authController } from '@controllers/authController';
+import { authMiddleware } from '@middleware/authMiddleware';
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/v1/status:
+ *   get:
+ *     summary: API 상태 확인
+ *     tags: [Status]
+ *     responses:
+ *       200:
+ *         description: API 상태 정보
+ */
+router.get('/status', statusController.getStatus);
+
+/**
+ * @swagger
+ * /api/v1/auth/register:
+ *   post:
+ *     summary: 사용자 등록
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               email:
+ *                 type: string
+ *               password:
+ *                 type: string
+ *               name:
+ *                 type: string
+ */
+router.post('/auth/register', authController.register);
+
+/**
+ * @swagger
+ * /api/v1/auth/login:
+ *   post:
+ *     summary: 사용자 로그인
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               email:
+ *                 type: string
+ *               password:
+ *                 type: string
+ */
+router.post('/auth/login', authController.login);
+
+// Protected routes example
+router.get('/protected', authMiddleware, (req, res) => {
+  res.json({ message: 'This is a protected route' });
+});
+
+export default router;

package/.aiwf/templates/api-server/template/src/utils/logger.ts

@@ -0,0 +1,37 @@
+import winston from 'winston';
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: '{{projectName}}' },
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple()
+      ),
+    }),
+  ],
+});
+
+// Production에서는 파일 로깅 추가
+if (process.env.NODE_ENV === 'production') {
+  logger.add(
+    new winston.transports.File({
+      filename: 'logs/error.log',
+      level: 'error',
+    })
+  );
+  logger.add(
+    new winston.transports.File({
+      filename: 'logs/combined.log',
+    })
+  );
+}
+
+export default logger;

package/.aiwf/templates/api-server/template/tests/app.test.ts

@@ -0,0 +1,40 @@
+import request from 'supertest';
+import app from '../src/app';
+
+describe('App', () => {
+  describe('GET /health', () => {
+    it('should return health status', async () => {
+      const response = await request(app)
+        .get('/health')
+        .expect(200);
+
+      expect(response.body).toHaveProperty('status', 'healthy');
+      expect(response.body).toHaveProperty('timestamp');
+      expect(response.body).toHaveProperty('uptime');
+    });
+  });
+
+  describe('GET /api/v1/status', () => {
+    it('should return API status', async () => {
+      const response = await request(app)
+        .get('/api/v1/status')
+        .expect(200);
+
+      expect(response.body.success).toBe(true);
+      expect(response.body.data).toHaveProperty('service');
+      expect(response.body.data).toHaveProperty('version');
+      expect(response.body.data).toHaveProperty('aiwf');
+    });
+  });
+
+  describe('404 Handler', () => {
+    it('should return 404 for unknown routes', async () => {
+      const response = await request(app)
+        .get('/unknown-route')
+        .expect(404);
+
+      expect(response.body.success).toBe(false);
+      expect(response.body.error.statusCode).toBe(404);
+    });
+  });
+});

package/.aiwf/templates/api-server/template/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@config/*": ["src/config/*"],
+      "@controllers/*": ["src/controllers/*"],
+      "@middleware/*": ["src/middleware/*"],
+      "@models/*": ["src/models/*"],
+      "@routes/*": ["src/routes/*"],
+      "@services/*": ["src/services/*"],
+      "@utils/*": ["src/utils/*"],
+      "@types/*": ["src/types/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/.aiwf/templates/npm-library/config.json

@@ -0,0 +1,61 @@
+{
+  "name": "npm-library",
+  "displayName": "NPM 라이브러리",
+  "description": "TypeScript 기반 NPM 패키지 라이브러리 템플릿",
+  "type": "npm-library",
+  "language": "typescript",
+  "framework": "none",
+  "features": [
+    "TypeScript",
+    "Rollup Build",
+    "Jest Testing",
+    "ESM & CommonJS",
+    "Type Definitions",
+    "Tree Shaking",
+    "AIWF Integration",
+    "Auto Versioning"
+  ],
+  "structure": {
+    "src": "소스 코드",
+    "tests": "테스트 파일",
+    "dist": "빌드 출력",
+    ".aiwf": "AIWF 설정 및 메타데이터",
+    "docs": "라이브러리 문서"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@typescript-eslint/parser": "^5.60.0",
+    "typescript": "^5.1.0",
+    "rollup": "^3.25.0",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-json": "^6.0.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "eslint": "^8.43.0",
+    "jest": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "np": "^8.0.0",
+    "husky": "^8.0.0",
+    "lint-staged": "^13.0.0",
+    "prettier": "^2.8.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "dev": "rollup -c -w",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build",
+    "release": "np",
+    "aiwf": "node .aiwf/scripts/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/.aiwf/templates/npm-library/template/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) {{year}} {{author}}
+
+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.