olly-molly 0.1.0 → 0.1.3

package/app/api/pm/breakdown/route.ts

@@ -1,142 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { ticketService, memberService } from '@/lib/db';
-import OpenAI from 'openai';
-
-const openai = new OpenAI({
-    apiKey: process.env.OPENAI_API_KEY,
-});
-
-/**
- * PM Agent - AI-powered feature breakdown
- * 
- * Uses OpenAI to analyze feature requests and create appropriate tasks
- * with intelligent assignment to team members.
- */
-
-interface TaskFromAI {
-    title: string;
-    description: string;
-    priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-    assignee_role: 'FE_DEV' | 'BACKEND_DEV' | 'QA' | 'DEVOPS';
-}
-
-const SYSTEM_PROMPT = `You are a PM (Project Manager) AI agent for a software development team.
-
-Your team consists of:
-- FE_DEV (Frontend Developer): Handles UI/UX, React, Next.js, CSS, components, user interfaces
-- BACKEND_DEV (Backend Developer): Handles APIs, databases, server logic, authentication, business logic
-- QA (QA Engineer): Handles testing, quality assurance, bug verification, E2E tests
-- DEVOPS (DevOps Engineer): Handles deployment, CI/CD, infrastructure, monitoring
-
-When given a feature request, you must:
-1. Break it down into specific, actionable tasks
-2. Assign each task to the appropriate team member based on their expertise
-3. Set priorities (CRITICAL > HIGH > MEDIUM > LOW)
-
-IMPORTANT RULES:
-- Create focused, single-responsibility tasks
-- Backend tasks should come before frontend integration tasks
-- Always include a QA task for testing
-- Be specific in task descriptions
-- Use Korean for titles and descriptions
-
-Respond in JSON format:
-{
-  "tasks": [
-    {
-      "title": "Task title in Korean",
-      "description": "Detailed task description in Korean",
-      "priority": "HIGH",
-      "assignee_role": "BACKEND_DEV"
-    }
-  ],
-  "summary": "Brief summary of the breakdown in Korean"
-}`;
-
-async function breakdownWithAI(request: string): Promise<{ tasks: TaskFromAI[]; summary: string }> {
-    const completion = await openai.chat.completions.create({
-        model: 'gpt-4o-mini',
-        messages: [
-            { role: 'system', content: SYSTEM_PROMPT },
-            { role: 'user', content: `Feature Request: ${request}` }
-        ],
-        response_format: { type: 'json_object' },
-        temperature: 0.7,
-        max_tokens: 2000,
-    });
-
-    const content = completion.choices[0].message.content;
-    if (!content) {
-        throw new Error('No response from AI');
-    }
-
-    return JSON.parse(content);
-}
-
-function getAssigneeByRole(role: string): string | null {
-    const member = memberService.getByRole(role);
-    return member?.id || null;
-}
-
-export async function POST(request: NextRequest) {
-    try {
-        const body = await request.json();
-
-        if (!body.request) {
-            return NextResponse.json(
-                { error: 'Feature request is required' },
-                { status: 400 }
-            );
-        }
-
-        if (!process.env.OPENAI_API_KEY) {
-            return NextResponse.json(
-                { error: 'OpenAI API key not configured' },
-                { status: 500 }
-            );
-        }
-
-        const pmMember = memberService.getByRole('PM');
-
-        // Use AI to break down the request
-        const aiResponse = await breakdownWithAI(body.request);
-
-        const createdTickets = [];
-
-        for (const task of aiResponse.tasks) {
-            const assigneeId = getAssigneeByRole(task.assignee_role);
-
-            const ticket = ticketService.create({
-                title: task.title,
-                description: task.description,
-                priority: task.priority,
-                assignee_id: assigneeId || undefined,
-                project_id: body.project_id,
-                created_by: pmMember?.id,
-            });
-
-            const assignee = assigneeId ? memberService.getById(assigneeId) : null;
-            createdTickets.push({
-                ...ticket,
-                assignee,
-                assigned_role: task.assignee_role,
-            });
-        }
-
-        return NextResponse.json({
-            success: true,
-            original_request: body.request,
-            created_by: pmMember,
-            tickets_created: createdTickets.length,
-            tickets: createdTickets,
-            ai_summary: aiResponse.summary,
-            message: `PM이 AI를 사용해 "${body.request}" 요청을 분석하여 ${createdTickets.length}개의 태스크를 생성했습니다.`,
-        }, { status: 201 });
-    } catch (error) {
-        console.error('Error in PM breakdown:', error);
-        return NextResponse.json(
-            { error: 'Failed to process feature request', details: String(error) },
-            { status: 500 }
-        );
-    }
-}

package/app/api/pm/tickets/route.ts

@@ -1,147 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { ticketService, memberService } from '@/lib/db';
-
-/**
- * PM Agent API - Create tickets with automatic assignment
- * 
- * The PM Agent analyzes the ticket content and automatically assigns
- * it to the most appropriate team member based on keywords and task type.
- */
-
-// Keywords mapping for auto-assignment
-const ROLE_KEYWORDS: Record<string, string[]> = {
-    FE_DEV: [
-        'frontend', 'ui', 'ux', 'react', 'component', 'css', 'style', 'design',
-        'button', 'form', 'page', 'layout', 'responsive', 'animation', 'tailwind',
-        '프론트엔드', 'UI', '컴포넌트', '디자인', '스타일', '화면', '페이지'
-    ],
-    BACKEND_DEV: [
-        'backend', 'api', 'database', 'db', 'server', 'endpoint', 'rest',
-        'authentication', 'auth', 'sql', 'query', 'migration', 'model',
-        '백엔드', 'API', '데이터베이스', '서버', '인증'
-    ],
-    QA: [
-        'test', 'testing', 'qa', 'quality', 'bug', 'fix', 'verify', 'validation',
-        'e2e', 'integration', 'unit test', 'playwright', 'automation',
-        '테스트', 'QA', '버그', '검증', '품질'
-    ],
-    DEVOPS: [
-        'deploy', 'deployment', 'ci', 'cd', 'pipeline', 'docker', 'kubernetes',
-        'infrastructure', 'monitoring', 'logging', 'aws', 'cloud', 'server',
-        '배포', '인프라', '파이프라인', '모니터링'
-    ],
-};
-
-function analyzeAndAssign(title: string, description?: string): string | null {
-    const text = `${title} ${description || ''}`.toLowerCase();
-
-    // Count keyword matches for each role
-    const scores: Record<string, number> = {
-        FE_DEV: 0,
-        BACKEND_DEV: 0,
-        QA: 0,
-        DEVOPS: 0,
-    };
-
-    for (const [role, keywords] of Object.entries(ROLE_KEYWORDS)) {
-        for (const keyword of keywords) {
-            if (text.includes(keyword.toLowerCase())) {
-                scores[role] += 1;
-            }
-        }
-    }
-
-    // Find the role with highest score
-    let maxScore = 0;
-    let assignedRole: string | null = null;
-
-    for (const [role, score] of Object.entries(scores)) {
-        if (score > maxScore) {
-            maxScore = score;
-            assignedRole = role;
-        }
-    }
-
-    // If no clear match, default to FE_DEV for general tasks
-    if (maxScore === 0) {
-        assignedRole = 'FE_DEV';
-    }
-
-    // Get the member with this role
-    const member = memberService.getByRole(assignedRole!);
-    return member?.id || null;
-}
-
-export async function POST(request: NextRequest) {
-    try {
-        const body = await request.json();
-
-        if (!body.title) {
-            return NextResponse.json(
-                { error: 'Title is required' },
-                { status: 400 }
-            );
-        }
-
-        // Get PM member
-        const pmMember = memberService.getByRole('PM');
-
-        // Auto-assign based on content analysis
-        let assigneeId = body.assignee_id;
-        let autoAssigned = false;
-
-        if (!assigneeId && body.auto_assign !== false) {
-            assigneeId = analyzeAndAssign(body.title, body.description);
-            autoAssigned = true;
-        }
-
-        // Create ticket with PM as creator
-        const ticket = ticketService.create({
-            title: body.title,
-            description: body.description,
-            priority: body.priority || 'MEDIUM',
-            assignee_id: assigneeId,
-            created_by: pmMember?.id,
-        });
-
-        // Get assignee info for response
-        const assignee = assigneeId ? memberService.getById(assigneeId) : null;
-
-        return NextResponse.json({
-            ...ticket,
-            assignee,
-            auto_assigned: autoAssigned,
-            created_by_pm: true,
-        }, { status: 201 });
-    } catch (error) {
-        console.error('Error in PM create ticket:', error);
-        return NextResponse.json(
-            { error: 'Failed to create ticket' },
-            { status: 500 }
-        );
-    }
-}
-
-// GET endpoint to get PM agent info and capabilities
-export async function GET() {
-    try {
-        const pmMember = memberService.getByRole('PM');
-        const allMembers = memberService.getAll();
-
-        return NextResponse.json({
-            pm: pmMember,
-            team: allMembers.filter(m => m.role !== 'PM'),
-            capabilities: {
-                auto_assignment: true,
-                supported_roles: Object.keys(ROLE_KEYWORDS),
-                keywords: ROLE_KEYWORDS,
-            },
-        });
-    } catch (error) {
-        console.error('Error fetching PM info:', error);
-        return NextResponse.json(
-            { error: 'Failed to fetch PM info' },
-            { status: 500 }
-        );
-    }
-}

package/app/api/projects/[id]/route.ts

@@ -1,56 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { projectService } from '@/lib/db';
-
-export async function GET(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const project = projectService.getById(id);
-        if (!project) {
-            return NextResponse.json({ error: 'Project not found' }, { status: 404 });
-        }
-        return NextResponse.json(project);
-    } catch (error) {
-        console.error('Error fetching project:', error);
-        return NextResponse.json({ error: 'Failed to fetch project' }, { status: 500 });
-    }
-}
-
-export async function DELETE(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const deleted = projectService.delete(id);
-        if (!deleted) {
-            return NextResponse.json({ error: 'Project not found' }, { status: 404 });
-        }
-        return NextResponse.json({ success: true });
-    } catch (error) {
-        console.error('Error deleting project:', error);
-        return NextResponse.json({ error: 'Failed to delete project' }, { status: 500 });
-    }
-}
-
-export async function PATCH(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const body = await request.json();
-
-        if (body.is_active) {
-            const project = projectService.setActive(id);
-            return NextResponse.json(project);
-        }
-
-        return NextResponse.json({ error: 'Invalid update' }, { status: 400 });
-    } catch (error) {
-        console.error('Error updating project:', error);
-        return NextResponse.json({ error: 'Failed to update project' }, { status: 500 });
-    }
-}

package/app/api/projects/active/route.ts

@@ -1,15 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { projectService } from '@/lib/db';
-
-export async function GET() {
-    try {
-        const project = projectService.getActive();
-        if (!project) {
-            return NextResponse.json({ error: 'No active project' }, { status: 404 });
-        }
-        return NextResponse.json(project);
-    } catch (error) {
-        console.error('Error fetching active project:', error);
-        return NextResponse.json({ error: 'Failed to fetch active project' }, { status: 500 });
-    }
-}

package/app/api/projects/route.ts

@@ -1,53 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { projectService } from '@/lib/db';
-import fs from 'fs';
-import path from 'path';
-
-export async function GET() {
-    try {
-        const projects = projectService.getAll();
-        return NextResponse.json(projects);
-    } catch (error) {
-        console.error('Error fetching projects:', error);
-        return NextResponse.json({ error: 'Failed to fetch projects' }, { status: 500 });
-    }
-}
-
-export async function POST(request: NextRequest) {
-    try {
-        const body = await request.json();
-
-        if (!body.path) {
-            return NextResponse.json({ error: 'Project path is required' }, { status: 400 });
-        }
-
-        // Validate that the path exists and is a directory
-        const projectPath = body.path;
-        if (!fs.existsSync(projectPath)) {
-            return NextResponse.json({ error: 'Path does not exist' }, { status: 400 });
-        }
-
-        const stats = fs.statSync(projectPath);
-        if (!stats.isDirectory()) {
-            return NextResponse.json({ error: 'Path is not a directory' }, { status: 400 });
-        }
-
-        // Check if it's a git repository
-        const gitPath = path.join(projectPath, '.git');
-        const isGitRepo = fs.existsSync(gitPath);
-
-        // Extract project name from path if not provided
-        const name = body.name || path.basename(projectPath);
-
-        const project = projectService.create({
-            name,
-            path: projectPath,
-            description: body.description || (isGitRepo ? 'Git repository' : 'Local project'),
-        });
-
-        return NextResponse.json({ ...project, is_git_repo: isGitRepo }, { status: 201 });
-    } catch (error) {
-        console.error('Error creating project:', error);
-        return NextResponse.json({ error: 'Failed to create project' }, { status: 500 });
-    }
-}

package/app/api/tickets/[id]/logs/route.ts

@@ -1,16 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { activityService } from '@/lib/db';
-
-export async function GET(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const logs = activityService.getByTicketId(id);
-        return NextResponse.json(logs);
-    } catch (error) {
-        console.error('Error fetching activity logs:', error);
-        return NextResponse.json({ error: 'Failed to fetch activity logs' }, { status: 500 });
-    }
-}

package/app/api/tickets/[id]/route.ts

@@ -1,60 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { ticketService, activityService } from '@/lib/db';
-
-export async function GET(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const ticket = ticketService.getById(id);
-        if (!ticket) {
-            return NextResponse.json({ error: 'Ticket not found' }, { status: 404 });
-        }
-
-        // Include activity logs
-        const logs = activityService.getByTicketId(id);
-
-        return NextResponse.json({ ...ticket, logs });
-    } catch (error) {
-        console.error('Error fetching ticket:', error);
-        return NextResponse.json({ error: 'Failed to fetch ticket' }, { status: 500 });
-    }
-}
-
-export async function PATCH(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const body = await request.json();
-        const { updated_by, ...data } = body;
-
-        const ticket = ticketService.update(id, data, updated_by);
-        if (!ticket) {
-            return NextResponse.json({ error: 'Ticket not found' }, { status: 404 });
-        }
-        return NextResponse.json(ticket);
-    } catch (error) {
-        console.error('Error updating ticket:', error);
-        return NextResponse.json({ error: 'Failed to update ticket' }, { status: 500 });
-    }
-}
-
-export async function DELETE(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const deleted = ticketService.delete(id);
-        if (!deleted) {
-            return NextResponse.json({ error: 'Ticket not found' }, { status: 404 });
-        }
-        return NextResponse.json({ success: true });
-    } catch (error) {
-        console.error('Error deleting ticket:', error);
-        return NextResponse.json({ error: 'Failed to delete ticket' }, { status: 500 });
-    }
-}

package/app/api/tickets/[id]/work-logs/route.ts

@@ -1,16 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { agentWorkLogService } from '@/lib/db';
-
-export async function GET(
-    request: NextRequest,
-    { params }: { params: Promise<{ id: string }> }
-) {
-    try {
-        const { id } = await params;
-        const logs = agentWorkLogService.getByTicketId(id);
-        return NextResponse.json(logs);
-    } catch (error) {
-        console.error('Error fetching work logs:', error);
-        return NextResponse.json({ error: 'Failed to fetch work logs' }, { status: 500 });
-    }
-}

package/app/api/tickets/route.ts

@@ -1,37 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { ticketService } from '@/lib/db';
-
-export async function GET(request: NextRequest) {
-    try {
-        const { searchParams } = new URL(request.url);
-        const status = searchParams.get('status') || undefined;
-        const projectId = searchParams.get('projectId') || undefined;
-        const tickets = ticketService.getAll(status, projectId);
-        return NextResponse.json(tickets);
-    } catch (error) {
-        console.error('Error fetching tickets:', error);
-        return NextResponse.json({ error: 'Failed to fetch tickets' }, { status: 500 });
-    }
-}
-
-export async function POST(request: NextRequest) {
-    try {
-        const body = await request.json();
-        if (!body.title) {
-            return NextResponse.json({ error: 'Title is required' }, { status: 400 });
-        }
-        const ticket = ticketService.create({
-            title: body.title,
-            description: body.description,
-            priority: body.priority,
-            assignee_id: body.assignee_id,
-            project_id: body.project_id,
-            created_by: body.created_by,
-        });
-        return NextResponse.json(ticket, { status: 201 });
-    } catch (error) {
-        console.error('Error creating ticket:', error);
-        return NextResponse.json({ error: 'Failed to create ticket' }, { status: 500 });
-    }
-}
-