@silbaram/artifact-driven-agent 0.1.6 → 0.1.9

package/src/utils/sessionState.process.test.js

@@ -0,0 +1,101 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs-extra';
+import path from 'path';
+import {
+  cleanupZombieSessions,
+  readStatus,
+  writeStatus,
+  getStatusFilePath
+} from './sessionState.js';
+import { getSessionsDir } from './files.js';
+
+describe('좀비 세션 정리 - 프로세스 확인', () => {
+  let originalCwd;
+  let testDir;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    testDir = path.join(process.cwd(), '.test-workspace');
+    fs.ensureDirSync(testDir);
+    process.chdir(testDir);
+
+    fs.ensureDirSync(path.join(testDir, 'ai-dev-team'));
+
+    const initialStatus = {
+      version: '1.0',
+      updatedAt: new Date().toISOString(),
+      currentPhase: 'planning',
+      activeSessions: [],
+      pendingQuestions: [],
+      taskProgress: {},
+      notifications: [],
+      locks: {}
+    };
+    const statusFilePath = getStatusFilePath();
+    fs.ensureDirSync(path.dirname(statusFilePath));
+    fs.writeFileSync(statusFilePath, JSON.stringify(initialStatus, null, 2));
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.removeSync(testDir);
+  });
+
+  test('실행 중 pid는 오래돼도 유지', () => {
+    const status = readStatus();
+    status.activeSessions = [
+      {
+        sessionId: 'sess-live',
+        role: 'developer',
+        tool: 'codex',
+        startedAt: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+        status: 'active',
+        pid: process.pid
+      }
+    ];
+    writeStatus(status);
+
+    const removed = cleanupZombieSessions(60);
+    assert.strictEqual(removed, 0);
+
+    const updated = readStatus();
+    assert.strictEqual(updated.activeSessions.length, 1);
+    assert.strictEqual(updated.activeSessions[0].sessionId, 'sess-live');
+  });
+
+  test('종료된 pid는 즉시 정리되고 세션 상태가 error로 기록됨', () => {
+    const pid = 9999999;
+    const sessionId = 'sess-dead';
+    const status = readStatus();
+    status.activeSessions = [
+      {
+        sessionId,
+        role: 'developer',
+        tool: 'codex',
+        startedAt: new Date().toISOString(),
+        status: 'active',
+        pid
+      }
+    ];
+    writeStatus(status);
+
+    const sessionDir = path.join(getSessionsDir(), sessionId);
+    fs.ensureDirSync(sessionDir);
+    fs.writeFileSync(
+      path.join(sessionDir, 'session.json'),
+      JSON.stringify({ session_id: sessionId, status: 'active' }, null, 2)
+    );
+
+    const removed = cleanupZombieSessions(60);
+    assert.strictEqual(removed, 1);
+
+    const updated = readStatus();
+    assert.strictEqual(updated.activeSessions.length, 0);
+
+    const updatedSession = JSON.parse(fs.readFileSync(path.join(sessionDir, 'session.json'), 'utf-8'));
+    assert.strictEqual(updatedSession.status, 'error');
+    assert.ok(updatedSession.ended_at);
+    assert.ok(updatedSession.error);
+  });
+});

package/src/utils/sessionState.test.js

@@ -0,0 +1,183 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs-extra';
+import path from 'path';
+import {
+  addQuestion,
+  answerQuestion,
+  addNotification,
+  markNotificationAsRead,
+  markNotificationsAsRead,
+  markNotificationsByFilter,
+  readStatus,
+  writeStatus,
+  getStatusFilePath
+} from './sessionState.js';
+
+describe('알림 읽음 처리 기능', () => {
+  let originalCwd;
+  let testDir;
+
+  beforeEach(() => {
+    // 테스트용 임시 디렉토리 생성
+    originalCwd = process.cwd();
+    testDir = path.join(process.cwd(), '.test-workspace');
+    fs.ensureDirSync(testDir);
+    process.chdir(testDir);
+
+    // ai-dev-team 디렉토리 생성
+    fs.ensureDirSync(path.join(testDir, 'ai-dev-team'));
+
+    // 초기 상태 파일 생성
+    const initialStatus = {
+      version: '1.0',
+      updatedAt: new Date().toISOString(),
+      currentPhase: 'planning',
+      activeSessions: [],
+      pendingQuestions: [],
+      taskProgress: {},
+      notifications: [],
+      locks: {}
+    };
+    const statusFilePath = getStatusFilePath();
+    fs.ensureDirSync(path.dirname(statusFilePath));
+    fs.writeFileSync(statusFilePath, JSON.stringify(initialStatus, null, 2));
+  });
+
+  afterEach(() => {
+    // 테스트 디렉토리 정리
+    process.chdir(originalCwd);
+    fs.removeSync(testDir);
+  });
+
+  test('알림 추가 시 to 필드가 포함됨', () => {
+    addNotification('info', 'planner', '테스트 알림', 'developer');
+
+    const status = readStatus();
+    assert.strictEqual(status.notifications.length, 1);
+    assert.strictEqual(status.notifications[0].to, 'developer');
+    assert.strictEqual(status.notifications[0].read, false);
+  });
+
+  test('markNotificationAsRead로 알림 읽음 처리', () => {
+    addNotification('info', 'planner', '테스트 알림', 'developer');
+    const status = readStatus();
+    const notifId = status.notifications[0].id;
+
+    const result = markNotificationAsRead(notifId);
+
+    assert.strictEqual(result, true);
+
+    const updatedStatus = readStatus();
+    assert.strictEqual(updatedStatus.notifications[0].read, true);
+    assert.ok(updatedStatus.notifications[0].readAt);
+  });
+
+  test('이미 읽은 알림은 다시 처리하지 않음', () => {
+    addNotification('info', 'planner', '테스트 알림', 'developer');
+    const status = readStatus();
+    const notifId = status.notifications[0].id;
+
+    markNotificationAsRead(notifId);
+    const firstReadAt = readStatus().notifications[0].readAt;
+
+    // 약간의 지연
+    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    return delay(10).then(() => {
+      const result = markNotificationAsRead(notifId);
+      assert.strictEqual(result, false);
+
+      const secondReadAt = readStatus().notifications[0].readAt;
+      assert.strictEqual(firstReadAt, secondReadAt);
+    });
+  });
+
+  test('markNotificationsAsRead로 여러 알림 읽음 처리', () => {
+    addNotification('info', 'planner', '알림 1', 'developer');
+    addNotification('info', 'planner', '알림 2', 'developer');
+    addNotification('info', 'planner', '알림 3', 'developer');
+
+    const status = readStatus();
+    const ids = status.notifications.map(n => n.id);
+
+    const markedCount = markNotificationsAsRead(ids);
+
+    assert.strictEqual(markedCount, 3);
+
+    const updatedStatus = readStatus();
+    updatedStatus.notifications.forEach(n => {
+      assert.strictEqual(n.read, true);
+    });
+  });
+
+  test('markNotificationsByFilter로 조건부 읽음 처리', () => {
+    addNotification('info', 'planner', '알림 1', 'developer');
+    addNotification('warning', 'reviewer', '알림 2', 'developer');
+    addNotification('info', 'planner', '알림 3', 'manager');
+
+    // developer에게 온 알림만 읽음 처리
+    const markedCount = markNotificationsByFilter(n => n.to === 'developer');
+
+    assert.strictEqual(markedCount, 2);
+
+    const status = readStatus();
+    assert.strictEqual(status.notifications[0].read, true); // developer
+    assert.strictEqual(status.notifications[1].read, true); // developer
+    assert.strictEqual(status.notifications[2].read, false); // manager
+  });
+
+  test('질문 추가 시 알림의 to가 질문 대상으로 설정됨', () => {
+    addQuestion('planner', 'developer', 'API 엔드포인트는?', ['POST /users', 'GET /users']);
+
+    const status = readStatus();
+    assert.strictEqual(status.notifications.length, 1);
+    assert.strictEqual(status.notifications[0].to, 'developer');
+    assert.ok(status.notifications[0].message.includes('QP001'));
+  });
+
+  test('질문 응답 시 관련 알림 자동 읽음 처리', () => {
+    const questionId = addQuestion('planner', 'developer', 'API 엔드포인트는?');
+
+    // 질문 전 상태 확인
+    let status = readStatus();
+    assert.strictEqual(status.notifications[0].read, false);
+
+    // 질문 응답
+    answerQuestion(questionId, 'POST /users');
+
+    // 질문 관련 알림이 읽음 처리되었는지 확인
+    status = readStatus();
+    const questionNotif = status.notifications.find(n => n.message.includes(questionId));
+    assert.strictEqual(questionNotif.read, true);
+    assert.ok(questionNotif.readAt);
+  });
+
+  test('질문 응답 시 응답 알림이 질문자에게 전달됨', () => {
+    const questionId = addQuestion('planner', 'developer', 'API 엔드포인트는?');
+
+    answerQuestion(questionId, 'POST /users');
+
+    const status = readStatus();
+    const answerNotif = status.notifications.find(n => n.message.includes('응답됨'));
+    assert.ok(answerNotif);
+    assert.strictEqual(answerNotif.to, 'planner'); // 질문자에게 전달
+    assert.strictEqual(answerNotif.from, 'manager');
+  });
+
+  test('통계: 읽지 않은 알림 개수 정확함', () => {
+    addNotification('info', 'planner', '알림 1', 'developer');
+    addNotification('info', 'planner', '알림 2', 'developer');
+    addNotification('info', 'planner', '알림 3', 'developer');
+
+    let status = readStatus();
+    const unreadCount1 = status.notifications.filter(n => !n.read).length;
+    assert.strictEqual(unreadCount1, 3);
+
+    // 하나 읽음 처리
+    markNotificationAsRead(status.notifications[0].id);
+
+    status = readStatus();
+    const unreadCount2 = status.notifications.filter(n => !n.read).length;
+    assert.strictEqual(unreadCount2, 2);
+  });
+});

package/src/utils/sprintUtils.js

@@ -0,0 +1,134 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { parseTaskMetadata } from './taskParser.js';
+
+/**
+ * 현재 활성 스프린트 찾기
+ * @param {string} sprintsDir
+ */
+export function findActiveSprint(sprintsDir) {
+  try {
+    if (!fs.existsSync(sprintsDir)) return null;
+
+    const sprints = fs.readdirSync(sprintsDir).filter(d => {
+      try {
+        return fs.statSync(path.join(sprintsDir, d)).isDirectory() && !d.startsWith('_');
+      } catch {
+        return false;
+      }
+    });
+
+    for (const sprint of sprints) {
+      const metaPath = path.join(sprintsDir, sprint, 'meta.md');
+      if (fs.existsSync(metaPath)) {
+        try {
+          const content = fs.readFileSync(metaPath, 'utf-8');
+          if (content.includes('상태 | active')) {
+            return sprint;
+          }
+        } catch {
+          // 파일 읽기 실패 시 다음 스프린트 확인
+          continue;
+        }
+      }
+    }
+
+    return null;
+  } catch {
+    // 디렉토리 접근 실패 시 null 반환
+    return null;
+  }
+}
+
+/**
+ * 스프린트 동기화 (Task 파일 상태 → meta.md)
+ * @param {string} sprintsDir
+ * @param {boolean} silent
+ */
+export async function syncSprint(sprintsDir, silent = false) {
+  try {
+    const activeSprint = findActiveSprint(sprintsDir);
+    if (!activeSprint) {
+      if (!silent) console.log(chalk.red('❌ 활성 스프린트가 없습니다.'));
+      return;
+    }
+
+    const sprintPath = path.join(sprintsDir, activeSprint);
+    const tasksDir = path.join(sprintPath, 'tasks');
+    const tasks = [];
+
+    if (fs.existsSync(tasksDir)) {
+      const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.md'));
+
+      for (const file of taskFiles) {
+        try {
+          const content = fs.readFileSync(path.join(tasksDir, file), 'utf-8');
+          const taskInfo = parseTaskMetadata(content, file);
+          tasks.push(taskInfo);
+        } catch {
+          // 개별 Task 파일 읽기 실패 시 건너뛰기
+          if (!silent) console.log(chalk.yellow(`   ⚠️ Task 파일 읽기 실패: ${file}`));
+        }
+      }
+    }
+
+    // meta.md 업데이트
+    updateSprintMeta(sprintPath, tasks);
+
+    if (!silent) {
+      console.log(chalk.green(`✅ ${activeSprint} 메타데이터 동기화 완료`));
+      console.log(chalk.gray(`   총 ${tasks.length}개 Task 상태 반영됨`));
+    }
+  } catch (err) {
+    // 동기화 실패해도 호출자의 루프는 계속 진행되도록 함
+    if (!silent) {
+      console.log(chalk.yellow(`   ⚠️ 스프린트 상태 동기화 실패: ${err.message}`));
+    }
+  }
+}
+
+/**
+ * sprint meta.md 업데이트
+ * @param {string} sprintPath 
+ * @param {Array} tasks 
+ */
+export function updateSprintMeta(sprintPath, tasks) {
+  const metaPath = path.join(sprintPath, 'meta.md');
+  if (!fs.existsSync(metaPath)) return;
+  
+  let metaContent = fs.readFileSync(metaPath, 'utf-8');
+
+  // Task 목록/요약 섹션 찾기
+  // 기존 정규식이 좀 약할 수 있으므로 보완
+  const taskSectionRegex = /## Task (?:목록|요약)\s*\n[\s\S]*?\n\n(?=##|$)|## Task (?:목록|요약)\s*\n[\s\S]*?$/;
+  const taskSectionTitle = metaContent.includes('## Task 요약') ? '## Task 요약' : '## Task 목록';
+
+  // 새로운 Task 목록 생성
+  let taskListContent = `${taskSectionTitle}\n\n`;
+  taskListContent += '| Task | 제목 | 상태 | 우선순위 | 크기 |\n';
+  taskListContent += '|------|------|:----:|:--------:|:----:|\n';
+
+  for (const task of tasks) {
+    taskListContent += `| ${task.id} | ${task.title} | ${task.status} | ${task.priority} | ${task.size} |\n`;
+  }
+
+  taskListContent += '\n';
+
+  // 기존 Task 목록 섹션 교체
+  if (metaContent.match(/## Task 목록/)) {
+    // 섹션이 존재하면 교체
+    // 단순히 replace를 쓰면 첫번째 매칭만 되는데, 정규식을 잘 썼으므로 괜찮음.
+    // 다만 섹션 뒤에 아무것도 없는 경우를 대비해 regex를 위에서 수정함.
+    metaContent = metaContent.replace(taskSectionRegex, taskListContent);
+  } else {
+    // Task 목록 섹션이 없으면 '## 참고' 섹션 앞이나 파일 끝에 추가
+    if (metaContent.includes('## 참고')) {
+      metaContent = metaContent.replace(/## 참고/, taskListContent + '## 참고');
+    } else {
+      metaContent += '\n' + taskListContent;
+    }
+  }
+
+  fs.writeFileSync(metaPath, metaContent);
+}

package/src/utils/taskParser.js

@@ -0,0 +1,134 @@
+import path from 'path';
+
+/**
+ * Task 파일(.md) 내용을 파싱하여 메타데이터 객체를 반환합니다.
+ * @param {string} content - 파일 내용
+ * @param {string} filename - 파일 이름 (예: task-001.md)
+ * @returns {object} 파싱된 Task 정보
+ */
+export function parseTaskMetadata(content, filename) {
+  const lines = content.split('\n');
+
+  // 1. ID 및 제목 파싱 (첫 줄: # TASK-NNN: [Task 이름])
+  // 파일명에서 ID 추출을 우선 시도 (파일명이 더 신뢰도 높음)
+  let id = filename ? path.basename(filename, '.md') : '';
+  
+  // 제목 줄 파싱
+  const titleLine = lines.find(line => line.startsWith('# '));
+  let title = '제목 없음';
+  
+  if (titleLine) {
+    // "# TASK-001: 제목" 형태인 경우
+    const match = titleLine.match(/^#\s*(TASK-\d+)?[:\s]*\s*(.+)$/i);
+    if (match) {
+      if (!id && match[1]) id = match[1]; // 파일명이 없으면 제목에서 ID 추출
+      title = match[2].trim();
+    } else {
+      title = titleLine.replace(/^#\s*/, '').trim();
+    }
+  }
+
+  if (!id) id = 'unknown';
+
+  // 2. 메타 테이블 파싱 (| 항목 | 값 |)
+  const status = parseTableValue(content, ['상태', 'Status'], null) ??
+    parseInlineValue(content, ['상태', 'Status']) ?? 'BACKLOG';
+  const priority = parseTableValue(content, ['우선순위', 'Priority'], null) ??
+    parseInlineValue(content, ['우선순위', 'Priority']) ?? 'P2';
+  const size = parseTableValue(content, ['크기', 'Size'], null) ??
+    parseInlineValue(content, ['크기', 'Size']) ?? 'M';
+  const assignee = parseTableValue(content, ['담당', 'Assignee'], null) ??
+    parseInlineValue(content, ['담당', 'Assignee']) ?? '-';
+
+  // 3. Status Normalize
+  const normalizedStatus = normalizeTaskStatus(status);
+
+  // 4. 추가 정보 (리뷰 리포트 존재 여부 추론 등)
+  const hasReviewReport = content.includes('## Review') ||
+                         content.includes('리뷰 결과');
+
+  return {
+    id,
+    title,
+    status: normalizedStatus,
+    priority,
+    size,
+    assignee,
+    hasReviewReport
+  };
+}
+
+/**
+ * Task 상태값 정규화
+ * @param {string} status 
+ */
+export function normalizeTaskStatus(status) {
+  if (!status) return 'UNKNOWN';
+  const upper = status.toString().toUpperCase().trim().replace(/[\s-]+/g, '_');
+  
+  // 별칭 처리
+  if (['IN_PROGRESS', 'PROCESSING', 'DOING', 'DEV', 'ACTIVE'].includes(upper)) return 'IN_DEV';
+  if (['IN_REVIEW', 'REVIEW', 'CODE_REVIEW', 'REVIEWING'].includes(upper)) return 'IN_REVIEW';
+  if (['IN_QA', 'QA', 'TEST', 'TESTING'].includes(upper)) return 'IN_REVIEW';
+  if (['BLOCKED', 'BLOCK', 'ON_HOLD', 'HOLD'].includes(upper)) return 'BLOCKED';
+  if (['COMPLETED', 'FINISH', 'FINISHED', 'COMPLETE'].includes(upper)) return 'DONE';
+  if (['REJECTED', 'DENIED'].includes(upper)) return 'REJECT';
+  
+  return upper;
+}
+
+/**
+ * 마크다운 테이블에서 특정 키의 값을 추출
+ * @param {string} content 
+ * @param {string} key 
+ * @param {string} defaultValue 
+ */
+function parseTableValue(content, key, defaultValue) {
+  // 예: | 상태 | BACKLOG / ... |
+  // 공백 유연하게 대응
+  const keys = Array.isArray(key) ? key : [key];
+  for (const keyItem of keys) {
+    const escapedKey = escapeRegExp(keyItem);
+    const regex = new RegExp(`\\|\\s*${escapedKey}\\s*\\|\\s*([^\\|]+)\\s*\\|`, 'i');
+    const match = content.match(regex);
+
+    if (match) {
+      // "BACKLOG / IN_DEV" 처럼 슬래시로 옵션이 나열된 경우 첫 번째 값 사용
+      // 또는 단순히 값이 하나만 있는 경우
+      // 템플릿 값("BACKLOG / ...")이 그대로 남아있으면 첫번째 값(BACKLOG) 선택
+      let val = match[1].trim();
+      if (val.includes('/')) {
+          // "BACKLOG / IN_DEV" 형태라면 현재 선택된 값이 무엇인지 모호할 수 있음.
+          // 하지만 보통 사람이 편집할 때 나머지를 지우거나, 
+          // 템플릿 상태라면 첫번째가 기본값이라고 가정.
+          // 만약 사용자가 "DONE"만 남겼다면 "/"가 없음.
+          val = val.split('/')[0].trim();
+      }
+      return val;
+    }
+  }
+  
+  return defaultValue;
+}
+
+/**
+ * 인라인 형식 (예: Status: DONE) 값 추출
+ * @param {string} content
+ * @param {string|string[]} key
+ */
+function parseInlineValue(content, key) {
+  const keys = Array.isArray(key) ? key : [key];
+  for (const keyItem of keys) {
+    const escapedKey = escapeRegExp(keyItem);
+    const regex = new RegExp(`^\\s*${escapedKey}\\s*:\\s*(.+)$`, 'mi');
+    const match = content.match(regex);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+  return null;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/utils/taskParser.test.js

@@ -0,0 +1,76 @@
+import test from 'node:test';
+import assert from 'node:assert';
+import { parseTaskMetadata } from './taskParser.js';
+
+test('parseTaskMetadata - 표준 포맷 파싱', (t) => {
+  const content = `
+# TASK-001: 로그인 기능
+
+| 항목 | 값 |
+|------|-----|
+| 상태 | IN_DEV |
+| 우선순위 | P1 |
+| 크기 | M |
+| 담당 | developer |
+
+## 내용
+...
+`;
+  const result = parseTaskMetadata(content, 'task-001.md');
+  
+  assert.strictEqual(result.id, 'task-001');
+  assert.strictEqual(result.title, '로그인 기능');
+  assert.strictEqual(result.status, 'IN_DEV');
+  assert.strictEqual(result.priority, 'P1');
+  assert.strictEqual(result.size, 'M');
+  assert.strictEqual(result.assignee, 'developer');
+});
+
+test('parseTaskMetadata - 템플릿 값 잔존 (선택지 포함)', (t) => {
+  const content = `
+| 상태 | DONE / REJECTED |
+`;
+  // "DONE / REJECTED" 처럼 되어 있으면 첫 번째 값인 DONE을 가져와야 함 (일반적인 AI 수정 패턴)
+  // 하지만 유틸리티 구현상 split('/')[0]을 하므로 DONE이 됨.
+  const result = parseTaskMetadata(content, 'task-002.md');
+  assert.strictEqual(result.status, 'DONE');
+});
+
+test('parseTaskMetadata - 제목 파싱 변형', (t) => {
+  // # TASK-NNN 없이 그냥 # 제목 인 경우
+  const content = `# 회원가입 API 구현`;
+  const result = parseTaskMetadata(content, 'task-003.md');
+  assert.strictEqual(result.title, '회원가입 API 구현');
+  assert.strictEqual(result.id, 'task-003'); // 파일명에서 추출
+});
+
+test('parseTaskMetadata - 공백 불규칙 허용', (t) => {
+  const content = `
+|상태|  DONE  |
+|  우선순위|P0|
+`;
+  const result = parseTaskMetadata(content, 'task-004.md');
+  assert.strictEqual(result.status, 'DONE');
+  assert.strictEqual(result.priority, 'P0');
+});
+
+test('parseTaskMetadata - 영문 키 지원 여부 확인', (t) => {
+  // AI가 실수로 영문 템플릿을 사용하거나 영문으로 바꾼 경우
+  const content = `
+| Status | IN_DEV |
+| Priority | P2 |
+`;
+  const result = parseTaskMetadata(content, 'task-005.md');
+
+  assert.strictEqual(result.status, 'IN_DEV');
+  assert.strictEqual(result.priority, 'P2');
+});
+
+test('parseTaskMetadata - 리뷰 리포트 존재 감지', (t) => {
+  const content = `
+## Review
+- PASS
+`;
+  const result = parseTaskMetadata(content, 'task-006.md');
+  assert.strictEqual(result.hasReviewReport, true);
+});

package/ai-dev-team/artifacts/features/_template/qa.md

@@ -1,16 +0,0 @@
-# Feature QA: [Feature명]
-
-## Task별 QA
-
-### TASK-001
-
-| 항목 | 값 |
-|------|-----|
-| 결과 | PASS / FAIL |
-| QA 담당 | - |
-| 일시 | YYYY-MM-DD |
-
-**테스트 결과:**
-| TC | 결과 |
-|----|:----:|
-| TC-001 | ✓/✗ |

package/examples/todo-app/README.md

@@ -1,23 +0,0 @@
-# 예제: Todo App 프로젝트
-
-> Artifact-Driven AI Agent Framework 예제
-
-## 프로젝트 개요
-
-- **규모**: S (Small)
-- **기간**: 1주일
-- **상태**: ✅ 완료
-
-## 워크플로우
-
-1. Planner: plan.md 작성 → Confirmed
-2. Architect: project.md 작성 → Frozen
-3. Manager: 스프린트 시작
-4. Developer/Reviewer/QA: Task 완료
-5. Manager: 스프린트 종료
-
-## 산출물
-
-- `artifacts/plan.md` - 기획서
-- `artifacts/project.md` - 기술 기준
-- `artifacts/backlog.md` - Task 목록

package/examples/todo-app/artifacts/backlog.md

@@ -1,23 +0,0 @@
-# Backlog
-
-> DONE: 5개
-
-## ~~TASK-001: 데이터 모델~~ ✅
-- 상태: DONE
-- 크기: S
-
-## ~~TASK-002: 추가 기능~~ ✅
-- 상태: DONE
-- 크기: M
-
-## ~~TASK-003: 삭제 기능~~ ✅
-- 상태: DONE
-- 크기: S
-
-## ~~TASK-004: 완료 토글~~ ✅
-- 상태: DONE
-- 크기: S
-
-## ~~TASK-005: 필터~~ ✅
-- 상태: DONE
-- 크기: M