docuking-mcp 1.8.0 → 1.9.1

package/index.js

@@ -508,7 +508,26 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: 'docuking_todo',
-        description: '할일을 z_DocuKing/z_Todo/z_Todo.md 파일에 추가하거나 완료 표시합니다. 단일 파일에 계속 누적되어 전체 작업 히스토리가 됩니다. 논의 후 할일이 생기면 바로 등록하세요.',
+        description: `킹투두(King Todo) - 프로젝트 공식 할일을 z_DocuKing/z_King_Todo/z_King_Todo.md에 관리합니다.
+
+**AI 내장 TodoWrite와 다름!** 킹투두는 웹에 동기화되고 팀과 공유됩니다.
+
+**작성 형식:**
+\`\`\`
+1. ✅ **[태그] 키워드** 12.30/12.30
+       설명 (7칸 들여쓰기)
+
+2. ⚙️ **[태그] 키워드** 12.30
+       설명
+\`\`\`
+
+**형식 규칙:**
+- ✅ 완료 / ⚙️ 진행중
+- **[태그] 키워드** 볼드 처리
+- 날짜 1개 = 등록일(진행중), 2개 = 등록일/완료일(완료)
+- 설명은 7칸 들여쓰기 ([ 기호 아래 정렬)
+
+**사용자에게 "킹투두에 등록했습니다" 형식으로 보고하세요.**`,
         inputSchema: {
           type: 'object',
           properties: {
@@ -523,7 +542,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             todo: {
               type: 'string',
-              description: '할일 내용 (add 시 필수)',
+              description: '할일 내용 (add 시 필수). 형식: "[태그] 키워드 - 설명" 예: "[보안] API 인증 강화 - JWT 토큰 검증"',
             },
             todoId: {
               type: 'number',
@@ -1318,11 +1337,13 @@ docuking_init을 먼저 실행하세요.`,
     console.error('[DocuKing] Sync 시작 알림 실패:', e.message);
   }
 
-  // 서버에서 파일 해시 조회 (변경 감지용)
-  let serverFileHashes = {};
+  // 서버에서 파일 해시 조회 (Git 스타일 동기화용)
+  let serverPathToHash = {};
+  let serverHashToPath = {};
+  let serverAllPaths = [];
   try {
     const hashResponse = await fetch(
-      `${API_ENDPOINT}/files/hashes?projectId=${projectId}`,
+      `${API_ENDPOINT}/files/hashes-for-sync?projectId=${projectId}`,
       {
         headers: {
           'Authorization': `Bearer ${apiKey}`,
@@ -1331,16 +1352,23 @@ docuking_init을 먼저 실행하세요.`,
     );
     if (hashResponse.ok) {
       const hashData = await hashResponse.json();
-      serverFileHashes = hashData.hashes || {};
+      serverPathToHash = hashData.pathToHash || {};
+      serverHashToPath = hashData.hashToPath || {};
+      serverAllPaths = hashData.allPaths || [];
     }
   } catch (e) {
     // 해시 조회 실패는 무시 (처음 Push하는 경우 등)
     console.error('[DocuKing] 파일 해시 조회 실패:', e.message);
   }
 
+  // 처리된 로컬 파일 경로 (서버 삭제용)
+  const processedLocalPaths = new Set();
+  let moved = 0;
+
   for (const file of filesToPush) {
     current++;
     const progress = `${current}/${total}`;
+    processedLocalPaths.add(file.serverPath);
 
     try {
       // 파일 해시 계산 (변경 감지)
@@ -1360,15 +1388,50 @@ docuking_init을 먼저 실행하세요.`,
         fileHash = crypto.createHash('sha256').update(content, 'utf-8').digest('hex');
       }
 
-      // 변경 감지: 서버에 같은 해시가 있으면 스킵
-      if (serverFileHashes[file.path] === fileHash) {
-        const resultText = `${progress} ⊘ ${file.path} (변경 없음)`;
+      // Git 스타일 동기화:
+      // 1. 같은 경로 + 같은 해시 → 스킵 (변경 없음)
+      if (serverPathToHash[file.serverPath] === fileHash) {
+        const resultText = `${progress} ⊘ ${file.serverPath} (변경 없음)`;
         results.push(resultText);
         console.log(resultText);
         skipped++;
         continue;
       }
 
+      // 2. 같은 해시가 다른 경로에 있음 → Move (경로 변경)
+      const existingPath = serverHashToPath[fileHash];
+      if (existingPath && existingPath !== file.serverPath) {
+        try {
+          const moveResponse = await fetch(`${API_ENDPOINT}/files/move`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+              projectId,
+              oldPath: existingPath,
+              newPath: file.serverPath,
+            }),
+          });
+
+          if (moveResponse.ok) {
+            const resultText = `${progress} ↷ ${existingPath} → ${file.serverPath}`;
+            results.push(resultText);
+            console.log(resultText);
+            moved++;
+            // 이동된 파일의 해시 맵 업데이트
+            delete serverHashToPath[fileHash];
+            serverHashToPath[fileHash] = file.serverPath;
+            continue;
+          }
+        } catch (e) {
+          console.error(`[DocuKing] Move 실패: ${e.message}, Upload로 대체`);
+        }
+      }
+
+      // 3. 새 파일 또는 내용 변경 → Upload
+
       // 재시도 로직 (최대 3회)
       let lastError = null;
       let success = false;
@@ -1467,6 +1530,41 @@ docuking_init을 먼저 실행하세요.`,
     }
   }
 
+  // 4. 서버에만 있고 로컬에 없는 파일 삭제 (Git rm과 동일)
+  let deleted = 0;
+  const deletedFiles = [];
+  if (serverAllPaths.length > 0 && !isCoworker) {
+    // 코워커가 아닌 경우에만 삭제 수행 (오너 전용)
+    const pathsToDelete = serverAllPaths.filter(p => !processedLocalPaths.has(p));
+
+    if (pathsToDelete.length > 0) {
+      console.log(`[DocuKing] 서버에만 있는 파일 ${pathsToDelete.length}개 삭제 중...`);
+
+      try {
+        const deleteResponse = await fetch(`${API_ENDPOINT}/files/delete-batch`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+          },
+          body: JSON.stringify({
+            projectId,
+            paths: pathsToDelete,
+          }),
+        });
+
+        if (deleteResponse.ok) {
+          const deleteResult = await deleteResponse.json();
+          deleted = deleteResult.deleted || 0;
+          deletedFiles.push(...pathsToDelete.slice(0, deleted));
+          console.log(`[DocuKing] ${deleted}개 파일 삭제 완료`);
+        }
+      } catch (e) {
+        console.error('[DocuKing] 파일 삭제 실패:', e.message);
+      }
+    }
+  }
+
   // Sync 완료 알림
   try {
     await fetch(`${API_ENDPOINT}/projects/${projectId}/sync/complete`, {
@@ -1484,9 +1582,10 @@ docuking_init을 먼저 실행하세요.`,
   const failCount = results.filter(r => r.includes('✗')).length;
   const skippedCount = skipped; // 이미 계산된 스킵 개수 사용
   const excludedCount = excludedFiles.length;
+  const movedCount = moved;
 
   // 요약 정보
-  let summary = `\n📦 커밋 메시지: "${message}"\n\n📊 처리 결과:\n   - 총 파일: ${total}개\n   - 업로드: ${successCount}개\n   - 스킵 (변경 없음): ${skippedCount}개\n   - 실패: ${failCount}개`;
+  let summary = `\n📦 커밋 메시지: "${message}"\n\n📊 처리 결과:\n   - 총 파일: ${total}개\n   - 업로드: ${successCount}개\n   - 이동: ${movedCount}개\n   - 삭제: ${deleted}개\n   - 스킵 (변경 없음): ${skippedCount}개\n   - 실패: ${failCount}개`;
   if (excludedCount > 0) {
     summary += `\n   - 제외 (압축/설치파일): ${excludedCount}개`;
   }
@@ -1500,6 +1599,20 @@ docuking_init을 먼저 실행하세요.`,
     resultText += `\n\n📤 업로드된 파일 (${successCount}개):\n${uploadedFiles.map(r => `   ${r.replace(/^\d+\/\d+ /, '')}`).join('\n')}`;
   }
 
+  // 이동된 파일이 있으면 표시 (Git 스타일)
+  if (movedCount > 0) {
+    const movedFiles = results.filter(r => r.includes('↷'));
+    resultText += `\n\n↷ 이동된 파일 (${movedCount}개):\n${movedFiles.map(r => `   ${r.replace(/^\d+\/\d+ /, '')}`).join('\n')}`;
+  }
+
+  // 삭제된 파일이 있으면 표시 (Git 스타일)
+  if (deleted > 0) {
+    resultText += `\n\n🗑️ 삭제된 파일 (${deleted}개, 로컬에 없음):\n${deletedFiles.slice(0, 20).map(f => `   ✗ ${f}`).join('\n')}`;
+    if (deleted > 20) {
+      resultText += `\n   ... 외 ${deleted - 20}개`;
+    }
+  }
+
   // 스킵된 파일이 있으면 표시
   if (skippedCount > 0) {
     const skippedFiles = results.filter(r => r.includes('⊘'));
@@ -1829,10 +1942,15 @@ function getFileType(fileName) {
 }
 
 // 유틸: DocuKing 폴더 찾기 (docuking 포함, 대소문자 무관)
+// .docuking (설정 폴더)는 제외
 function findDocuKingFolder(projectPath) {
   try {
     const entries = fs.readdirSync(projectPath, { withFileTypes: true });
     for (const entry of entries) {
+      // .docuking은 설정 폴더이므로 제외 (숨김 폴더)
+      if (entry.name.startsWith('.')) {
+        continue;
+      }
       if (entry.isDirectory() && entry.name.toLowerCase().includes('docuking')) {
         return entry.name;
       }
@@ -2122,13 +2240,13 @@ function generatePlanId() {
   return id;
 }
 
-// docuking_todo 구현 - 할일 추가/완료/조회 (단일 파일 누적)
+// docuking_todo 구현 - 킹투두 (단일 파일 누적)
 async function handleTodo(args) {
   const { localPath, action, todo, todoId } = args;
 
-  // z_Todo 폴더 경로
-  const todoBasePath = path.join(localPath, 'z_DocuKing', 'z_Todo');
-  const todoFilePath = path.join(todoBasePath, 'z_Todo.md');
+  // z_King_Todo 폴더 경로
+  const todoBasePath = path.join(localPath, 'z_DocuKing', 'z_King_Todo');
+  const todoFilePath = path.join(todoBasePath, 'z_King_Todo.md');
 
   // 폴더 생성
   if (!fs.existsSync(todoBasePath)) {
@@ -2139,8 +2257,7 @@ async function handleTodo(args) {
   if (!fs.existsSync(todoFilePath)) {
     const header = `# TODO 목록
 
-> 이 파일은 모든 할일을 누적 기록합니다.
-> - [ ] 미완료 / - [x] 완료 (완료 시 날짜 추가)
+> 날짜 1개 = 등록일 (진행중) / 날짜 2개 = 등록일/완료일 (완료)
 
 ---
 
@@ -2161,8 +2278,9 @@ async function handleTodo(args) {
   }
 
   const now = new Date();
-  const dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
-  const timeStr = `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const dateStr = `${month}.${day}`;
 
   if (action === 'add') {
     if (!todo) {
@@ -2172,7 +2290,39 @@ async function handleTodo(args) {
     }
 
     const newId = maxId + 1;
-    const newTodo = `${newId}. - [ ] ${todo} (${dateStr})\n`;
+
+    // todo에서 태그와 키워드, 설명 분리
+    // 형식: "[태그] 키워드 - 설명" 또는 "[태그] 키워드"
+    let tag = '';
+    let keyword = '';
+    let description = '';
+
+    const tagMatch = todo.match(/^\[([^\]]+)\]\s*/);
+    if (tagMatch) {
+      tag = tagMatch[1];
+      const rest = todo.slice(tagMatch[0].length);
+      const descSplit = rest.split(/\s*[-–]\s*/);
+      keyword = descSplit[0].trim();
+      description = descSplit.slice(1).join(' - ').trim();
+    } else {
+      // 태그 없이 입력된 경우
+      const descSplit = todo.split(/\s*[-–]\s*/);
+      keyword = descSplit[0].trim();
+      description = descSplit.slice(1).join(' - ').trim();
+    }
+
+    // 킹투두 형식으로 작성
+    let newTodo;
+    if (tag) {
+      newTodo = `${newId}. ⚙️ **[${tag}] ${keyword}** ${dateStr}\n`;
+    } else {
+      newTodo = `${newId}. ⚙️ **${keyword}** ${dateStr}\n`;
+    }
+
+    if (description) {
+      newTodo += `       ${description}\n`;
+    }
+    newTodo += '\n';
 
     // 파일 끝에 추가
     fs.appendFileSync(todoFilePath, newTodo, 'utf-8');
@@ -2180,10 +2330,10 @@ async function handleTodo(args) {
     return {
       content: [{
         type: 'text',
-        text: `✓ TODO 추가 완료!
+        text: `✓ 킹투두에 등록했습니다!
 
-📝 #${newId}: ${todo}
-📅 등록: ${dateStr} ${timeStr}
+📝 #${newId}: ${tag ? `[${tag}] ` : ''}${keyword}${description ? ` - ${description}` : ''}
+📅 등록: ${dateStr}
 
 💡 완료 시: docuking_todo(action: "done", todoId: ${newId})`,
       }],
@@ -2197,73 +2347,81 @@ async function handleTodo(args) {
       };
     }
 
-    // 해당 번호의 TODO 찾아서 완료 표시
-    const todoLinePattern = new RegExp(`^(${todoId}\\. - \\[)( )(\\].*)$`, 'm');
+    // 해당 번호의 TODO 찾아서 ⚙️ -> ✅ 변경 및 날짜 추가
+    const todoLinePattern = new RegExp(`^(${todoId}\\. )⚙️( \\*\\*.*\\*\\* )(\\d+\\.\\d+)(.*)$`, 'm');
     const matched = content.match(todoLinePattern);
 
     if (!matched) {
+      // 이미 완료된 항목인지 확인
+      const completedPattern = new RegExp(`^${todoId}\\. ✅`, 'm');
+      if (completedPattern.test(content)) {
+        return {
+          content: [{ type: 'text', text: `킹투두 #${todoId}는 이미 완료 상태입니다.` }],
+        };
+      }
       return {
-        content: [{ type: 'text', text: `오류: TODO #${todoId}를 찾을 수 없습니다.` }],
+        content: [{ type: 'text', text: `오류: 킹투두 #${todoId}를 찾을 수 없습니다.` }],
       };
     }
 
-    // [ ] -> [x] 변경 + 완료 날짜 추가
+    // ⚙️ -> ✅ 변경 + 완료 날짜 추가 (등록일/완료일)
     const updatedContent = content.replace(
       todoLinePattern,
-      `$1x$3 ✓${dateStr}`
+      `$1✅$2$3/${dateStr}$4`
     );
 
     fs.writeFileSync(todoFilePath, updatedContent, 'utf-8');
 
     // 완료된 TODO 내용 추출
-    const todoContent = matched[0].replace(/^\d+\. - \[ \] /, '').replace(/ \(\d{4}-\d{2}-\d{2}\)$/, '');
+    const keywordMatch = matched[2].match(/\*\*(.+)\*\*/);
+    const todoKeyword = keywordMatch ? keywordMatch[1] : '';
 
     return {
       content: [{
         type: 'text',
-        text: `✓ TODO #${todoId} 완료!
+        text: `✓ 킹투두 #${todoId} 완료!
 
-✅ ${todoContent}
-📅 완료: ${dateStr} ${timeStr}`,
+✅ ${todoKeyword}
+📅 완료: ${dateStr}`,
       }],
     };
   }
 
   if (action === 'list') {
-    // 미완료 TODO만 추출
-    const pendingPattern = /^(\d+)\. - \[ \] (.+)$/gm;
+    // 미완료(⚙️) TODO 추출
+    const pendingPattern = /^(\d+)\. ⚙️ \*\*(.+)\*\* (\d+\.\d+)/gm;
     const pendingTodos = [];
     let listMatch;
     while ((listMatch = pendingPattern.exec(content)) !== null) {
-      pendingTodos.push({ id: listMatch[1], content: listMatch[2] });
+      pendingTodos.push({ id: listMatch[1], keyword: listMatch[2], date: listMatch[3] });
     }
 
-    // 완료된 TODO 수 세기
-    const completedCount = (content.match(/- \[x\]/g) || []).length;
+    // 완료된(✅) TODO 수 세기
+    const completedCount = (content.match(/^(\d+)\. ✅/gm) || []).length;
 
     if (pendingTodos.length === 0) {
       return {
         content: [{
           type: 'text',
-          text: `📋 미완료 TODO: 없음
+          text: `📋 킹투두 미결: 없음
 
-✅ 완료된 TODO: ${completedCount}개
-📁 전체 기록: z_DocuKing/z_Todo/z_Todo.md`,
+✅ 완료: ${completedCount}개
+📁 전체 기록: z_DocuKing/z_King_Todo/z_King_Todo.md`,
         }],
       };
     }
 
-    const listText = pendingTodos.map(t => `  #${t.id}: ${t.content}`).join('\n');
+    const listText = pendingTodos.map(t => `  #${t.id}: ${t.keyword} (${t.date})`).join('\n');
 
     return {
       content: [{
         type: 'text',
-        text: `📋 미완료 TODO: ${pendingTodos.length}개
+        text: `📋 킹투두 미결: ${pendingTodos.length}개
 
 ${listText}
 
-✅ 완료된 TODO: ${completedCount}개
-📁 전체 기록: z_DocuKing/z_Todo/z_Todo.md`,
+✅ 완료: ${completedCount}개
+📁 전체 기록: z_DocuKing/z_King_Todo/z_King_Todo.md`,
       }],
     };
   }

package/package.json

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