docuking-mcp 1.0.0 → 1.2.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 | 설명 |
@@ -403,7 +515,7 @@ z_DocuKing/
 **특징:**
 - 프로젝트에 초대받아 참여한 사람
 - **읽기**: 전체 문서 Pull 가능 (오너의 문서도 볼 수 있음)
-- **쓰기**: 자신의 폴더(\`Co-worker/{이름}/\`)에만 Push 가능
+- **쓰기**: 자신의 폴더(\`zz_Coworker_{이름}/\`)에만 Push 가능
 - API Key: \`sk_cw_\`로 시작
 - 프로젝트 설정 변경 불가능
 
@@ -412,39 +524,37 @@ z_DocuKing/
 2. MCP 설정 (한 번만)
 3. 프로젝트 연결 (\`docuking_init\`)
 4. Pull로 오너의 문서 가져오기 (\`docuking_pull\`)
-5. 내 폴더에 문서 작성 (\`Co-worker/{이름}/\`)
+5. 내 폴더에 문서 작성 (\`zz_Coworker_{이름}/\`)
 6. Push (\`docuking_push\`)
 
-**폴더 구조:**
+**폴더 구조 (z_DocuKing과 zz_Coworker는 같은 레벨):**
 \`\`\`
-z_DocuKing/
-├── 정책/
-│   └── README.md  ← 오너의 파일 (읽기만 가능)
-├── 기획/
-│   └── 요구사항.md  ← 오너의 파일 (읽기만 가능)
-└── Co-worker/
-    └── 김개발/  ← 참여자 "김개발"의 폴더
-        ├── 제안서.md  ← 여기에만 Push 가능
-        └── 수정안.md  ← 여기에만 Push 가능
+프로젝트/
+├── src/                        ← 소스 코드 (git 관리)
+├── z_DocuKing/                 ← 오너의 문서 공간
+│   ├── 정책/
+│   │   └── README.md           ← 오너의 파일 (읽기만 가능)
+│   └── 기획/
+│       └── 요구사항.md         ← 오너의 파일 (읽기만 가능)
+└── zz_Coworker_김개발/         ← 참여자 "김개발"의 폴더 (z_DocuKing과 같은 레벨!)
+    ├── 제안서.md               ← 여기에만 Push 가능
+    └── 수정안.md               ← 여기에만 Push 가능
 \`\`\`
 
 **중요 규칙:**
-- 참여자가 오너의 폴더를 Pull해서 가지고 있어도, Push할 때는 자동으로 자신의 폴더만 필터링됨
-- 참여자가 다른 폴더에 Push 시도 시 오류 메시지 표시
-- \`docuking_status\`로 현재 권한 확인 가능
+- 코워커 폴더(\`zz_Coworker_{이름}/\`)는 z_DocuKing과 같은 레벨에 생성됨
+- 참여자는 Pull로 z_DocuKing/ 폴더의 오너 문서를 볼 수 있음
+- 참여자는 자신의 폴더에만 Push 가능
+- \`docuking_status\`로 현재 권한과 작업 폴더 확인 가능
 
 **참여자가 오너의 파일을 수정하고 싶을 때:**
-1. 오너의 파일을 Pull해서 로컬에 가져옴 (예: \`정책/README.md\`)
-2. 로컬에서 수정함 (로컬 파일이므로 수정 가능)
-3. Push 시도 → ❌ 오류 발생: "협업자는 Co-worker/{이름}/ 폴더에만 Push할 수 있습니다"
-4. **해결 방법**: 수정한 내용을 자신의 폴더에 새 파일로 작성
-   - 예: \`정책/README.md\`를 수정했다면
-   - → \`Co-worker/김개발/정책_README_수정제안.md\`로 작성 후 Push
+1. Pull로 오너의 파일을 로컬에 가져옴 (z_DocuKing/에 저장됨)
+2. 내용을 참고하여 자신의 폴더에 수정 제안 작성
+   - 예: \`zz_Coworker_김개발/정책_README_수정제안.md\`로 작성 후 Push
 
 **AI가 참여자에게 안내해야 할 내용:**
-- 참여자가 Push를 요청하면, 파일이 \`Co-worker/{이름}/\` 폴더 안에 있는지 확인
-- 다른 폴더에 있는 파일을 Push하려고 하면, 오류 메시지를 명확히 설명하고 해결 방법 제시
-- 오너의 파일을 수정하고 싶다면, 자신의 폴더에 제안서 형태로 작성하도록 안내
+- 참여자의 작업 폴더는 \`zz_Coworker_{이름}/\` (z_DocuKing이 아님)
+- 오너의 파일을 직접 수정할 수 없으므로, 제안서 형태로 작성하도록 안내
 
 ## AI 응답 가이드 (중요!)
 
@@ -507,6 +617,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 +827,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}`);
     }
@@ -747,24 +940,42 @@ Git처럼 무엇을 변경했는지 명확히 작성해주세요.
   const projectId = projectInfo.projectId;
   const projectName = projectInfo.projectName;
 
-  // DocuKing 폴더 찾기
-  const folderName = findDocuKingFolder(localPath);
-  if (!folderName) {
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `오류: DocuKing 폴더가 없습니다.
-docuking_init을 먼저 실행하세요.`,
-        },
-      ],
-    };
-  }
-  const docuKingPath = path.join(localPath, folderName);
-
   // Co-worker 권한은 API Key 형식에서 판단 (sk_xxx_cw_이름_)
   const coworkerMatch = API_KEY.match(/^sk_[a-f0-9]+_cw_([^_]+)_/);
-  const allowedPathPrefix = coworkerMatch ? `Co-worker/${coworkerMatch[1]}/` : null;
+  const isCoworker = !!coworkerMatch;
+  const coworkerName = coworkerMatch ? coworkerMatch[1] : null;
+  const coworkerFolderName = isCoworker ? `zz_Coworker_${coworkerName}` : null;
+
+  // 작업 폴더 결정: 코워커는 zz_Coworker_{이름}/, 오너는 z_DocuKing/
+  let workingPath;
+  let serverPathPrefix = ''; // 서버에 저장될 때 경로 접두사
+
+  if (isCoworker) {
+    // 코워커: zz_Coworker_{이름}/ 폴더 사용 (z_DocuKing과 같은 레벨)
+    workingPath = path.join(localPath, coworkerFolderName);
+    serverPathPrefix = `${coworkerFolderName}/`;
+
+    if (!fs.existsSync(workingPath)) {
+      // 폴더가 없으면 생성
+      fs.mkdirSync(workingPath, { recursive: true });
+      console.log(`[DocuKing] 코워커 폴더 생성: ${coworkerFolderName}/`);
+    }
+  } else {
+    // 오너: z_DocuKing/ 폴더 사용
+    const folderName = findDocuKingFolder(localPath);
+    if (!folderName) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `오류: DocuKing 폴더가 없습니다.
+docuking_init을 먼저 실행하세요.`,
+          },
+        ],
+      };
+    }
+    workingPath = path.join(localPath, folderName);
+  }
 
   // 파일 목록 수집
   const filesToPush = [];
@@ -772,7 +983,7 @@ docuking_init을 먼저 실행하세요.`,
 
   if (filePath) {
     // 특정 파일만
-    const fullPath = path.join(docuKingPath, filePath);
+    const fullPath = path.join(workingPath, filePath);
     if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
       const fileType = getFileType(filePath);
       if (fileType === 'excluded') {
@@ -786,52 +997,21 @@ docuking_init을 먼저 실행하세요.`,
         };
       }
 
-      // 참여자인 경우 경로 체크
-      if (allowedPathPrefix) {
-        const normalizedPath = filePath.toLowerCase();
-        const normalizedPrefix = allowedPathPrefix.toLowerCase();
-        if (!normalizedPath.startsWith(normalizedPrefix)) {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `오류: 협업자는 ${allowedPathPrefix} 폴더에만 Push할 수 있습니다.\n\n요청한 파일: ${filePath}\n허용된 경로: ${allowedPathPrefix}\n\n💡 참고: 오너의 파일을 로컬에서 수정하셨다면, 수정 내용을 ${allowedPathPrefix} 폴더에 새 파일로 작성해주세요.\n예: 정책/README.md를 수정했다면 → ${allowedPathPrefix}정책_README_수정제안.md`,
-              },
-            ],
-          };
-        }
-      }
-
-      filesToPush.push({ path: filePath, fullPath, fileType });
+      // 서버 경로: 코워커는 zz_Coworker_{이름}/파일경로, 오너는 파일경로
+      const serverFilePath = serverPathPrefix + filePath;
+      filesToPush.push({ path: filePath, serverPath: serverFilePath, fullPath, fileType });
     }
   } else {
     // 전체 파일 - 제외된 파일 목록도 수집
-    collectFiles(docuKingPath, '', filesToPush, excludedFiles);
-
-    // 참여자인 경우 허용된 경로의 파일만 필터링
-    if (allowedPathPrefix) {
-      const normalizedPrefix = allowedPathPrefix.toLowerCase();
-      const filteredFiles = filesToPush.filter(file => {
-        const normalizedPath = file.path.toLowerCase();
-        return normalizedPath.startsWith(normalizedPrefix);
-      });
+    collectFiles(workingPath, '', filesToPush, excludedFiles);
 
-      if (filteredFiles.length === 0) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Push할 파일이 없습니다.\n\n협업자는 ${allowedPathPrefix} 폴더에만 Push할 수 있습니다.\n\n현재 폴더 구조를 확인하고, 해당 폴더에 파일을 배치한 후 다시 시도해주세요.`,
-            },
-          ],
-        };
-      }
-
-      // 필터링된 파일로 교체
-      filesToPush.length = 0;
-      filesToPush.push(...filteredFiles);
+    // 서버 경로 추가
+    for (const file of filesToPush) {
+      file.serverPath = serverPathPrefix + file.path;
+    }
 
-      console.log(`[DocuKing] 협업자 권한: ${filteredFiles.length}개 파일만 Push (${allowedPathPrefix})`);
+    if (isCoworker) {
+      console.log(`[DocuKing] 코워커 Push: ${filesToPush.length}개 파일 (${coworkerFolderName}/)`);
     }
   }
 
@@ -940,7 +1120,7 @@ docuking_init을 먼저 실행하세요.`,
               },
               body: JSON.stringify({
                 projectId,
-                path: file.path,
+                path: file.serverPath, // 서버 경로 (코워커는 zz_Coworker_{이름}/파일경로)
                 content,
                 encoding, // 'utf-8' 또는 'base64'
                 message, // 커밋 메시지
@@ -1105,11 +1285,10 @@ async function handlePull(args) {
   const projectId = projectInfo.projectId;
 
   // DocuKing 폴더 찾기 (없으면 기본값으로 생성)
-  let folderName = findDocuKingFolder(localPath);
-  if (!folderName) {
-    folderName = 'z_DocuKing';
+  let ownerFolderName = findDocuKingFolder(localPath);
+  if (!ownerFolderName) {
+    ownerFolderName = 'z_DocuKing';
   }
-  const docuKingPath = path.join(localPath, folderName);
 
   // 파일 목록 조회
   let files = [];
@@ -1175,7 +1354,18 @@ async function handlePull(args) {
       }
 
       const data = await response.json();
-      const fullPath = path.join(docuKingPath, file.path);
+
+      // 서버 경로에 따라 로컬 저장 경로 결정
+      // zz_Coworker_{이름}/으로 시작하면 해당 폴더에, 아니면 z_DocuKing/에 저장
+      let fullPath;
+      const coworkerPrefixMatch = file.path.match(/^(zz_Coworker_[^/]+)\//);
+      if (coworkerPrefixMatch) {
+        // 코워커 폴더 파일: 프로젝트 루트에 zz_Coworker_{이름}/ 폴더로 저장
+        fullPath = path.join(localPath, file.path);
+      } else {
+        // 오너 폴더 파일: z_DocuKing/ 폴더에 저장
+        fullPath = path.join(localPath, ownerFolderName, file.path);
+      }
 
       // 디렉토리 생성
       fs.mkdirSync(path.dirname(fullPath), { recursive: true });
@@ -1430,20 +1620,20 @@ async function handleStatus(args) {
   const coworkerMatch = API_KEY.match(/^sk_[a-f0-9]+_cw_([^_]+)_/);
   const isCoworker = !!coworkerMatch;
   const coworkerName = coworkerMatch ? coworkerMatch[1] : null;
-  const allowedPathPrefix = isCoworker ? `Co-worker/${coworkerName}/` : null;
+  const coworkerFolderName = isCoworker ? `zz_Coworker_${coworkerName}` : null;
 
   // 권한 정보 구성
   let permissionInfo = '';
   if (isCoworker) {
     permissionInfo = `\n\n## 현재 권한: 참여자 (Co-worker)
 - 이름: ${coworkerName}
-- 읽기 권한: 전체 문서 (제한 없음)
-- 쓰기 권한: ${allowedPathPrefix} 폴더만
-- 설명: 다른 폴더의 파일을 Pull해서 가지고 있어도, Push할 때는 자동으로 ${allowedPathPrefix} 폴더의 파일만 Push됩니다.`;
+- 읽기 권한: 전체 문서 (Pull로 z_DocuKing/ 폴더의 문서 가져오기 가능)
+- 쓰기 권한: ${coworkerFolderName}/ 폴더만 (z_DocuKing과 같은 레벨)
+- 설명: 코워커 전용 폴더에서 작업하면 자동으로 서버에 Push됩니다.`;
   } else {
     permissionInfo = `\n\n## 현재 권한: 오너 (Owner)
 - 읽기 권한: 전체 문서
-- 쓰기 권한: 전체 문서 (제한 없음)
+- 쓰기 권한: z_DocuKing/ 폴더 전체 (제한 없음)
 - 설명: 프로젝트의 모든 폴더에 Push할 수 있습니다.`;
   }
 
@@ -1467,29 +1657,35 @@ async function handleStatus(args) {
   }
 
   // 로컬 파일 목록 조회
-  const folderName = findDocuKingFolder(localPath);
-  const docuKingPath = folderName ? path.join(localPath, folderName) : null;
   let localFiles = [];
-  if (docuKingPath && fs.existsSync(docuKingPath)) {
-    collectFiles(docuKingPath, '', localFiles);
-  }
+  let pushableFiles = [];
 
-  // 참여자인 경우 Push 가능한 파일만 필터링
-  let pushableFiles = localFiles;
-  if (allowedPathPrefix) {
-    const normalizedPrefix = allowedPathPrefix.toLowerCase();
-    pushableFiles = localFiles.filter(file => {
-      const normalizedPath = file.path.toLowerCase();
-      return normalizedPath.startsWith(normalizedPrefix);
-    });
+  if (isCoworker) {
+    // 코워커: zz_Coworker_{이름}/ 폴더에서 파일 수집
+    const coworkerPath = path.join(localPath, coworkerFolderName);
+    if (fs.existsSync(coworkerPath)) {
+      collectFiles(coworkerPath, '', localFiles);
+    }
+    pushableFiles = localFiles; // 코워커는 자기 폴더의 모든 파일 Push 가능
+  } else {
+    // 오너: z_DocuKing/ 폴더에서 파일 수집
+    const folderName = findDocuKingFolder(localPath);
+    const docuKingPath = folderName ? path.join(localPath, folderName) : null;
+    if (docuKingPath && fs.existsSync(docuKingPath)) {
+      collectFiles(docuKingPath, '', localFiles);
+    }
+    pushableFiles = localFiles; // 오너는 모든 파일 Push 가능
   }
 
   const projectNameInfo = projectName ? ` (${projectName})` : '';
+  const workingFolder = isCoworker ? coworkerFolderName : 'z_DocuKing';
   const statusText = `DocuKing 동기화 상태
 
 **프로젝트**: ${projectId}${projectNameInfo}
+**작업 폴더**: ${workingFolder}/
 **로컬 파일**: ${localFiles.length}개
-**서버 파일**: ${serverFiles.length}개${allowedPathPrefix ? `\n**Push 가능한 파일**: ${pushableFiles.length}개 (${allowedPathPrefix})` : ''}${permissionInfo}
+**서버 파일**: ${serverFiles.length}개
+**Push 가능한 파일**: ${pushableFiles.length}개${permissionInfo}
 
 ## 사용 가능한 작업
 - **Push**: docuking_push({ localPath, message: "..." })
@@ -1584,6 +1780,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.2.0",
   "description": "DocuKing MCP Server - AI 시대의 문서 협업 플랫폼",
   "type": "module",
   "main": "index.js",