feat:task context

Author: kunwarVivek

src/domain/ai-types.ts

@@ -500,31 +500,158 @@ export interface EnhancedFeatureRequirement extends FeatureRequirement {
 }
 
 /**
- * Enhanced AI Task with full requirements traceability
+ * Task Execution Context - comprehensive context for task execution
+ */
+export interface TaskExecutionContext {
+  // Business Context
+  businessObjective: string;           // Why this task matters to the business
+  userImpact: string;                 // How this affects end users
+  successMetrics: string[];           // How success is measured
+
+  // Feature Context
+  parentFeature: {
+    id: string;
+    title: string;
+    description: string;
+    userStories: string[];
+    businessValue: string;
+  };
+
+  // Technical Context
+  technicalConstraints: string[];      // Technical limitations or requirements
+  architecturalDecisions: string[];    // Relevant architecture decisions
+  integrationPoints: string[];         // Systems this task integrates with
+  dataRequirements: string[];          // Data models or schemas involved
+
+  // PRD Context Summary
+  prdContextSummary: {
+    relevantObjectives: string[];      // PRD objectives this task supports
+    relevantRequirements: string[];    // Technical requirements this task addresses
+    scopeConstraints: string[];        // Scope limitations from PRD
+  };
+}
+
+/**
+ * Enhanced Acceptance Criteria with verification details
+ */
+export interface EnhancedAcceptanceCriteria extends AcceptanceCriteria {
+  category: 'functional' | 'technical' | 'quality' | 'integration' | 'performance';
+  verificationMethod: 'unit_test' | 'integration_test' | 'manual_test' | 'code_review' | 'demo';
+  verificationDetails: string;         // Specific steps to verify this criteria
+  priority: 'must_have' | 'should_have' | 'nice_to_have';
+}
+
+/**
+ * Contextual References for tasks
+ */
+export interface ContextualReferences {
+  // Source Document References
+  prdSections: Array<{
+    section: string;
+    content: string;                   // Relevant excerpt
+    relevance: string;                 // Why this section is relevant
+  }>;
+
+  // Feature References
+  relatedFeatures: Array<{
+    id: string;
+    title: string;
+    relationship: 'implements' | 'extends' | 'integrates_with' | 'depends_on';
+    context: string;
+  }>;
+
+  // Technical References
+  technicalSpecs: Array<{
+    type: 'api_spec' | 'data_model' | 'architecture_doc' | 'design_system';
+    title: string;
+    description: string;
+    relevantSections: string[];
+  }>;
+
+  // Example References
+  codeExamples: Array<{
+    description: string;
+    language: string;
+    snippet: string;
+    source: string;
+  }>;
+}
+
+/**
+ * Implementation Guidance for tasks
+ */
+export interface ImplementationGuidance {
+  // Approach Recommendations
+  recommendedApproach: string;         // High-level implementation strategy
+  implementationSteps: string[];       // Step-by-step implementation guide
+
+  // Technical Guidance
+  technicalConsiderations: string[];   // Important technical points
+  commonPitfalls: string[];            // Things to avoid
+  testingStrategy: string;             // How to test this implementation
+
+  // Resource Recommendations
+  recommendedTools: string[];          // Suggested tools or libraries
+  learningResources?: string[];        // Documentation or tutorials
+
+  // Quality Guidelines
+  codeQualityStandards: string[];      // Coding standards to follow
+  performanceConsiderations: string[]; // Performance requirements
+  securityConsiderations: string[];    // Security requirements
+}
+
+/**
+ * Enhanced Task Dependency with context
+ */
+export interface EnhancedTaskDependency extends TaskDependency {
+  // Dependency Context
+  dependencyReason: string;            // Why this dependency exists
+  dependencyOutcome: string;           // What the dependency provides
+  integrationDetails: string;          // How to integrate with dependency
+
+  // Dependency Management
+  canStartInParallel: boolean;         // Can work start before dependency completes
+  parallelWorkGuidance?: string;       // How to work in parallel if possible
+  blockingReason?: string;             // Why this blocks if it does
+
+  // Dependency Verification
+  verificationCriteria: string[];      // How to verify dependency is ready
+  integrationTests: string[];          // Tests to verify integration
+}
+
+/**
+ * Enhanced AI Task with full requirements traceability and context
  */
 export interface EnhancedAITask extends AITask {
   // Requirements traceability
-  implementsRequirements: string[];     // Requirement IDs this task implements
-  implementsUseCases: string[];         // Use case IDs this task implements
-  implementsFeatures: string[];         // Feature IDs this task implements
+  implementsRequirements?: string[];     // Requirement IDs this task implements
+  implementsUseCases?: string[];         // Use case IDs this task implements
+  implementsFeatures?: string[];         // Feature IDs this task implements
   parentPRDId?: string;                // PRD this task originates from
 
   // Detailed traceability
-  requirementTraceability: {
+  requirementTraceability?: {
     businessRequirement: string;        // High-level business requirement
     functionalRequirement: string;      // Functional requirement
     useCase: string;                   // Specific use case
     acceptanceCriteria: string[];      // Acceptance criteria IDs
   };
 
+  // Enhanced Context
+  executionContext?: TaskExecutionContext;
+  enhancedAcceptanceCriteria?: EnhancedAcceptanceCriteria[];
+  contextualReferences?: ContextualReferences;
+  implementationGuidance?: ImplementationGuidance;
+  enhancedDependencies?: EnhancedTaskDependency[];
+
   // Verification and validation
-  verificationTasks: string[];          // Task IDs for verification (testing)
-  verificationStatus: 'not_started' | 'in_progress' | 'completed' | 'failed';
-  testCases: string[];                 // Test case IDs that verify this task
+  verificationTasks?: string[];          // Task IDs for verification (testing)
+  verificationStatus?: 'not_started' | 'in_progress' | 'completed' | 'failed';
+  testCases?: string[];                 // Test case IDs that verify this task
 
   // Impact tracking
-  requirementChanges: RequirementChange[];  // Changes that affected this task
-  impactAnalysis: {
+  requirementChanges?: RequirementChange[];  // Changes that affected this task
+  impactAnalysis?: {
     affectedRequirements: string[];
     affectedUseCases: string[];
     affectedFeatures: string[];

src/env.ts

@@ -135,10 +135,10 @@ export const ENHANCED_TASK_GENERATION = getBooleanConfigValue("ENHANCED_TASK_GEN
 export const AUTO_CREATE_TRACEABILITY = getBooleanConfigValue("AUTO_CREATE_TRACEABILITY", true);
 export const AUTO_GENERATE_USE_CASES = getBooleanConfigValue("AUTO_GENERATE_USE_CASES", true);
 export const AUTO_CREATE_LIFECYCLE = getBooleanConfigValue("AUTO_CREATE_LIFECYCLE", true);
-export const ENHANCED_CONTEXT_LEVEL = getOptionalConfigValue("ENHANCED_CONTEXT_LEVEL", "full"); // minimal, standard, full
-export const INCLUDE_BUSINESS_CONTEXT = getBooleanConfigValue("INCLUDE_BUSINESS_CONTEXT", true);
-export const INCLUDE_TECHNICAL_CONTEXT = getBooleanConfigValue("INCLUDE_TECHNICAL_CONTEXT", true);
-export const INCLUDE_IMPLEMENTATION_GUIDANCE = getBooleanConfigValue("INCLUDE_IMPLEMENTATION_GUIDANCE", true);
+export const ENHANCED_CONTEXT_LEVEL = getOptionalConfigValue("ENHANCED_CONTEXT_LEVEL", "standard"); // minimal, standard, full
+export const INCLUDE_BUSINESS_CONTEXT = getBooleanConfigValue("INCLUDE_BUSINESS_CONTEXT", false); // Default: traceability only
+export const INCLUDE_TECHNICAL_CONTEXT = getBooleanConfigValue("INCLUDE_TECHNICAL_CONTEXT", false); // Default: traceability only
+export const INCLUDE_IMPLEMENTATION_GUIDANCE = getBooleanConfigValue("INCLUDE_IMPLEMENTATION_GUIDANCE", false); // Default: traceability only
 
 // GitHub AI Integration
 export const AUTO_CREATE_PROJECT_FIELDS = getBooleanConfigValue("AUTO_CREATE_PROJECT_FIELDS", true);

src/infrastructure/tools/ai-tasks/ParsePRDTool.ts

@@ -21,11 +21,11 @@ const parsePRDSchema = z.object({
   createTraceabilityMatrix: z.boolean().default(true).describe('Whether to create comprehensive requirements traceability matrix'),
   includeUseCases: z.boolean().default(true).describe('Whether to generate use cases from features'),
   projectId: z.string().optional().describe('Project ID for traceability matrix'),
-  enhancedGeneration: z.boolean().default(true).describe('Whether to use enhanced task generation with full context'),
-  contextLevel: z.enum(['minimal', 'standard', 'full']).default('full').describe('Level of contextual information to include'),
-  includeBusinessContext: z.boolean().default(true).describe('Whether to include business context in tasks'),
-  includeTechnicalContext: z.boolean().default(true).describe('Whether to include technical context in tasks'),
-  includeImplementationGuidance: z.boolean().default(true).describe('Whether to include implementation guidance in tasks')
+  enhancedGeneration: z.boolean().default(true).describe('Whether to use enhanced task generation with context'),
+  contextLevel: z.enum(['minimal', 'standard', 'full']).default('standard').describe('Level of contextual information to include'),
+  includeBusinessContext: z.boolean().default(false).describe('Whether to include AI-generated business context (requires AI)'),
+  includeTechnicalContext: z.boolean().default(false).describe('Whether to include AI-generated technical context (requires AI)'),
+  includeImplementationGuidance: z.boolean().default(false).describe('Whether to include AI-generated implementation guidance (requires AI)')
 });
 
 export type ParsePRDArgs = z.infer<typeof parsePRDSchema>;
@@ -428,10 +428,10 @@ export const parsePRDTool: ToolDefinition<ParsePRDArgs> = {
         includeUseCases: true,
         projectId: "task-management-app",
         enhancedGeneration: true,
-        contextLevel: "full" as const,
-        includeBusinessContext: true,
-        includeTechnicalContext: true,
-        includeImplementationGuidance: true
+        contextLevel: "standard" as const,
+        includeBusinessContext: false,
+        includeTechnicalContext: false,
+        includeImplementationGuidance: false
       }
     }
   ]

src/services/RequirementsTraceabilityService.ts

@@ -1,8 +1,8 @@
-import { 
-  Requirement, 
-  RequirementType, 
-  RequirementStatus, 
-  TraceabilityLink, 
+import {
+  Requirement,
+  RequirementType,
+  RequirementStatus,
+  TraceabilityLink,
   TraceabilityLinkType,
   UseCase,
   EnhancedFeatureRequirement,
@@ -219,15 +219,15 @@ export class RequirementsTraceabilityService {
    * Enhance tasks with full requirements traceability
    */
   enhanceTasksWithTraceability(
-    tasks: AITask[], 
-    useCases: UseCase[], 
-    features: FeatureRequirement[], 
+    tasks: AITask[],
+    useCases: UseCase[],
+    features: FeatureRequirement[],
     businessRequirements: Requirement[],
     prdId: string
   ): EnhancedAITask[] {
     return tasks.map(task => {
       // Find related use cases based on task title/description
-      const relatedUseCases = useCases.filter(uc => 
+      const relatedUseCases = useCases.filter(uc =>
         this.isTaskRelatedToUseCase(task, uc)
       );
 
@@ -246,7 +246,7 @@ export class RequirementsTraceabilityService {
         businessRequirement: relatedBusinessReqs[0]?.id || '',
         functionalRequirement: relatedFeatures[0]?.id || '',
         useCase: relatedUseCases[0]?.id || '',
-        acceptanceCriteria: relatedUseCases.flatMap(uc => 
+        acceptanceCriteria: relatedUseCases.flatMap(uc =>
           uc.acceptanceCriteria.map(ac => ac.id)
         )
       };
@@ -290,7 +290,7 @@ export class RequirementsTraceabilityService {
     const businessRequirements = this.extractBusinessRequirementsFromPRD(prd);
 
     // Generate use cases from features
-    const useCases = features.flatMap(feature => 
+    const useCases = features.flatMap(feature =>
       this.generateUseCasesFromFeature(feature, businessRequirements)
     );
 
@@ -373,7 +373,7 @@ export class RequirementsTraceabilityService {
     // Use Cases -> Tasks
     useCases.forEach(useCase => {
       tasks.forEach(task => {
-        if (task.implementsUseCases.includes(useCase.id)) {
+        if (task.implementsUseCases?.includes(useCase.id)) {
           links.push({
             id: `link-${useCase.id}-${task.id}`,
             fromRequirementId: useCase.id,
@@ -408,23 +408,23 @@ export class RequirementsTraceabilityService {
     ).length;
 
     const useCasesCovered = useCases.filter(uc =>
-      tasks.some(task => task.implementsUseCases.includes(uc.id))
+      tasks.some(task => task.implementsUseCases?.includes(uc.id))
     ).length;
 
     const tasksWithTraceability = tasks.filter(task =>
-      task.implementsRequirements.length > 0 || 
-      task.implementsUseCases.length > 0 || 
-      task.implementsFeatures.length > 0
+      (task.implementsRequirements?.length || 0) > 0 ||
+      (task.implementsUseCases?.length || 0) > 0 ||
+      (task.implementsFeatures?.length || 0) > 0
     ).length;
 
     const orphanedTasks = tasks
-      .filter(task => task.implementsRequirements.length === 0 && 
-                     task.implementsUseCases.length === 0 && 
-                     task.implementsFeatures.length === 0)
+      .filter(task => (task.implementsRequirements?.length || 0) === 0 &&
+                     (task.implementsUseCases?.length || 0) === 0 &&
+                     (task.implementsFeatures?.length || 0) === 0)
       .map(task => task.id);
 
     const unimplementedRequirements = businessRequirements
-      .filter(req => !tasks.some(task => task.implementsRequirements.includes(req.id)))
+      .filter(req => !tasks.some(task => task.implementsRequirements?.includes(req.id)))
       .map(req => req.id);
 
     return {
@@ -441,7 +441,7 @@ export class RequirementsTraceabilityService {
   private isTaskRelatedToUseCase(task: AITask, useCase: UseCase): boolean {
     const taskText = `${task.title} ${task.description}`.toLowerCase();
     const useCaseText = `${useCase.title} ${useCase.goal}`.toLowerCase();
-    
+
     // Simple keyword matching - in production, use more sophisticated NLP
     const keywords = useCase.goal.toLowerCase().split(' ').filter(word => word.length > 3);
     return keywords.some(keyword => taskText.includes(keyword));
@@ -450,23 +450,23 @@ export class RequirementsTraceabilityService {
   private isTaskRelatedToFeature(task: AITask, feature: FeatureRequirement): boolean {
     const taskText = `${task.title} ${task.description}`.toLowerCase();
     const featureText = `${feature.title} ${feature.description}`.toLowerCase();
-    
+
     const keywords = feature.title.toLowerCase().split(' ').filter(word => word.length > 3);
     return keywords.some(keyword => taskText.includes(keyword));
   }
 
   private isTaskRelatedToBusinessRequirement(task: AITask, requirement: Requirement): boolean {
     const taskText = `${task.title} ${task.description}`.toLowerCase();
     const reqText = requirement.description.toLowerCase();
-    
+
     const keywords = reqText.split(' ').filter(word => word.length > 4);
     return keywords.some(keyword => taskText.includes(keyword));
   }
 
   private isFeatureRelatedToBusinessRequirement(feature: FeatureRequirement, requirement: Requirement): boolean {
     const featureText = `${feature.title} ${feature.description}`.toLowerCase();
     const reqText = requirement.description.toLowerCase();
-    
+
     const keywords = reqText.split(' ').filter(word => word.length > 4);
     return keywords.some(keyword => featureText.includes(keyword));
   }