mcp-adr-analysis-server/dist/src/utils/adr-planning-task-integration.d.ts

MCP server for analyzing Architectural Decision Records and project architecture

/**
 * MCP Tasks Integration for Interactive ADR Planning Tool
 *
 * This module provides standardized task tracking for the interactive ADR planning tool,
 * implementing ADR-020: MCP Tasks Integration Strategy.
 *
 * Key features:
 * - Creates MCP Tasks for ADR planning sessions
 * - Tracks progress through planning phases (problem_definition, research, options, decision, impact, implementation, generation)
 * - Supports cancellation between phases
 * - Handles input_required state for interactive planning
 * - Provides memory integration for planning context tracking
 *
 * @see ADR-020: MCP Tasks Integration Strategy
 * @see https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/tasks
 */
import { type AdrTask, type TaskResult, type TaskManager } from './task-manager.js';
/**
 * ADR Planning phases that map to MCP Task phases
 */
export declare const ADR_PLANNING_PHASES: readonly ["problem_definition", "research_analysis", "option_exploration", "decision_making", "impact_assessment", "implementation_planning", "adr_generation"];
export type AdrPlanningPhase = (typeof ADR_PLANNING_PHASES)[number];
/**
 * ADR planning task context for tracking state across planning steps
 */
export interface AdrPlanningTaskContext {
    taskId: string;
    sessionId: string;
    currentPhase: AdrPlanningPhase;
    cancelled: boolean;
    awaitingInput: boolean;
    problemStatement?: string;
    researchCount?: number;
    optionCount?: number;
    selectedOption?: string;
    impactAssessment?: {
        technicalImpacts: number;
        businessImpacts: number;
        risks: number;
    };
    todoCount?: number;
    adrGenerated?: boolean;
}
/**
 * Options for creating an ADR planning task
 */
export interface CreateAdrPlanningTaskOptions {
    projectPath: string;
    adrDirectory?: string;
    sessionId?: string;
    initialProblem?: string;
    enableResearchIntegration?: boolean;
    enableTodoGeneration?: boolean;
}
/**
 * Result from ADR planning task execution
 */
export interface AdrPlanningTaskResult extends TaskResult {
    data?: {
        success: boolean;
        sessionId: string;
        phase: AdrPlanningPhase | 'completed';
        adrPath?: string;
        adrTitle?: string;
        todoCount?: number;
        researchFindingsCount?: number;
        optionsEvaluated?: number;
        awaitingInput?: boolean;
        inputPrompt?: string;
    };
}
/**
 * ADR Planning Task Manager - Provides MCP Tasks integration for interactive ADR planning
 *
 * This class wraps the TaskManager to provide ADR planning-specific functionality:
 * - Creates tasks with ADR planning phases
 * - Tracks planning progress through multiple steps
 * - Supports input_required state for interactive workflows
 * - Supports cancellation between phases
 * - Integrates with memory for planning context tracking
 */
export declare class AdrPlanningTaskManager {
    private taskManager;
    private activeContexts;
    constructor(taskManager?: TaskManager);
    /**
     * Initialize the ADR planning task manager
     */
    initialize(): Promise<void>;
    /**
     * Create a new ADR planning task
     *
     * @returns The created task and context
     */
    createAdrPlanningTask(options: CreateAdrPlanningTaskOptions): Promise<{
        task: AdrTask;
        context: AdrPlanningTaskContext;
    }>;
    /**
     * Get ADR planning task context
     */
    getContext(taskId: string): AdrPlanningTaskContext | undefined;
    /**
     * Start an ADR planning phase
     */
    startPhase(taskId: string, phase: AdrPlanningPhase, message?: string): Promise<void>;
    /**
     * Update phase progress
     */
    updatePhaseProgress(taskId: string, phase: AdrPlanningPhase, phaseProgress: number, message?: string): Promise<void>;
    /**
     * Complete an ADR planning phase
     */
    completePhase(taskId: string, phase: AdrPlanningPhase, _message?: string): Promise<void>;
    /**
     * Fail an ADR planning phase
     */
    failPhase(taskId: string, phase: AdrPlanningPhase, error: string): Promise<void>;
    /**
     * Request input from user (sets task to input_required state)
     */
    requestInput(taskId: string, prompt: string): Promise<void>;
    /**
     * Resume task after receiving input
     */
    resumeAfterInput(taskId: string): Promise<void>;
    /**
     * Store problem definition result
     */
    storeProblemDefinition(taskId: string, problemStatement: string): Promise<void>;
    /**
     * Store research findings
     */
    storeResearchFindings(taskId: string, findingsCount: number): Promise<void>;
    /**
     * Store options explored
     */
    storeOptionsExplored(taskId: string, optionCount: number): Promise<void>;
    /**
     * Store decision made
     */
    storeDecision(taskId: string, selectedOption: string, _rationale: string): Promise<void>;
    /**
     * Store impact assessment result
     */
    storeImpactAssessment(taskId: string, assessment: {
        technicalImpacts: number;
        businessImpacts: number;
        risks: number;
    }): Promise<void>;
    /**
     * Store implementation plan result
     */
    storeImplementationPlan(taskId: string, todoCount: number): Promise<void>;
    /**
     * Store ADR generation result
     */
    storeAdrGenerated(taskId: string, adrPath: string): Promise<void>;
    /**
     * Check if task is cancelled
     */
    isCancelled(taskId: string): Promise<boolean>;
    /**
     * Check if task is awaiting input
     */
    isAwaitingInput(taskId: string): boolean;
    /**
     * Cancel an ADR planning task
     */
    cancelTask(taskId: string, reason?: string): Promise<void>;
    /**
     * Complete an ADR planning task successfully
     */
    completeTask(taskId: string, result: AdrPlanningTaskResult): Promise<void>;
    /**
     * Fail an ADR planning task
     */
    failTask(taskId: string, error: string): Promise<void>;
    /**
     * Get task status
     */
    getTaskStatus(taskId: string): Promise<{
        task: AdrTask | null;
        context: AdrPlanningTaskContext | undefined;
    }>;
}
export declare function getAdrPlanningTaskManager(): AdrPlanningTaskManager;
/**
 * Reset the global AdrPlanningTaskManager (for testing)
 */
export declare function resetAdrPlanningTaskManager(): Promise<void>;
/**
 * Helper function to wrap ADR planning execution with task tracking
 *
 * This can be used by the interactive_adr_planning tool to automatically
 * track progress through MCP Tasks.
 *
 * @example
 * ```typescript
 * const result = await executeAdrPlanningWithTaskTracking(
 *   {
 *     projectPath: '/path/to/project',
 *     adrDirectory: 'docs/adrs',
 *   },
 *   async (tracker) => {
 *     // Problem definition phase
 *     await tracker.startPhase('problem_definition');
 *     const problem = await getProblemStatement();
 *     await tracker.storeProblemDefinition(problem);
 *     await tracker.completePhase('problem_definition');
 *
 *     // Research phase
 *     await tracker.startPhase('research_analysis');
 *     const findings = await conductResearch();
 *     await tracker.storeResearchFindings(findings.length);
 *     await tracker.completePhase('research_analysis');
 *
 *     // Return final result
 *     return {
 *       success: true,
 *       sessionId: tracker.sessionId,
 *       phase: 'completed',
 *       adrPath: '/path/to/adr.md',
 *     };
 *   }
 * );
 * ```
 */
export declare function executeAdrPlanningWithTaskTracking<T extends AdrPlanningTaskResult>(options: CreateAdrPlanningTaskOptions, executor: (tracker: AdrPlanningTaskTracker) => Promise<T['data']>): Promise<{
    taskId: string;
    result: T;
}>;
/**
 * Task tracker interface provided to ADR planning executor
 */
export interface AdrPlanningTaskTracker {
    taskId: string;
    sessionId: string;
    startPhase: (phase: AdrPlanningPhase, message?: string) => Promise<void>;
    updatePhaseProgress: (phase: AdrPlanningPhase, progress: number, message?: string) => Promise<void>;
    completePhase: (phase: AdrPlanningPhase, message?: string) => Promise<void>;
    failPhase: (phase: AdrPlanningPhase, error: string) => Promise<void>;
    requestInput: (prompt: string) => Promise<void>;
    resumeAfterInput: () => Promise<void>;
    storeProblemDefinition: (problem: string) => Promise<void>;
    storeResearchFindings: (count: number) => Promise<void>;
    storeOptionsExplored: (count: number) => Promise<void>;
    storeDecision: (option: string, rationale: string) => Promise<void>;
    storeImpactAssessment: (assessment: {
        technicalImpacts: number;
        businessImpacts: number;
        risks: number;
    }) => Promise<void>;
    storeImplementationPlan: (todoCount: number) => Promise<void>;
    storeAdrGenerated: (adrPath: string) => Promise<void>;
    isCancelled: () => Promise<boolean>;
    isAwaitingInput: () => boolean;
    getContext: () => AdrPlanningTaskContext;
}
//# sourceMappingURL=adr-planning-task-integration.d.ts.map