docuking-mcp 1.0.0 → 1.1.0

package/index.js

@@ -243,6 +243,102 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ['localPath', 'commitId'],
         },
       },
+      {
+        name: 'docuking_talk',
+        description: '의미 있는 대화 내용을 자동으로 z_Talk/ 폴더에 기록합니다. AI가 중요한 논의/결정이라고 판단하거나, 사용자가 "이거 기록해줘"라고 요청할 때 사용.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            localPath: {
+              type: 'string',
+              description: '로컬 프로젝트 경로',
+            },
+            title: {
+              type: 'string',
+              description: '대화록 제목 (예: "인증 방식 결정", "API 설계 논의")',
+            },
+            content: {
+              type: 'string',
+              description: '대화 내용 요약 (마크다운 형식)',
+            },
+            tags: {
+              type: 'array',
+              items: { type: 'string' },
+              description: '태그 목록 (예: ["설계", "결정", "API"])',
+            },
+          },
+          required: ['localPath', 'title', 'content'],
+        },
+      },
+      {
+        name: 'docuking_plan',
+        description: '작업 계획 문서를 z_PlanToResult/ 폴더에 생성하거나 업데이트합니다. 작업 시작 시 계획을 작성하고, 진행하면서 결과를 upsert합니다.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            localPath: {
+              type: 'string',
+              description: '로컬 프로젝트 경로',
+            },
+            planId: {
+              type: 'string',
+              description: '계획 ID (기존 계획 업데이트 시 사용, 생략하면 새 계획 생성)',
+            },
+            title: {
+              type: 'string',
+              description: '작업 제목 (예: "MCP 활동 로깅 구현")',
+            },
+            goal: {
+              type: 'string',
+              description: '작업 목표',
+            },
+            steps: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string', description: '단계 이름' },
+                  status: { type: 'string', enum: ['pending', 'in_progress', 'done'], description: '상태' },
+                  result: { type: 'string', description: '결과 (완료 시)' },
+                },
+              },
+              description: '작업 단계 목록',
+            },
+            notes: {
+              type: 'string',
+              description: '추가 노트/메모',
+            },
+          },
+          required: ['localPath', 'title'],
+        },
+      },
+      {
+        name: 'docuking_done',
+        description: '작업 계획을 완료 상태로 변경하고 최종 결과를 기록합니다.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            localPath: {
+              type: 'string',
+              description: '로컬 프로젝트 경로',
+            },
+            planId: {
+              type: 'string',
+              description: '완료할 계획 ID',
+            },
+            summary: {
+              type: 'string',
+              description: '작업 완료 요약',
+            },
+            artifacts: {
+              type: 'array',
+              items: { type: 'string' },
+              description: '산출물 목록 (파일 경로, URL 등)',
+            },
+          },
+          required: ['localPath', 'planId', 'summary'],
+        },
+      },
     ],
   };
 });
@@ -327,6 +423,22 @@ DocuKing은 문서 버전 관리 시스템입니다. Git이 코드를 관리하
 ### 8. docuking_rollback
 특정 커밋으로 되돌립니다. (웹 탐색기에서 사용 가능)
 
+### 9. docuking_talk
+의미 있는 대화 내용을 \`z_Talk/\` 폴더에 자동 기록합니다.
+- AI가 중요한 논의/결정이라고 판단할 때
+- 사용자가 "이거 기록해줘"라고 요청할 때
+
+### 10. docuking_plan
+작업 계획을 \`z_PlanToResult/\` 폴더에 생성/업데이트합니다.
+- 작업 시작 시 계획 생성
+- 진행하면서 단계별 결과 upsert
+- planId로 기존 계획 찾아서 업데이트
+
+### 11. docuking_done
+작업 계획을 완료 상태로 변경합니다.
+- planId로 계획 찾기
+- 완료 요약 및 산출물 기록
+
 ## Git과의 유사성
 
 | DocuKing | Git | 설명 |
@@ -507,6 +619,83 @@ Push 완료! 총 10개 파일 중 3개 업로드, 6개 스킵(변경 없음), 1
 9. **재시작 최소화**: 이미 MCP가 작동 중이면 재시작 없이 바로 프로젝트 연결 진행
 10. **기존 설정 보호**: MCP 설정 시 기존 서버 설정을 덮어쓰지 말고 추가만
 
+### 대화록 자동 기록 (docuking_talk)
+
+**언제 사용하는가:**
+- 중요한 설계 결정이 내려졌을 때
+- 아키텍처나 정책에 대한 논의가 있었을 때
+- 사용자가 "이거 기록해줘", "이 대화 저장해줘"라고 요청할 때
+- 여러 선택지 중 하나를 결정한 이유를 남겨야 할 때
+
+**사용 예시:**
+\`\`\`
+사용자: "인증은 JWT로 하자. 세션은 관리가 복잡하니까"
+AI: (결정이 내려졌으므로 docuking_talk 호출)
+    docuking_talk({
+      localPath: "/current/path",
+      title: "인증 방식 결정 - JWT 선택",
+      content: "## 결정\\n인증 방식으로 JWT를 선택\\n\\n## 근거\\n- 세션 관리 복잡성 회피\\n- 무상태 아키텍처 선호",
+      tags: ["설계", "인증", "결정"]
+    })
+\`\`\`
+
+**저장 위치:** \`z_Talk/YYYY/MM/YYYY-MM-DD_HHMM__제목.md\`
+
+### 작업 계획 관리 (docuking_plan, docuking_done)
+
+**언제 사용하는가:**
+- 복잡한 작업을 시작할 때 (여러 단계가 필요한 작업)
+- 작업 진행 상황을 기록해야 할 때
+- 작업이 완료되었을 때
+
+**작업 흐름:**
+1. 작업 시작 → \`docuking_plan\` (새 계획 생성, planId 받음)
+2. 진행 중 → \`docuking_plan\` (planId로 업데이트)
+3. 작업 완료 → \`docuking_done\` (planId로 완료 처리)
+
+**사용 예시:**
+\`\`\`
+사용자: "MCP에 talk 기능 추가해줘"
+AI: (복잡한 작업이므로 docuking_plan 호출)
+    docuking_plan({
+      localPath: "/current/path",
+      title: "MCP talk 기능 구현",
+      goal: "대화 내용을 자동으로 문서화하는 기능 추가",
+      steps: [
+        { name: "도구 스키마 정의", status: "pending" },
+        { name: "핸들러 구현", status: "pending" },
+        { name: "테스트", status: "pending" }
+      ]
+    })
+    → planId: "abc12345" 받음
+
+(단계 완료 시)
+AI: docuking_plan({
+      localPath: "/current/path",
+      planId: "abc12345",
+      title: "MCP talk 기능 구현",
+      steps: [
+        { name: "도구 스키마 정의", status: "done", result: "index.js에 추가 완료" },
+        { name: "핸들러 구현", status: "in_progress" },
+        { name: "테스트", status: "pending" }
+      ]
+    })
+
+(작업 완료 시)
+AI: docuking_done({
+      localPath: "/current/path",
+      planId: "abc12345",
+      summary: "docuking_talk, docuking_plan, docuking_done 3개 도구 구현 완료",
+      artifacts: ["Docuking_mcp/index.js"]
+    })
+\`\`\`
+
+**저장 위치:** \`z_PlanToResult/YYYY/MM/YYYY-MM-DD_HHMM__제목__planId.md\`
+
+**핵심 가치:**
+- AI 세션이 끊겨도 (컴팩션, 세션 종료) 다음 AI가 계획 문서를 보고 이어서 작업 가능
+- "어디까지 했더라?"가 아니라 "계획 문서 보고 이어서 진행"
+
 ### MCP 설정 관련 (AI가 처리해야 할 경우)
 
 **사용자 요청 예시:**
@@ -640,6 +829,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return await handleDiff(args);
       case 'docuking_rollback':
         return await handleRollback(args);
+      case 'docuking_talk':
+        return await handleTalk(args);
+      case 'docuking_plan':
+        return await handlePlan(args);
+      case 'docuking_done':
+        return await handleDone(args);
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -1584,6 +1779,320 @@ async function handleRollback(args) {
   };
 }
 
+// 날짜 기반 파일명 생성 유틸
+function generateDateFileName(title) {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hour = String(now.getHours()).padStart(2, '0');
+  const minute = String(now.getMinutes()).padStart(2, '0');
+
+  // 제목에서 파일명으로 사용 가능한 slug 생성
+  const slug = title
+    .replace(/[^\w\s가-힣-]/g, '') // 특수문자 제거
+    .replace(/\s+/g, '_') // 공백을 언더스코어로
+    .substring(0, 50); // 50자 제한
+
+  return {
+    fileName: `${year}-${month}-${day}_${hour}${minute}__${slug}.md`,
+    yearMonth: `${year}/${month}`,
+    timestamp: `${year}-${month}-${day} ${hour}:${minute}`,
+  };
+}
+
+// 계획 ID 생성 (간단한 UUID-like)
+function generatePlanId() {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let id = '';
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return id;
+}
+
+// docuking_talk 구현 - 대화록 자동 저장
+async function handleTalk(args) {
+  const { localPath, title, content, tags = [] } = args;
+
+  // z_Talk 폴더 경로
+  const talkBasePath = path.join(localPath, 'z_Talk');
+
+  // 날짜 기반 파일명 생성
+  const { fileName, yearMonth, timestamp } = generateDateFileName(title);
+  const talkFolderPath = path.join(talkBasePath, yearMonth);
+  const talkFilePath = path.join(talkFolderPath, fileName);
+
+  // 폴더 생성
+  if (!fs.existsSync(talkFolderPath)) {
+    fs.mkdirSync(talkFolderPath, { recursive: true });
+  }
+
+  // 태그 문자열
+  const tagString = tags.length > 0 ? `\n태그: ${tags.map(t => `#${t}`).join(' ')}` : '';
+
+  // 마크다운 문서 생성
+  const document = `# ${title}
+
+> 기록 시간: ${timestamp}${tagString}
+
+---
+
+${content}
+
+---
+*이 문서는 AI와의 대화에서 자동 생성되었습니다.*
+`;
+
+  // 파일 저장
+  fs.writeFileSync(talkFilePath, document, 'utf-8');
+
+  const relativePath = path.relative(localPath, talkFilePath).replace(/\\/g, '/');
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `✓ 대화록 저장 완료!
+
+📝 제목: ${title}
+📁 경로: ${relativePath}
+🕐 시간: ${timestamp}${tags.length > 0 ? `\n🏷️  태그: ${tags.join(', ')}` : ''}
+
+💡 DocuKing에 Push하면 웹에서도 확인할 수 있습니다.`,
+      },
+    ],
+  };
+}
+
+// docuking_plan 구현 - 작업 계획 생성/업데이트
+async function handlePlan(args) {
+  const { localPath, planId, title, goal, steps = [], notes } = args;
+
+  // z_PlanToResult 폴더 경로
+  const planBasePath = path.join(localPath, 'z_PlanToResult');
+
+  // 기존 계획 업데이트 또는 새 계획 생성
+  let targetPlanId = planId;
+  let isNew = !planId;
+  let planFilePath;
+  let existingContent = null;
+
+  if (planId) {
+    // 기존 계획 찾기
+    const planFiles = findPlanFiles(planBasePath, planId);
+    if (planFiles.length === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `오류: planId '${planId}'에 해당하는 계획을 찾을 수 없습니다.`,
+          },
+        ],
+      };
+    }
+    planFilePath = planFiles[0];
+    existingContent = fs.readFileSync(planFilePath, 'utf-8');
+  } else {
+    // 새 계획 생성
+    targetPlanId = generatePlanId();
+    const { fileName, yearMonth, timestamp } = generateDateFileName(title);
+    const planFolderPath = path.join(planBasePath, yearMonth);
+
+    if (!fs.existsSync(planFolderPath)) {
+      fs.mkdirSync(planFolderPath, { recursive: true });
+    }
+
+    // 파일명에 planId 포함
+    const fileNameWithId = fileName.replace('.md', `__${targetPlanId}.md`);
+    planFilePath = path.join(planFolderPath, fileNameWithId);
+  }
+
+  // 현재 시간
+  const now = new Date();
+  const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+
+  // 단계 상태 문자열 생성
+  const stepsMarkdown = steps.length > 0
+    ? steps.map((step, i) => {
+        const statusIcon = step.status === 'done' ? '✅' : step.status === 'in_progress' ? '🔄' : '⬜';
+        const resultText = step.result ? ` → ${step.result}` : '';
+        return `${i + 1}. ${statusIcon} ${step.name}${resultText}`;
+      }).join('\n')
+    : '(단계 미정의)';
+
+  // 진행률 계산
+  const doneCount = steps.filter(s => s.status === 'done').length;
+  const totalCount = steps.length;
+  const progress = totalCount > 0 ? Math.round((doneCount / totalCount) * 100) : 0;
+
+  // 마크다운 문서 생성
+  let document;
+  if (isNew) {
+    document = `# ${title}
+
+> Plan ID: \`${targetPlanId}\`
+> 생성: ${timestamp}
+> 상태: 진행 중 (${progress}%)
+
+---
+
+## 목표
+${goal || '(목표 미정의)'}
+
+## 진행 단계
+${stepsMarkdown}
+
+## 노트
+${notes || '(없음)'}
+
+---
+
+## 진행 기록
+- ${timestamp}: 계획 생성
+
+---
+*이 문서는 AI 작업 계획에서 자동 생성되었습니다.*
+`;
+  } else {
+    // 기존 문서 업데이트 (진행 기록에 추가)
+    const updateEntry = `- ${timestamp}: 계획 업데이트 (진행률 ${progress}%)`;
+
+    // 기존 내용에서 섹션 업데이트
+    document = existingContent
+      .replace(/> 상태: .+/, `> 상태: 진행 중 (${progress}%)`)
+      .replace(/## 진행 단계\n[\s\S]*?(?=\n## )/, `## 진행 단계\n${stepsMarkdown}\n\n`)
+      .replace(/## 진행 기록\n/, `## 진행 기록\n${updateEntry}\n`);
+
+    if (notes) {
+      document = document.replace(/## 노트\n[\s\S]*?(?=\n---\n\n## 진행 기록)/, `## 노트\n${notes}\n\n`);
+    }
+  }
+
+  // 파일 저장
+  fs.writeFileSync(planFilePath, document, 'utf-8');
+
+  const relativePath = path.relative(localPath, planFilePath).replace(/\\/g, '/');
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `✓ 작업 계획 ${isNew ? '생성' : '업데이트'} 완료!
+
+📋 제목: ${title}
+🆔 Plan ID: ${targetPlanId}
+📁 경로: ${relativePath}
+📊 진행률: ${progress}% (${doneCount}/${totalCount})
+
+💡 이 planId를 기억해두세요. 나중에 업데이트하거나 완료 처리할 때 필요합니다.
+💡 DocuKing에 Push하면 웹에서도 확인할 수 있습니다.`,
+      },
+    ],
+  };
+}
+
+// 계획 파일 찾기 유틸
+function findPlanFiles(basePath, planId) {
+  const results = [];
+
+  if (!fs.existsSync(basePath)) {
+    return results;
+  }
+
+  function searchDir(dirPath) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        searchDir(fullPath);
+      } else if (entry.isFile() && entry.name.includes(`__${planId}.md`)) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  searchDir(basePath);
+  return results;
+}
+
+// docuking_done 구현 - 작업 완료 처리
+async function handleDone(args) {
+  const { localPath, planId, summary, artifacts = [] } = args;
+
+  // z_PlanToResult 폴더 경로
+  const planBasePath = path.join(localPath, 'z_PlanToResult');
+
+  // 계획 파일 찾기
+  const planFiles = findPlanFiles(planBasePath, planId);
+  if (planFiles.length === 0) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `오류: planId '${planId}'에 해당하는 계획을 찾을 수 없습니다.`,
+        },
+      ],
+    };
+  }
+
+  const planFilePath = planFiles[0];
+  let content = fs.readFileSync(planFilePath, 'utf-8');
+
+  // 현재 시간
+  const now = new Date();
+  const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+
+  // 산출물 목록
+  const artifactsMarkdown = artifacts.length > 0
+    ? artifacts.map(a => `- ${a}`).join('\n')
+    : '(없음)';
+
+  // 완료 섹션 추가
+  const completionSection = `
+
+## ✅ 완료
+> 완료 시간: ${timestamp}
+
+### 요약
+${summary}
+
+### 산출물
+${artifactsMarkdown}
+`;
+
+  // 상태 업데이트 및 완료 섹션 추가
+  content = content
+    .replace(/> 상태: .+/, `> 상태: ✅ 완료`)
+    .replace(/---\n\*이 문서는 AI 작업 계획에서 자동 생성되었습니다.\*/, `${completionSection}\n---\n*이 문서는 AI 작업 계획에서 자동 생성되었습니다.*`);
+
+  // 진행 기록에 완료 추가
+  content = content.replace(/## 진행 기록\n/, `## 진행 기록\n- ${timestamp}: ✅ 작업 완료\n`);
+
+  // 파일 저장
+  fs.writeFileSync(planFilePath, content, 'utf-8');
+
+  const relativePath = path.relative(localPath, planFilePath).replace(/\\/g, '/');
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `✅ 작업 완료 처리됨!
+
+🆔 Plan ID: ${planId}
+📁 경로: ${relativePath}
+🕐 완료 시간: ${timestamp}
+
+📝 요약: ${summary}
+${artifacts.length > 0 ? `📦 산출물: ${artifacts.length}개` : ''}
+
+💡 DocuKing에 Push하면 웹에서 완료된 작업을 확인할 수 있습니다.`,
+      },
+    ],
+  };
+}
+
 // 서버 시작
 async function main() {
   const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docuking-mcp",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "DocuKing MCP Server - AI 시대의 문서 협업 플랫폼",
   "type": "module",
   "main": "index.js",