aiwf 0.3.21 → 0.3.23

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

@@ -1,54 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import fs from 'fs/promises';
-import path from 'path';
-
-export const aiwfController = {
-
-  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

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

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-import { Router } from 'express';
-import { aiwfController } from '@controllers/aiwfController';
-
-const router = Router();
-
-
-/**
- * @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

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

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

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

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

@@ -1,43 +0,0 @@
-{
-  "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"]
-}