@task-mcp/shared 1.0.13 → 1.0.14

package/src/algorithms/tech-analysis.ts

@@ -25,6 +25,57 @@ const RISK_ORDER: Record<RiskLevel, number> = {
   critical: 3,
 };
 
+/**
+ * Priority ordering for tiebreaker sorting (lower = higher priority)
+ */
+const PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3,
+} as const;
+
+/** Default priority order when priority is undefined */
+const DEFAULT_PRIORITY_ORDER = PRIORITY_ORDER.medium;
+
+/** Initial value for tech order tracking (before any phase) */
+const INITIAL_TECH_ORDER = -1;
+
+/**
+ * Complexity score thresholds for categorization
+ */
+const COMPLEXITY_THRESHOLDS = {
+  /** Maximum score for "low" complexity (1-3) */
+  LOW_MAX: 3,
+  /** Maximum score for "medium" complexity (4-6) */
+  MEDIUM_MAX: 6,
+  /** Minimum score requiring task breakdown (7+) */
+  BREAKDOWN_MIN: 7,
+} as const;
+
+/**
+ * Complexity score ranges for subtask suggestion calculation
+ */
+const SUBTASK_CALCULATION = {
+  /** Maximum score requiring no breakdown */
+  NO_BREAKDOWN_MAX: 2,
+  /** Maximum score for minimal breakdown */
+  MINIMAL_BREAKDOWN_MAX: 4,
+  /** Subtask count for minimal breakdown */
+  MINIMAL_SUBTASK_COUNT: 2,
+  /** Maximum score for moderate breakdown (3-4 subtasks) */
+  MODERATE_BREAKDOWN_MAX: 6,
+  /** Maximum score for significant breakdown (5-6 subtasks) */
+  SIGNIFICANT_BREAKDOWN_MAX: 8,
+  /** Coefficients for subtask count calculation */
+  MODERATE_COEFFICIENT: 0.5,
+  MODERATE_BASE: 3,
+  SIGNIFICANT_COEFFICIENT: 0.5,
+  SIGNIFICANT_BASE: 5,
+  EXTENSIVE_COEFFICIENT: 1.5,
+  EXTENSIVE_BASE: 7,
+} as const;
+
 /**
  * Result of safe order suggestion
  */
@@ -124,13 +175,12 @@ export function suggestSafeOrder(tasks: Task[]): SafeOrderResult {
     if (aBreaking !== bBreaking) return aBreaking - bBreaking;
 
     // 4. Priority as tiebreaker (higher priority first)
-    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-    return (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2);
+    return (PRIORITY_ORDER[a.priority] ?? DEFAULT_PRIORITY_ORDER) - (PRIORITY_ORDER[b.priority] ?? DEFAULT_PRIORITY_ORDER);
   });
 
   // Group into phases by tech level
   const phases: SafeOrderPhase[] = [];
-  let currentTechOrder = -1;
+  let currentTechOrder = INITIAL_TECH_ORDER;
   let currentPhase: SafeOrderPhase | null = null;
 
   for (const task of sorted) {
@@ -264,9 +314,9 @@ export function groupByTechArea(tasks: Task[]): Map<TechArea, Task[]> {
  * Complexity distribution by level
  */
 export interface ComplexityDistribution {
-  low: number;    // 1-3
-  medium: number; // 4-6
-  high: number;   // 7-10
+  low: number;    // 1 to LOW_MAX
+  medium: number; // LOW_MAX+1 to MEDIUM_MAX
+  high: number;   // MEDIUM_MAX+1 to 10
 }
 
 /**
@@ -275,7 +325,7 @@ export interface ComplexityDistribution {
 export interface ComplexitySummary {
   /** Distribution of complexity scores */
   distribution: ComplexityDistribution;
-  /** Tasks that should be broken down (score >= 7) */
+  /** Tasks that should be broken down (score >= BREAKDOWN_MIN) */
   needsBreakdown: Task[];
   /** Average complexity score */
   averageScore: number;
@@ -308,9 +358,9 @@ export function getComplexitySummary(tasks: Task[]): ComplexitySummary {
     const score = task.complexity!.score!;
     totalScore += score;
 
-    if (score <= 3) {
+    if (score <= COMPLEXITY_THRESHOLDS.LOW_MAX) {
       distribution.low++;
-    } else if (score <= 6) {
+    } else if (score <= COMPLEXITY_THRESHOLDS.MEDIUM_MAX) {
       distribution.medium++;
     } else {
       distribution.high++;
@@ -398,15 +448,33 @@ export function getTechStackSummary(tasks: Task[]): TechStackSummary {
  *
  * Mapping:
  * 1-2: 0 (no breakdown needed)
- * 3-4: 2
- * 5-6: 3-4
- * 7-8: 5-6
- * 9-10: 7-10
+ * 3-4: 2 (minimal breakdown)
+ * 5-6: 3-4 (moderate breakdown)
+ * 7-8: 5-6 (significant breakdown)
+ * 9-10: 7-10 (extensive breakdown)
  */
 export function suggestSubtaskCount(score: number): number {
-  if (score <= 2) return 0;
-  if (score <= 4) return 2;
-  if (score <= 6) return Math.ceil((score - 4) * 0.5 + 3); // 3-4
-  if (score <= 8) return Math.ceil((score - 6) * 0.5 + 5); // 5-6
-  return Math.ceil((score - 8) * 1.5 + 7); // 7-10
+  const {
+    NO_BREAKDOWN_MAX,
+    MINIMAL_BREAKDOWN_MAX,
+    MINIMAL_SUBTASK_COUNT,
+    MODERATE_BREAKDOWN_MAX,
+    SIGNIFICANT_BREAKDOWN_MAX,
+    MODERATE_COEFFICIENT,
+    MODERATE_BASE,
+    SIGNIFICANT_COEFFICIENT,
+    SIGNIFICANT_BASE,
+    EXTENSIVE_COEFFICIENT,
+    EXTENSIVE_BASE,
+  } = SUBTASK_CALCULATION;
+
+  if (score <= NO_BREAKDOWN_MAX) return 0;
+  if (score <= MINIMAL_BREAKDOWN_MAX) return MINIMAL_SUBTASK_COUNT;
+  if (score <= MODERATE_BREAKDOWN_MAX) {
+    return Math.ceil((score - MINIMAL_BREAKDOWN_MAX) * MODERATE_COEFFICIENT + MODERATE_BASE);
+  }
+  if (score <= SIGNIFICANT_BREAKDOWN_MAX) {
+    return Math.ceil((score - MODERATE_BREAKDOWN_MAX) * SIGNIFICANT_COEFFICIENT + SIGNIFICANT_BASE);
+  }
+  return Math.ceil((score - SIGNIFICANT_BREAKDOWN_MAX) * EXTENSIVE_COEFFICIENT + EXTENSIVE_BASE);
 }

package/src/algorithms/topological-sort.ts

@@ -1,4 +1,5 @@
 import type { Task } from "../schemas/task.js";
+import { PriorityQueue } from "../utils/priority-queue.js";
 
 /**
  * Node representation for graph algorithms
@@ -10,67 +11,6 @@ export interface TaskNode {
   estimate: number; // Duration in minutes
 }
 
-/**
- * Max-heap implementation for priority queue (higher priority = higher value comes first)
- * O(log n) insert and extract operations vs O(n log n) for sort-based approach
- */
-class PriorityQueue<T> {
-  private heap: T[] = [];
-  private compare: (a: T, b: T) => number;
-
-  constructor(compare: (a: T, b: T) => number) {
-    this.compare = compare;
-  }
-
-  get length(): number {
-    return this.heap.length;
-  }
-
-  push(item: T): void {
-    this.heap.push(item);
-    this.bubbleUp(this.heap.length - 1);
-  }
-
-  pop(): T | undefined {
-    if (this.heap.length === 0) return undefined;
-    if (this.heap.length === 1) return this.heap.pop();
-
-    const result = this.heap[0];
-    this.heap[0] = this.heap.pop()!;
-    this.bubbleDown(0);
-    return result;
-  }
-
-  private bubbleUp(index: number): void {
-    while (index > 0) {
-      const parentIndex = Math.floor((index - 1) / 2);
-      if (this.compare(this.heap[index]!, this.heap[parentIndex]!) <= 0) break;
-      [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex]!, this.heap[index]!];
-      index = parentIndex;
-    }
-  }
-
-  private bubbleDown(index: number): void {
-    const length = this.heap.length;
-    while (true) {
-      const leftChild = 2 * index + 1;
-      const rightChild = 2 * index + 2;
-      let largest = index;
-
-      if (leftChild < length && this.compare(this.heap[leftChild]!, this.heap[largest]!) > 0) {
-        largest = leftChild;
-      }
-      if (rightChild < length && this.compare(this.heap[rightChild]!, this.heap[largest]!) > 0) {
-        largest = rightChild;
-      }
-
-      if (largest === index) break;
-      [this.heap[index], this.heap[largest]] = [this.heap[largest]!, this.heap[index]!];
-      index = largest;
-    }
-  }
-}
-
 /**
  * Convert priority string to numeric value
  */
@@ -206,7 +146,6 @@ export function wouldCreateCycle(
  * Find all tasks that depend on a given task (directly or transitively)
  */
 export function findDependents(tasks: Task[], taskId: string): Task[] {
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
   const visited = new Set<string>();
   const result: Task[] = [];
 

package/src/schemas/index.ts

@@ -82,3 +82,6 @@ export {
   AgentResponse,
   GenerateResponseInput,
 } from "./response-schema.js";
+
+// State schema (git branch, active tag)
+export { State, DEFAULT_STATE } from "./state.js";

package/src/schemas/state.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+// State schema for persisting application state
+// Stored in .tasks/state.json
+
+export const State = z.object({
+  // Current git branch (auto-detected or manually set)
+  gitBranch: z.string().optional(),
+
+  // Active tag for task filtering (maps to git branch by default)
+  // Required field - use DEFAULT_STATE when creating new state
+  activeTag: z.string(),
+
+  // Last updated timestamp
+  updatedAt: z.string().optional(),
+});
+
+export type State = z.infer<typeof State>;
+
+// Default state when no state.json exists
+export const DEFAULT_STATE: State = {
+  activeTag: "main",
+};

package/src/schemas/task.ts

@@ -124,6 +124,7 @@ export const Task = z.object({
   // Organization
   contexts: z.array(z.string()).optional(), // e.g., ["focus", "review"]
   tags: z.array(z.string()).optional(),
+  sortOrder: z.number().optional(), // Manual ordering within lists
 
   // Recurrence
   recurrence: Recurrence.optional(),
@@ -157,6 +158,7 @@ export const TaskCreateInput = z.object({
   startDate: z.string().optional(),
   contexts: z.array(z.string()).optional(),
   tags: z.array(z.string()).optional(),
+  sortOrder: z.number().optional(),
   recurrence: Recurrence.optional(),
 });
 export type TaskCreateInput = z.infer<typeof TaskCreateInput>;
@@ -176,6 +178,7 @@ export const TaskUpdateInput = z.object({
   startDate: z.string().optional(),
   contexts: z.array(z.string()).optional(),
   tags: z.array(z.string()).optional(),
+  sortOrder: z.number().optional(),
   recurrence: Recurrence.optional(),
   // Analysis fields
   complexity: ComplexityAnalysis.optional(),