aiwf 0.3.6 → 0.3.8

package/src/lib/resources/templates/api-server/template/src/controllers/aiwfController.ts

@@ -0,0 +1,68 @@
+import { Request, Response, NextFunction } from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+
+export const aiwfController = {
+  getFeatures: async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const ledgerPath = path.join(process.cwd(), '.aiwf', 'feature-ledger.json');
+      const ledgerData = await fs.readFile(ledgerPath, 'utf-8');
+      const ledger = JSON.parse(ledgerData);
+
+      res.json({
+        success: true,
+        data: ledger,
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  getTokenUsage: async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      // 실제 구현에서는 토큰 사용량을 추적하는 로직 필요
+      const mockData = {
+        total: parseInt(process.env.AIWF_TOKEN_LIMIT || '100000'),
+        used: 45000,
+        remaining: 55000,
+        percentage: 45,
+        history: [
+          {
+            date: new Date().toISOString(),
+            tokens: 1500,
+            action: 'API endpoint creation',
+            endpoint: 'POST /api/v1/users',
+          },
+        ],
+      };
+
+      res.json({
+        success: true,
+        data: mockData,
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+
+  getContextStatus: async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const configPath = path.join(process.cwd(), '.aiwf', 'config.json');
+      const configData = await fs.readFile(configPath, 'utf-8');
+      const config = JSON.parse(configData);
+
+      res.json({
+        success: true,
+        data: {
+          compressionLevel: config.features.context_compression.level,
+          cacheEnabled: config.features.context_compression.cache_enabled,
+          tokenLimit: config.features.context_compression.token_limit,
+          activePersona: config.features.ai_persona.default,
+          availablePersonas: config.features.ai_persona.available,
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  },
+};

package/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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/src/lib/resources/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"]
+}