@task-mcp/shared 1.0.29 → 1.0.30

package/src/utils/natural-language.test.ts

@@ -255,6 +255,33 @@ describe("parseTaskInput", () => {
       const result = parseTaskInput("간단한 작업 !medium #task");
       expect(result.workContext).toBeUndefined();
     });
+
+    test("parses done: before :: to prevent intent capturing done:", () => {
+      // Regression test: done: should be extracted before intent (::)
+      const result = parseTaskInput(
+        "API 리팩토링 :: 성능 개선 done:테스트통과,코드리뷰 @thorough #backend !high"
+      );
+      expect(result.title).toBe("API 리팩토링");
+      expect(result.workContext?.intent).toBe("성능 개선");
+      expect(result.workContext?.acceptanceCriteria).toEqual(["테스트통과", "코드리뷰"]);
+      expect(result.workContext?.qualityLevel).toBe("thorough");
+      expect(result.priority).toBe("high");
+      expect(result.tags).toEqual(["backend"]);
+    });
+
+    test("parses done: without intent", () => {
+      const result = parseTaskInput("테스트 작성 done:유닛테스트,통합테스트 !high");
+      expect(result.title).toBe("테스트 작성");
+      expect(result.workContext?.acceptanceCriteria).toEqual(["유닛테스트", "통합테스트"]);
+      expect(result.workContext?.intent).toBeUndefined();
+    });
+
+    test("parses intent without done:", () => {
+      const result = parseTaskInput("리팩토링 :: 가독성 향상 !medium");
+      expect(result.title).toBe("리팩토링");
+      expect(result.workContext?.intent).toBe("가독성 향상");
+      expect(result.workContext?.acceptanceCriteria).toBeUndefined();
+    });
   });
 });
 

package/src/utils/natural-language.ts

@@ -316,7 +316,16 @@ export function parseTaskInput(input: string): TaskCreateInput {
   const result: TaskCreateInput = { title: "" };
   const workContext: Partial<WorkContext> = {};
 
-  // Extract intent first (:: separator)
+  // Extract acceptanceCriteria FIRST (done:xxx,yyy or done:xxx)
+  // Must be before intent extraction to prevent done: from being captured as intent
+  // Format: "done:criterion1,criterion2" or "done:single criterion"
+  const doneMatch = remaining.match(/done:([^\s@#!~^:]+(?:,[^\s@#!~^:]+)*)/i);
+  if (doneMatch) {
+    workContext.acceptanceCriteria = doneMatch[1]!.split(",").map((c) => c.trim());
+    remaining = remaining.replace(doneMatch[0], " ").trim();
+  }
+
+  // Extract intent (:: separator)
   // Format: "Task title :: intent description"
   const intentMatch = remaining.match(/\s*::\s*(.+?)(?=\s+[@#!~^]|$)/);
   if (intentMatch) {
@@ -324,14 +333,6 @@ export function parseTaskInput(input: string): TaskCreateInput {
     remaining = remaining.replace(intentMatch[0], " ").trim();
   }
 
-  // Extract acceptanceCriteria (done:xxx,yyy or done:xxx)
-  // Format: "done:criterion1,criterion2" or "done:single criterion"
-  const doneMatch = remaining.match(/done:([^\s@#!~^]+(?:,[^\s@#!~^]+)*)/i);
-  if (doneMatch) {
-    workContext.acceptanceCriteria = doneMatch[1]!.split(",").map((c) => c.trim());
-    remaining = remaining.replace(doneMatch[0], " ").trim();
-  }
-
   // Extract qualityLevel (@quick, @thorough, etc.) - before contexts
   // These are reserved keywords that become qualityLevel, not contexts
   const qualityLevelKeywords = Object.keys(QUALITY_LEVEL_KEYWORDS);

package/src/utils/plan-parser.ts

@@ -93,10 +93,7 @@ function preprocessInput(input: string): string {
  * `);
  * ```
  */
-export function parsePlan(
-  input: string,
-  options: ParsePlanOptions = {}
-): ParsePlanResult {
+export function parsePlan(input: string, options: ParsePlanOptions = {}): ParsePlanResult {
   if (input.length > MAX_PLAN_LENGTH) {
     return {
       tasks: [],
@@ -121,7 +118,6 @@ export function parsePlan(
   let taskCounter = 0;
   let currentPhase: { tempId: string; title: string } | null = null;
   let currentSection: { tempId: string; level: number } | null = null;
-  let currentParent: { tempId: string; level: number; indent: number } | null = null;
   const parentStack: Array<{ tempId: string; level: number; indent: number }> = [];
 
   for (const line of lines) {
@@ -160,7 +156,6 @@ export function parsePlan(
 
       // Reset section and parent stack
       currentSection = null;
-      currentParent = null;
       parentStack.length = 0;
       continue;
     }
@@ -192,7 +187,6 @@ export function parsePlan(
       });
 
       currentSection = { tempId, level: 1 };
-      currentParent = null;
       parentStack.length = 0;
       continue;
     }
@@ -230,7 +224,6 @@ export function parsePlan(
 
       // Extract metadata from content
       let title = content;
-      let description: string | undefined;
       let priority: Priority | undefined;
       let tags: string[] | undefined;
       let dependsOn: string[] | undefined;
@@ -252,7 +245,7 @@ export function parsePlan(
       // Extract description from remaining parentheses (not dependency-related)
       const descExtracted = extractDescription(title);
       title = descExtracted.title;
-      description = descExtracted.description;
+      const description = descExtracted.description;
 
       const task: ParsedPlanTask = {
         title,
@@ -269,7 +262,6 @@ export function parsePlan(
 
       // Push to parent stack for potential children
       parentStack.push({ tempId, level, indent });
-      currentParent = { tempId, level, indent };
       continue;
     }
 
@@ -303,7 +295,6 @@ export function parsePlan(
       }
 
       let title = content;
-      let description: string | undefined;
       let priority: Priority | undefined;
       let tags: string[] | undefined;
       let dependsOn: string[] | undefined;
@@ -323,7 +314,7 @@ export function parsePlan(
       // Extract description from remaining parentheses
       const descExtracted = extractDescription(title);
       title = descExtracted.title;
-      description = descExtracted.description;
+      const description = descExtracted.description;
 
       tasks.push({
         title,
@@ -347,10 +338,7 @@ export function parsePlan(
 /**
  * Infer dependencies from text patterns like "depends on X", "after X"
  */
-function inferDependenciesFromText(
-  content: string,
-  existingTasks: ParsedPlanTask[]
-): string[] {
+function inferDependenciesFromText(content: string, existingTasks: ParsedPlanTask[]): string[] {
   const deps: string[] = [];
   const lower = content.toLowerCase();
 

package/src/utils/projection.test.ts

@@ -45,7 +45,7 @@ const createInboxItem = (overrides: Partial<InboxItem> = {}): InboxItem => ({
 });
 
 describe("formatTask", () => {
-  test("concise format returns only 4 essential fields", () => {
+  test("concise format returns essential fields plus description for context", () => {
     const task = createTask();
     const result = formatTask(task, "concise");
 
@@ -54,11 +54,12 @@ describe("formatTask", () => {
       title: "Test Task",
       status: "pending",
       priority: "medium",
+      description: "This is a test task with a long description",
     });
-    expect(Object.keys(result)).toHaveLength(4);
+    expect(Object.keys(result)).toHaveLength(5);
   });
 
-  test("standard format returns 8 common fields", () => {
+  test("standard format returns common fields including description", () => {
     const task = createTask();
     const result = formatTask(task, "standard");
 
@@ -67,6 +68,7 @@ describe("formatTask", () => {
       title: "Test Task",
       status: "pending",
       priority: "medium",
+      description: "This is a test task with a long description",
       dueDate: "2025-01-15",
       tags: ["test", "unit"],
       contexts: ["work"],
@@ -94,6 +96,57 @@ describe("formatTask", () => {
     expect(result).not.toHaveProperty("dueDate");
     expect(result).not.toHaveProperty("tags");
   });
+
+  test("concise format includes workContext fields (intent, methodology, quality, patterns, criteria)", () => {
+    const task = createTask({
+      workContext: {
+        intent: "Migrate API layer to service pattern",
+        methodology: "TDD + iterative refactoring",
+        qualityLevel: "thorough",
+        patterns: {
+          parallelExecution: true,
+          testFirst: true,
+        },
+        acceptanceCriteria: ["All tests pass", "No type errors"],
+      },
+    });
+    const result = formatTask(task, "concise");
+
+    expect(result).toHaveProperty("intent", "Migrate API layer to service pattern");
+    expect(result).toHaveProperty("methodology", "TDD + iterative refactoring");
+    expect(result).toHaveProperty("quality", "thorough");
+    expect(result).toHaveProperty("patterns", { parallelExecution: true, testFirst: true });
+    expect(result).toHaveProperty("criteria", ["All tests pass", "No type errors"]);
+  });
+
+  test("standard format includes full workContext with patterns and criteria", () => {
+    const task = createTask({
+      workContext: {
+        intent: "Refactor module",
+        methodology: "Analyze → Extract → Test",
+        qualityLevel: "standard",
+        patterns: {
+          parallelExecution: true,
+          testFirst: true,
+          reviewRequired: false,
+        },
+        acceptanceCriteria: ["Tests pass", "No regressions"],
+      },
+    });
+    const result = formatTask(task, "standard");
+
+    expect(result).toHaveProperty("workContext");
+    const wc = (result as { workContext?: unknown }).workContext as Record<string, unknown>;
+    expect(wc["intent"]).toBe("Refactor module");
+    expect(wc["methodology"]).toBe("Analyze → Extract → Test");
+    expect(wc["qualityLevel"]).toBe("standard");
+    expect(wc["patterns"]).toEqual({
+      parallelExecution: true,
+      testFirst: true,
+      reviewRequired: false,
+    });
+    expect(wc["acceptanceCriteria"]).toEqual(["Tests pass", "No regressions"]);
+  });
 });
 
 describe("formatTasks", () => {
@@ -107,6 +160,7 @@ describe("formatTasks", () => {
       title: "Test Task",
       status: "pending",
       priority: "medium",
+      description: "This is a test task with a long description",
     });
   });
 
@@ -404,8 +458,8 @@ describe("token efficiency", () => {
     const conciseSize = JSON.stringify(concise).length;
     const fullSize = JSON.stringify(full).length;
 
-    // Concise should be at least 50% smaller
-    expect(conciseSize).toBeLessThan(fullSize * 0.5);
+    // Concise should be at least 40% smaller (now includes description for session context)
+    expect(conciseSize).toBeLessThan(fullSize * 0.6);
   });
 
   test("concise list is significantly smaller than full list", () => {
@@ -424,7 +478,7 @@ describe("token efficiency", () => {
     const conciseSize = JSON.stringify(concise).length;
     const fullSize = JSON.stringify(full).length;
 
-    // For list of 20 tasks, concise should be 70%+ smaller
-    expect(conciseSize).toBeLessThan(fullSize * 0.4);
+    // For list of 20 tasks, concise should be 40%+ smaller (now includes description)
+    expect(conciseSize).toBeLessThan(fullSize * 0.6);
   });
 });

package/src/utils/projection.ts

@@ -36,13 +36,43 @@ export function formatTask(task: Task, format: ResponseFormat): TaskSummary | Ta
         status: task.status,
         priority: task.priority,
       };
-      // Include intent + qualityLevel for quick context understanding
+      // Include description for session context (truncated for token efficiency)
+      // Skip if intent exists and provides enough context
+      if (task.description) {
+        const hasIntent = !!task.workContext?.intent;
+        // With intent: shorter description (100 chars), without: fuller context (200 chars)
+        const maxLen = hasIntent ? 100 : 200;
+        summary.description = truncate(task.description, maxLen);
+      }
+      // Include workContext fields for session resumption
       if (task.workContext?.intent) {
         summary.intent = task.workContext.intent;
       }
+      if (task.workContext?.methodology) {
+        summary.methodology = task.workContext.methodology;
+      }
       if (task.workContext?.qualityLevel) {
         summary.quality = task.workContext.qualityLevel;
       }
+      // Include patterns for execution guidance
+      if (task.workContext?.patterns) {
+        const p = task.workContext.patterns;
+        const patterns: {
+          parallelExecution?: boolean;
+          testFirst?: boolean;
+          reviewRequired?: boolean;
+        } = {};
+        if (p.parallelExecution !== undefined) patterns.parallelExecution = p.parallelExecution;
+        if (p.testFirst !== undefined) patterns.testFirst = p.testFirst;
+        if (p.reviewRequired !== undefined) patterns.reviewRequired = p.reviewRequired;
+        if (Object.keys(patterns).length > 0) {
+          summary.patterns = patterns;
+        }
+      }
+      // Include acceptance criteria for completion validation
+      if (task.workContext?.acceptanceCriteria?.length) {
+        summary.criteria = task.workContext.acceptanceCriteria;
+      }
       return summary;
     }
 
@@ -53,6 +83,7 @@ export function formatTask(task: Task, format: ResponseFormat): TaskSummary | Ta
         title: task.title,
         status: task.status,
         priority: task.priority,
+        ...(task.description !== undefined && { description: task.description }),
         ...(task.dueDate !== undefined && { dueDate: task.dueDate }),
         ...(task.tags !== undefined && { tags: task.tags }),
         ...(task.contexts !== undefined && { contexts: task.contexts }),
@@ -65,6 +96,18 @@ export function formatTask(task: Task, format: ResponseFormat): TaskSummary | Ta
           ...(wc.intent !== undefined && { intent: wc.intent }),
           ...(wc.methodology !== undefined && { methodology: wc.methodology }),
           ...(wc.qualityLevel !== undefined && { qualityLevel: wc.qualityLevel }),
+          ...(wc.patterns !== undefined && {
+            patterns: {
+              ...(wc.patterns.parallelExecution !== undefined && {
+                parallelExecution: wc.patterns.parallelExecution,
+              }),
+              ...(wc.patterns.testFirst !== undefined && { testFirst: wc.patterns.testFirst }),
+              ...(wc.patterns.reviewRequired !== undefined && {
+                reviewRequired: wc.patterns.reviewRequired,
+              }),
+            },
+          }),
+          ...(wc.acceptanceCriteria?.length && { acceptanceCriteria: wc.acceptanceCriteria }),
         };
       }
       return result;

package/src/utils/terminal-ui.test.ts

@@ -917,16 +917,13 @@ describe("formatPriorityBadge", () => {
 
 describe("renderSection", () => {
   test("renders header and items", () => {
-    const items = [
-      { primary: "Task 1" },
-      { primary: "Task 2" },
-    ];
+    const items = [{ primary: "Task 1" }, { primary: "Task 2" }];
     const lines = renderSection("Test Section", items);
 
     expect(lines.length).toBeGreaterThan(0);
     expect(stripAnsi(lines[0] ?? "")).toContain("Test Section");
-    expect(lines.some(l => l.includes("Task 1"))).toBe(true);
-    expect(lines.some(l => l.includes("Task 2"))).toBe(true);
+    expect(lines.some((l) => l.includes("Task 1"))).toBe(true);
+    expect(lines.some((l) => l.includes("Task 2"))).toBe(true);
   });
 
   test("renders with icon", () => {
@@ -936,25 +933,21 @@ describe("renderSection", () => {
 
   test("renders empty state message", () => {
     const lines = renderSection("Empty", [], { emptyMessage: "No items" });
-    expect(lines.some(l => stripAnsi(l).includes("No items"))).toBe(true);
+    expect(lines.some((l) => stripAnsi(l).includes("No items"))).toBe(true);
   });
 
   test("renders item details", () => {
-    const items = [
-      { primary: "Task", details: ["Detail 1", "Detail 2"] },
-    ];
+    const items = [{ primary: "Task", details: ["Detail 1", "Detail 2"] }];
     const lines = renderSection("With Details", items);
-    expect(lines.some(l => l.includes("Detail 1"))).toBe(true);
-    expect(lines.some(l => l.includes("Detail 2"))).toBe(true);
+    expect(lines.some((l) => l.includes("Detail 1"))).toBe(true);
+    expect(lines.some((l) => l.includes("Detail 2"))).toBe(true);
   });
 
   test("renders prefix and suffix", () => {
-    const items = [
-      { primary: "Task", prefix: "[x]", suffix: "P1" },
-    ];
+    const items = [{ primary: "Task", prefix: "[x]", suffix: "P1" }];
     const lines = renderSection("Test", items);
-    expect(lines.some(l => l.includes("[x]"))).toBe(true);
-    expect(lines.some(l => l.includes("P1"))).toBe(true);
+    expect(lines.some((l) => l.includes("[x]"))).toBe(true);
+    expect(lines.some((l) => l.includes("P1"))).toBe(true);
   });
 });
 
@@ -966,8 +959,8 @@ describe("renderSections", () => {
     ];
     const lines = renderSections(sections);
 
-    expect(lines.some(l => stripAnsi(l).includes("Section 1"))).toBe(true);
-    expect(lines.some(l => stripAnsi(l).includes("Section 2"))).toBe(true);
+    expect(lines.some((l) => stripAnsi(l).includes("Section 1"))).toBe(true);
+    expect(lines.some((l) => stripAnsi(l).includes("Section 2"))).toBe(true);
     expect(lines.includes("")).toBe(true); // spacing between sections
   });
 });
@@ -1013,9 +1006,7 @@ describe("renderStats", () => {
   });
 
   test("applies color to values", () => {
-    const stats = [
-      { label: "Blocked", value: 3, color: "red" as const },
-    ];
+    const stats = [{ label: "Blocked", value: 3, color: "red" as const }];
     const result = renderStats(stats);
     expect(result).toContain("\x1b[31m"); // red
   });