taskflow-ai/dist/index.d.ts

TaskFlow AI - 智能PRD文档解析与任务管理助手，支持多模型AI协同、MCP编辑器集成，专为开发团队设计的CLI工具

/**
 * 配置相关类型定义
 */
/**
 * 模型类型枚举
 */
declare enum ModelType {
    BAIDU = "baidu",
    XUNFEI = "xunfei",
    ZHIPU = "zhipu",
    DEEPSEEK = "deepseek",
    QWEN = "qwen",
    SPARK = "spark",
    MOONSHOT = "moonshot"
}
/**
 * 日志级别
 */
declare enum LogLevel {
    ERROR = "error",
    WARN = "warn",
    INFO = "info",
    DEBUG = "debug"
}
/**
 * 通用模型配置接口
 */
interface ModelConfig {
    apiKey: string;
    endpoint?: string;
}
/**
 * 百度文心模型配置
 */
interface BaiduModelConfig extends ModelConfig {
    secretKey: string;
    modelVersion?: string;
}
/**
 * 讯飞星火模型配置
 */
interface XunfeiModelConfig extends ModelConfig {
    appId: string;
    apiSecret: string;
}
/**
 * 智谱AI模型配置
 */
interface ZhipuModelConfig extends ModelConfig {
    modelVersion?: string;
}
/**
 * DeepSeek模型配置
 */
interface DeepseekModelConfig extends ModelConfig {
    modelVersion?: string;
}
/**
 * 阿里通义千问模型配置
 */
interface QwenModelConfig extends ModelConfig {
    modelVersion?: string;
    region?: string;
}
/**
 * 讯飞星火模型配置（扩展版）
 */
interface SparkModelConfig extends ModelConfig {
    appId: string;
    apiSecret: string;
    domain?: string;
}
/**
 * 月之暗面模型配置
 */
interface MoonshotModelConfig extends ModelConfig {
    modelVersion?: string;
}
/**
 * 多模型协作配置
 */
interface MultiModelConfig$1 {
    enabled: boolean;
    primary: ModelType;
    fallback: ModelType[];
    loadBalancing: boolean;
    costOptimization: boolean;
}
/**
 * 所有模型配置映射
 */
interface ModelsConfig {
    default: ModelType;
    multiModel?: MultiModelConfig$1;
    [ModelType.BAIDU]?: BaiduModelConfig;
    [ModelType.XUNFEI]?: XunfeiModelConfig;
    [ModelType.ZHIPU]?: ZhipuModelConfig;
    [ModelType.DEEPSEEK]?: DeepseekModelConfig;
    [ModelType.QWEN]?: QwenModelConfig;
    [ModelType.SPARK]?: SparkModelConfig;
    [ModelType.MOONSHOT]?: MoonshotModelConfig;
}
/**
 * 任务设置配置
 */
interface TaskSettings {
    outputDir: string;
    autoSave: boolean;
    saveInterval: number;
}
/**
 * 测试配置
 */
interface TestSettings {
    framework: string;
    outputDir: string;
    coverage: boolean;
}
/**
 * 日志配置
 */
interface LoggerConfig {
    level: LogLevel;
    output: 'console' | 'file' | 'both';
    file?: string;
}
/**
 * 完整应用配置
 */
interface AppConfig {
    models: ModelsConfig;
    taskSettings: TaskSettings;
    testSettings: TestSettings;
    logger: LoggerConfig;
}

/**
 * 日志服务，用于记录应用运行日志
 */
declare class Logger {
    private static instance;
    private logger;
    /**
     * 创建日志服务实例
     * @param config 日志配置
     */
    private constructor();
    /**
     * 获取日志服务实例
     * @param config 日志配置
     */
    static getInstance(config: LoggerConfig): Logger;
    /**
     * 更新日志配置
     * @param config 日志配置
     */
    updateConfig(config: LoggerConfig): void;
    /**
     * 记录错误级别日志
     * @param message 日志消息
     * @param meta 元数据
     */
    error(message: string, meta?: Record<string, unknown>): void;
    /**
     * 记录警告级别日志
     * @param message 日志消息
     * @param meta 元数据
     */
    warn(message: string, meta?: Record<string, unknown>): void;
    /**
     * 记录信息级别日志
     * @param message 日志消息
     * @param meta 元数据
     */
    info(message: string, meta?: Record<string, unknown>): void;
    /**
     * 记录调试级别日志
     * @param message 日志消息
     * @param meta 元数据
     */
    debug(message: string, meta?: Record<string, unknown>): void;
    /**
     * 通用日志记录方法
     * @param level 日志级别
     * @param message 日志消息
     * @param meta 元数据
     */
    log(level: string, message: string, meta?: Record<string, unknown>): void;
}

/**
 * 配置管理器，负责管理应用的配置信息
 */
declare class ConfigManager {
    private conf;
    private projectConf;
    /**
     * 创建配置管理器实例
     * @param configName 配置名称
     */
    constructor(configName?: string);
    /**
     * 获取完整配置
     */
    getConfig(): AppConfig;
    /**
     * 更新配置
     * @param config 配置对象
     * @param isProjectLevel 是否为项目级配置
     */
    updateConfig(config: Partial<AppConfig>, isProjectLevel?: boolean): void;
    /**
     * 设置配置项
     * @param key 配置键路径（点分隔，如 'models.baidu.apiKey'）
     * @param value 配置值
     * @param isProjectLevel 是否为项目级配置
     */
    set(key: string, value: any, isProjectLevel?: boolean): void;
    /**
     * 获取配置项
     * @param key 配置键路径
     * @param defaultValue 默认值
     */
    get<T>(key: string, defaultValue?: T): T;
    /**
     * 检查配置项是否存在
     * @param key 配置键路径
     */
    has(key: string): boolean;
    /**
     * 删除配置项
     * @param key 配置键路径
     * @param isProjectLevel 是否为项目级配置
     */
    delete(key: string, isProjectLevel?: boolean): void;
    /**
     * 重置配置
     * @param isProjectLevel 是否为项目级配置
     */
    reset(isProjectLevel?: boolean): void;
    /**
     * 初始化项目配置文件
     * @param directory 项目目录
     */
    initProjectConfig(directory: string): void;
    /**
     * 获取当前默认模型类型
     */
    getDefaultModelType(): ModelType;
    /**
     * 设置默认模型类型
     * @param modelType 模型类型
     * @param isProjectLevel 是否为项目级配置
     */
    setDefaultModelType(modelType: ModelType, isProjectLevel?: boolean): void;
    /**
     * 获取配置路径
     * @param isProjectLevel 是否为项目级配置
     */
    getConfigPath(isProjectLevel?: boolean): string;
}

/**
 * 模型相关类型定义
 */
/**
 * 服务响应类型
 */
interface ServiceResponse<T> {
    success: boolean;
    data?: T;
    error?: string;
}

/**
 * 消息角色
 */
declare enum MessageRole {
    USER = "user",
    ASSISTANT = "assistant",
    SYSTEM = "system"
}
/**
 * 聊天消息
 */
interface ChatMessage {
    role: MessageRole;
    content: string;
}
/**
 * 基本模型响应
 */
interface ModelResponse {
    content: string;
    finishReason?: string;
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
}
/**
 * 模型调用选项
 */
interface ModelCallOptions {
    temperature?: number;
    maxTokens?: number;
    stream?: boolean;
    timeout?: number;
}
/**
 * 多模型配置
 */
interface MultiModelConfig {
    enabled: boolean;
    primary: ModelType;
    fallback: ModelType[];
    loadBalancing?: boolean;
    costOptimization?: boolean;
}
/**
 * PRD解析选项
 */
interface ParseOptions {
    modelType?: ModelType;
    multiModel?: MultiModelConfig;
    extractSections?: boolean;
    extractFeatures?: boolean;
    prioritize?: boolean;
    outputPath?: string;
}
/**
 * 任务规划选项
 */
interface PlanningOptions {
    modelType?: ModelType;
    taskTemplate?: string;
    estimateDuration?: boolean;
    assignTasks?: boolean;
    suggestDependencies?: boolean;
    optimizeForTime?: boolean;
    optimizeForResources?: boolean;
    considerTeamSize?: number;
    maxParallelTasks?: number;
    includeTestTasks?: boolean;
    includeDocTasks?: boolean;
}
/**
 * 测试生成选项
 */
interface TestGenerationOptions {
    modelType?: ModelType;
    framework?: string;
    coverage?: boolean;
    includeEdgeCases?: boolean;
    mockDependencies?: boolean;
}
/**
 * 文件类型
 */
declare enum FileType {
    MARKDOWN = "markdown",
    PDF = "pdf",
    WORD = "word",
    TEXT = "text",
    JSON = "json",
    UNKNOWN = "unknown"
}

/**
 * TaskFlow AI 任务相关类型定义
 */
/**
 * 任务状态枚举
 */
declare enum TaskStatus {
    NOT_STARTED = "not_started",// 未开始
    PENDING = "pending",// 等待中
    IN_PROGRESS = "in_progress",// 进行中
    RUNNING = "running",// 执行中
    COMPLETED = "completed",// 已完成
    DONE = "done",// 完成（兼容性）
    CANCELLED = "cancelled",// 已取消
    FAILED = "failed",// 失败
    BLOCKED = "blocked",// 被阻塞
    ON_HOLD = "on_hold",// 暂停
    REVIEW = "review",// 审核中
    TODO = "todo"
}
/**
 * 任务优先级
 */
declare enum TaskPriority {
    LOW = "low",
    MEDIUM = "medium",
    HIGH = "high",
    CRITICAL = "critical"
}
/**
 * 任务类型
 */
declare enum TaskType {
    FEATURE = "feature",// 功能开发
    BUG_FIX = "bug_fix",// 缺陷修复
    REFACTOR = "refactor",// 代码重构
    TEST = "test",// 测试任务
    DOCUMENT = "document",// 文档任务
    ANALYSIS = "analysis",// 分析任务
    DESIGN = "design",// 设计任务
    DEPLOYMENT = "deployment",// 部署任务
    RESEARCH = "research"
}
/**
 * 基本任务接口
 */
interface Task {
    id: string;
    name: string;
    title: string;
    description: string;
    status: TaskStatus;
    priority: TaskPriority;
    type: TaskType;
    dependencies: string[];
    estimatedHours?: number;
    actualHours?: number;
    createdAt: Date;
    updatedAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    dueDate?: Date;
    assignee?: string;
    tags: string[];
    acceptance?: string[];
    notes?: string;
    progress?: number;
    metadata?: Record<string, any>;
    subtasks?: Task[];
}
/**
 * 任务计划
 */
interface TaskPlan {
    id: string;
    name: string;
    description: string;
    tasks: Task[];
    createdAt: Date;
    updatedAt: Date;
    dueDate?: Date;
    source?: string;
    status: 'draft' | 'active' | 'completed' | 'archived';
    metadata?: Record<string, any>;
}
/**
 * PRD解析结果
 */
interface ParsedPRD {
    id?: string;
    title: string;
    description: string;
    sections: PRDSection$1[];
    metadata: Record<string, any>;
}
/**
 * PRD章节
 */
interface PRDSection$1 {
    title: string;
    content: string;
    level: number;
    features: Feature[];
    subsections?: PRDSection$1[];
}
/**
 * 功能点
 */
interface Feature {
    name: string;
    description: string;
    priority?: TaskPriority;
    acceptance?: string[];
}

/**
 * 模型协调器
 * 负责协调多个模型的使用，根据任务类型选择合适的模型
 */
declare class ModelCoordinator {
    private modelFactory;
    private configManager;
    /**
     * 创建模型协调器实例
     * @param configManager 配置管理器实例
     */
    constructor(configManager: ConfigManager);
    /**
     * 执行聊天请求
     * @param messages 消息数组
     * @param modelType 模型类型，不传时使用默认模型
     * @param options 调用选项
     */
    chat(messages: ChatMessage[], modelType?: ModelType, options?: ModelCallOptions): Promise<ModelResponse>;
    /**
     * 执行流式聊天请求
     * @param messages 消息数组
     * @param onData 数据回调
     * @param modelType 模型类型，不传时使用默认模型
     * @param options 调用选项
     */
    chatStream(messages: ChatMessage[], onData: (content: string, done: boolean) => void, modelType?: ModelType, options?: ModelCallOptions): Promise<void>;
    /**
     * 执行PRD解析任务
     * @param content PRD文档内容
     * @param options 解析选项
     */
    parsePRD(content: string, options?: ParseOptions): Promise<ModelResponse>;
    /**
     * 执行任务规划
     * @param parsedPRD 解析后的PRD结果
     * @param options 规划选项
     */
    planTasks(parsedPRD: ParsedPRD, options?: PlanningOptions): Promise<ModelResponse>;
    /**
     * 生成测试用例
     * @param taskDescription 任务描述
     * @param options 测试生成选项
     */
    generateTests(taskDescription: string, options?: TestGenerationOptions): Promise<ModelResponse>;
    /**
     * 获取可用的模型类型列表
     */
    getAvailableModelTypes(): ModelType[];
    /**
     * 验证指定类型模型的API密钥
     * @param modelType 模型类型
     */
    validateModelApiKey(modelType: ModelType): Promise<boolean>;
}

/**
 * TaskFlow AI 核心引擎
 * 负责协调PRD解析、任务编排和管理的核心逻辑
 */

/**
 * 引擎执行结果
 */
interface EngineResult<T = unknown> {
    success: boolean;
    data?: T;
    message?: string;
    errors?: string[];
    warnings?: string[];
    metadata?: Record<string, unknown>;
}
/**
 * TaskFlow AI 核心引擎类
 */
declare class TaskFlowEngine {
    private logger;
    private configManager;
    private modelCoordinator;
    private prdParser;
    private taskPlanner;
    private taskManager;
    private config;
    /**
     * 创建TaskFlow引擎实例
     */
    constructor(logger: Logger, configManager: ConfigManager, modelCoordinator: ModelCoordinator);
    /**
     * 从PRD文件解析并生成完整的任务计划
     * @param prdFilePath PRD文件路径
     * @param parseOptions 解析选项
     * @param planningOptions 规划选项
     */
    processFromPRD(prdFilePath: string, parseOptions?: ParseOptions, planningOptions?: PlanningOptions): Promise<EngineResult<TaskPlan>>;
    /**
     * 解析PRD文档
     * @param prdFilePath PRD文件路径
     * @param options 解析选项
     */
    parsePRD(prdFilePath: string, options?: ParseOptions): Promise<EngineResult<ParsedPRD>>;
    /**
     * 生成任务计划
     * @param prdData 解析后的PRD数据
     * @param options 规划选项
     */
    generateTaskPlan(prdData: ParsedPRD, options?: PlanningOptions): Promise<EngineResult<TaskPlan>>;
    /**
     * 优化任务计划
     * @param taskPlan 原始任务计划
     * @param options 优化选项
     */
    optimizeTaskPlan(taskPlan: TaskPlan, options?: PlanningOptions): Promise<EngineResult<TaskPlan>>;
    /**
     * 获取当前任务计划
     */
    getCurrentTaskPlan(): TaskPlan | null;
    /**
     * 获取推荐的下一个任务
     */
    getRecommendedTasks(): Task[];
    /**
     * 更新任务状态
     * @param taskId 任务ID
     * @param status 新状态
     */
    updateTaskStatus(taskId: string, status: string): Promise<EngineResult<Task>>;
    /**
     * 获取项目进度统计
     */
    getProgressStats(): {
        total: number;
        completed: number;
        inProgress: number;
        notStarted: number;
        blocked: number;
        completionRate: number;
    };
    /**
     * 销毁引擎，清理资源
     */
    destroy(): void;
}

/**
 * PRD解析结果接口
 */
interface PRDParseResult {
    title: string;
    description: string;
    sections: PRDSection[];
}
/**
 * PRD章节接口
 */
interface PRDSection {
    title: string;
    content: string;
    level: number;
    features: PRDFeature[];
    subsections?: PRDSection[];
}
/**
 * PRD功能特性接口
 */
interface PRDFeature {
    name: string;
    description: string;
    priority: 'high' | 'medium' | 'low';
}
/**
 * PRD解析器类
 * 负责解析产品需求文档，整合文档处理和需求提取功能
 */
declare class PRDParser {
    private modelCoordinator;
    private logger;
    private documentProcessor;
    private requirementExtractor;
    /**
     * 创建PRD解析器实例
     * @param modelCoordinator 模型协调器实例
     * @param logger 日志记录器实例
     */
    constructor(modelCoordinator: ModelCoordinator, logger: Logger);
    /**
     * 从文件中解析PRD
     * @param filePath PRD文件路径
     * @param options 解析选项
     */
    parseFromFile(filePath: string, options?: ParseOptions): Promise<ParsedPRD>;
    /**
     * 解析PRD内容
     * @param content PRD文档内容
     * @param fileType 文件类型
     * @param options 解析选项
     */
    parseContent(content: string, fileType?: FileType, options?: ParseOptions): Promise<PRDParseResult>;
    /**
     * 预处理不同类型的文档内容
     * @param content 文档内容
     * @param fileType 文件类型
     */
    private preprocessContent;
    /**
     * 根据文件扩展名检测文件类型
     * @param filePath 文件路径
     */
    private detectFileType;
    /**
     * 验证解析结果是否符合预期格式
     * @param result 解析结果
     */
    private validateParseResult;
    /**
     * 转换为ParsedPRD格式
     * @param documentStructure 文档结构
     * @param extractionResult 需求提取结果
     */
    private convertToParseResult;
    /**
     * 提取文档描述
     * @param documentStructure 文档结构
     */
    private extractDescription;
    /**
     * 转换DocumentSection到PRDSection
     * @param sections 文档章节列表
     */
    private convertToPRDSections;
    /**
     * 计算最大深度
     * @param sections 章节列表
     */
    private calculateMaxDepth;
    /**
     * 检查是否有目录
     * @param documentStructure 文档结构
     */
    private hasTableOfContents;
}

/**
 * 任务规划器类
 * 负责根据PRD生成任务计划
 */
declare class TaskPlanner {
    private modelCoordinator;
    private logger;
    /**
     * 创建任务规划器实例
     * @param modelCoordinator 模型协调器实例
     * @param logger 日志记录器
     */
    constructor(modelCoordinator: ModelCoordinator, logger: Logger);
    /**
     * 根据PRD解析结果生成任务计划
     * @param prdResult PRD解析结果
     * @param options 规划选项
     */
    generateTaskPlan(prdResult: ParsedPRD | PRDParseResult, options?: PlanningOptions): Promise<TaskPlan>;
    /**
     * 优化任务计划
     * @param taskPlan 原始任务计划
     * @param options 优化选项
     */
    optimizeTaskPlan(taskPlan: TaskPlan, options?: PlanningOptions): Promise<TaskPlan>;
    /**
     * 将任务计划保存到文件
     * @param taskPlan 任务计划
     * @param outputPath 输出路径
     */
    saveTaskPlan(taskPlan: TaskPlan, outputPath: string): Promise<void>;
    /**
     * 验证任务计划是否符合预期格式
     * @param taskPlan 任务计划
     */
    private validateTaskPlan;
    /**
     * 后处理任务计划，添加一些自动生成的信息
     * @param taskPlan 任务计划
     */
    private postProcessTaskPlan;
    /**
     * 生成唯一ID
     * @param baseId 基础ID
     * @param existingIds 已存在的ID集合
     */
    private generateUniqueId;
    /**
     * 检测任务依赖是否存在循环依赖
     * @param taskPlan 任务计划
     */
    private checkCircularDependencies;
    /**
     * 使用DFS检测有向图中的环
     * @param node 当前节点
     * @param graph 依赖图
     * @param visited 已访问节点集合
     * @param recStack 递归栈
     */
    private detectCycle;
    /**
     * 优化任务依赖关系
     * @param taskPlan 任务计划
     */
    private optimizeDependencies;
    /**
     * 移除冗余依赖（传递依赖）
     * @param dependencies 依赖列表
     * @param taskPlan 任务计划
     */
    private removeRedundantDependencies;
    /**
     * 检查是否存在传递依赖
     * @param fromId 起始任务ID
     * @param toId 目标任务ID
     * @param taskMap 任务映射
     */
    private hasTransitiveDependency;
    /**
     * 优化任务优先级
     * @param taskPlan 任务计划
     * @param options 优化选项
     */
    private optimizePriorities;
    /**
     * 查找依赖某个任务的所有任务
     * @param taskId 任务ID
     * @param taskPlan 任务计划
     */
    private findDependentTasks;
    /**
     * 检查任务是否在关键路径上
     * @param taskId 任务ID
     * @param taskPlan 任务计划
     */
    private isOnCriticalPath;
    /**
     * 计算任务的依赖深度
     * @param taskId 任务ID
     * @param taskPlan 任务计划
     */
    private calculateDependencyDepth;
    /**
     * 计算平均依赖深度
     * @param taskPlan 任务计划
     */
    private calculateAverageDependencyDepth;
    /**
     * 识别可并行执行的任务
     * @param taskPlan 任务计划
     * @param options 优化选项
     */
    private identifyParallelTasks;
    /**
     * 查找可并行执行的任务组
     * @param taskPlan 任务计划
     * @param maxGroupSize 最大组大小
     */
    private findParallelGroups;
    /**
     * 查找与指定任务可并行执行的任务
     * @param task 基准任务
     * @param taskPlan 任务计划
     * @param processed 已处理的任务
     */
    private findParallelTasks;
    /**
     * 检查两个任务是否可以并行执行
     * @param task1 任务1
     * @param task2 任务2
     * @param taskPlan 任务计划
     */
    private canRunInParallel;
    /**
     * 检查是否存在间接依赖关系
     * @param fromId 起始任务ID
     * @param toId 目标任务ID
     * @param taskPlan 任务计划
     */
    private hasIndirectDependency;
    /**
     * 平衡工作量
     * @param taskPlan 任务计划
     * @param options 优化选项
     */
    private balanceWorkload;
}

/**
 * 任务过滤条件
 */
interface TaskFilter {
    status?: TaskStatus | TaskStatus[];
    type?: string | string[];
    assignee?: string;
    priority?: string | string[];
}
/**
 * 任务更新数据
 */
interface TaskUpdateData {
    name?: string;
    description?: string;
    status?: TaskStatus;
    priority?: string;
    assignee?: string;
}
/**
 * 任务管理器类
 * 负责管理任务计划中的任务
 */
declare class TaskManager {
    private taskPlan;
    private taskFilePath;
    private logger;
    private configManager;
    private autoSaveInterval;
    /**
     * 创建任务管理器实例
     * @param logger 日志记录器
     * @param configManager 配置管理器
     */
    constructor(logger: Logger, configManager: ConfigManager);
    /**
     * 加载任务计划
     * @param filePath 任务计划文件路径，不指定则使用默认路径
     */
    loadTaskPlan(filePath?: string): Promise<TaskPlan>;
    /**
     * 保存任务计划
     * @param filePath 保存路径，不指定则使用默认路径
     */
    saveTaskPlan(filePath?: string): Promise<void>;
    /**
     * 设置任务计划
     * @param taskPlan 任务计划
     */
    setTaskPlan(taskPlan: TaskPlan): void;
    /**
     * 获取任务计划
     */
    getTaskPlan(): TaskPlan | null;
    /**
     * 获取所有任务
     */
    getAllTasks(): Task[];
    /**
     * 根据ID获取任务
     * @param id 任务ID
     */
    getTaskById(id: string): Task | null;
    /**
     * 过滤任务
     * @param filter 过滤条件
     */
    filterTasks(filter: TaskFilter): Task[];
    /**
     * 添加新任务
     * @param task 任务
     */
    addTask(task: Task): Task;
    /**
     * 更新任务
     * @param id 任务ID
     * @param data 更新数据
     */
    updateTask(id: string, data: TaskUpdateData): Task | null;
    /**
     * 删除任务
     * @param id 任务ID
     */
    removeTask(id: string): boolean;
    /**
     * 添加子任务
     * @param parentId 父任务ID
     * @param subtask 子任务
     */
    addSubtask(parentId: string, subtask: any): any;
    /**
     * 获取下一个要处理的任务
     */
    getNextTasks(): Task[];
    /**
     * 添加依赖关系
     * @param taskId 任务ID
     * @param dependsOnId 依赖的任务ID
     */
    addDependency(taskId: string, dependsOnId: string): boolean;
    /**
     * 移除依赖关系
     * @param taskId 任务ID
     * @param dependsOnId 依赖的任务ID
     */
    removeDependency(taskId: string, dependsOnId: string): boolean;
    /**
     * 检查是否存在循环依赖
     * @param task1Id 任务1ID
     * @param task2Id 任务2ID
     */
    private checkCircularDependency;
    /**
     * 开始自动保存任务计划
     * @param interval 保存间隔（毫秒）
     */
    private startAutoSave;
    /**
     * 停止自动保存
     */
    stopAutoSave(): void;
    /**
     * 析构函数，清理资源
     */
    destroy(): void;
}

/**
 * TaskFlow AI 任务可视化模块
 * 负责生成各种任务可视化图表
 */

/**
 * 可视化类型枚举
 */
declare enum VisualizationType {
    GANTT = "gantt",
    DEPENDENCY = "dependency",
    KANBAN = "kanban",
    TIMELINE = "timeline",
    PROGRESS = "progress"
}
/**
 * 可视化选项
 */
interface VisualizationOptions {
    type: VisualizationType;
    format?: 'mermaid' | 'json' | 'html';
    includeSubtasks?: boolean;
    showProgress?: boolean;
    groupBy?: 'type' | 'assignee' | 'priority';
    timeUnit?: 'days' | 'hours';
}
/**
 * 任务可视化器类
 */
declare class TaskVisualizer {
    private logger;
    constructor(logger: Logger);
    /**
     * 生成可视化数据
     * @param taskPlan 任务计划
     * @param options 可视化选项
     */
    generateVisualization(taskPlan: TaskPlan, options: VisualizationOptions): Record<string, unknown>;
    /**
     * 生成甘特图
     * @param taskPlan 任务计划
     * @param options 选项
     */
    private generateGanttChart;
    /**
     * 生成Mermaid格式的甘特图
     * @param ganttData 甘特图数据
     */
    private generateMermaidGantt;
    /**
     * 生成依赖关系图
     * @param taskPlan 任务计划
     * @param options 选项
     */
    private generateDependencyGraph;
    /**
     * 生成Mermaid格式的依赖关系图
     * @param graph 依赖关系图数据
     */
    private generateMermaidDependencyGraph;
    /**
     * 获取节点形状
     * @param status 任务状态
     */
    private getNodeShape;
    /**
     * 获取节点样式
     * @param priority 优先级
     */
    private getNodeStyle;
    /**
     * 生成看板
     * @param taskPlan 任务计划
     * @param options 选项
     */
    private generateKanbanBoard;
    /**
     * 生成时间线
     * @param taskPlan 任务计划
     * @param options 选项
     */
    private generateTimeline;
    /**
     * 生成进度图表
     * @param taskPlan 任务计划
     * @param options 选项
     */
    private generateProgressChart;
    /**
     * 格式化日期
     * @param date 日期
     */
    private formatDate;
    /**
     * 计算任务开始日期
     * @param task 任务
     * @param index 索引
     */
    private calculateTaskStartDate;
}

/**
 * MCP接口函数
 * 为AI编辑器提供标准化接口
 */
/**
 * 执行MCP工具
 * @param toolName 工具名称
 * @param args 工具参数
 */
declare function executeTool(toolName: string, args: any): Promise<ServiceResponse<PRDParseResult> | {
    success: boolean;
    error?: undefined;
} | {
    success: boolean;
    error: string;
}>;
/**
 * 获取所有可用的MCP工具
 */
declare function getTools(): ({
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            content: {
                type: string;
                description: string;
            };
            fileType: {
                type: string;
                enum: string[];
                description: string;
                default: string;
            };
            modelType: {
                type: string;
                enum: string[];
                description: string;
            };
            outputPath: {
                type: string;
                description: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            filePath: {
                type: string;
                description: string;
            };
            modelType: {
                type: string;
                enum: string[];
                description: string;
            };
            outputPath: {
                type: string;
                description: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {};
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            id: {
                type: string;
                description: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {};
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            id: {
                type: string;
                description: string;
            };
            status: {
                type: string;
                enum: string[];
                description: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            messages: {
                type: string;
                items: {
                    type: string;
                    properties: {
                        role: {
                            type: string;
                            enum: string[];
                        };
                        content: {
                            type: string;
                        };
                    };
                    required: string[];
                };
                description: string;
            };
            modelType: {
                type: string;
                enum: string[];
                description: string;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {};
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            config: {
                type: string;
                description: string;
            };
            isProjectLevel: {
                type: string;
                description: string;
                default: boolean;
            };
        };
        required: string[];
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {};
    };
} | {
    name: string;
    description: string;
    inputSchema: {
        type: string;
        properties: {
            modelType: {
                type: string;
                enum: string[];
                description: string;
            };
        };
        required: string[];
    };
})[];
/**
 * 获取MCP服务器信息
 */
declare function getServerInfo(): {
    name: string;
    version: string;
    description: string;
    capabilities: {
        tools: boolean;
        resources: boolean;
        prompts: boolean;
    };
};
/**
 * 从文本解析PRD并生成任务
 * @param text PRD文本内容
 * @param options 解析选项
 */
declare function parsePRD(text: string, options?: any): Promise<{
    error: string | undefined;
    success?: undefined;
    data?: undefined;
} | {
    success: boolean;
    data: {
        prd: PRDParseResult | undefined;
        taskPlan: TaskPlan | undefined;
    };
    error?: undefined;
}>;
/**
 * 从文件解析PRD并生成任务
 * @param filePath PRD文件路径
 * @param options 解析选项
 */
declare function parsePRDFromFile(filePath: string, options?: any): Promise<{
    error: string | undefined;
    success?: undefined;
    data?: undefined;
} | {
    success: boolean;
    data: {
        prd: ParsedPRD | undefined;
        taskPlan: TaskPlan | undefined;
    };
    error?: undefined;
}>;
/**
 * 获取所有任务
 */
declare function getAllTasks(): Promise<{
    success: boolean;
    data: Task[];
    error?: undefined;
} | {
    success: boolean;
    error: string;
    data?: undefined;
}>;
/**
 * 根据ID获取任务
 * @param id 任务ID
 */
declare function getTaskById(id: string): Promise<{
    success: boolean;
    error: string;
    data?: undefined;
} | {
    success: boolean;
    data: Task;
    error?: undefined;
}>;
/**
 * 获取下一个要处理的任务
 */
declare function getNextTasks(): Promise<{
    success: boolean;
    data: Task[];
    error?: undefined;
} | {
    success: boolean;
    error: string;
    data?: undefined;
}>;
/**
 * 更新任务状态
 * @param id 任务ID
 * @param status 新状态
 */
declare function updateTaskStatus(id: string, status: string): Promise<{
    success: boolean;
    error: string;
    data?: undefined;
} | {
    success: boolean;
    data: Task;
    error?: undefined;
}>;
/**
 * 使用聊天模型进行对话
 * @param messages 消息数组
 * @param modelType 模型类型
 * @param options 调用选项
 */
declare function chat(messages: any[], modelType?: ModelType, options?: ModelCallOptions): Promise<{
    success: boolean;
    data: ModelResponse;
    error?: undefined;
} | {
    success: boolean;
    error: string;
    data?: undefined;
}>;
/**
 * 获取所有可用的模型类型
 */
declare function getAvailableModelTypes(): Promise<{
    success: boolean;
    data: ModelType[];
    error?: undefined;
} | {
    success: boolean;
    error: string;
    data?: undefined;
}>;
/**
 * 验证模型API密钥
 * @param modelType 模型类型
 */
declare function validateModelApiKey(modelType: ModelType): Promise<{
    success: boolean;
    data: {
        valid: boolean;
    };
    error?: undefined;
} | {
    success: boolean;
    error: string;
    data?: undefined;
}>;
/**
 * 更新配置
 * @param config 配置对象
 * @param isProjectLevel 是否为项目级配置
 */
declare function updateConfig(config: any, isProjectLevel?: boolean): Promise<{
    success: boolean;
    error?: undefined;
} | {
    success: boolean;
    error: string;
}>;
/**
 * 获取配置
 */
declare function getConfig(): Promise<{
    success: boolean;
    data: {
        [x: string]: unknown;
    };
    error?: undefined;
} | {
    success: boolean;
    error: string;
    data?: undefined;
}>;
/**
 * 根据PRD解析结果生成任务计划
 * @param prdResult PRD解析结果
 * @param options 规划选项
 */
declare function generateTaskPlan(prdResult: any, options?: any): Promise<{
    error: string | undefined;
    success?: undefined;
    data?: undefined;
} | {
    success: boolean;
    data: TaskPlan | undefined;
    error?: undefined;
}>;
/**
 * 生成测试用例
 * @param taskDescription 任务描述
 * @param options 测试生成选项
 */
declare function generateTests(taskDescription: string, options?: any): Promise<{
    success: boolean;
    data: ModelResponse;
    error?: undefined;
} | {
    error: string;
    success?: undefined;
    data?: undefined;
}>;

/**
 * TaskFlow AI MCP 服务类
 */
declare class TaskFlowService {
    private configManager;
    private logger;
    private modelCoordinator;
    private prdParser;
    private taskPlanner;
    private taskManager;
    /**
     * 创建TaskFlow AI MCP服务实例
     */
    constructor();
    /**
     * 解析PRD文档内容
     * @param content PRD文档内容
     * @param fileType 文件类型
     * @param options 解析选项
     */
    parsePRD(content: string, fileType?: FileType, options?: ParseOptions): Promise<ServiceResponse<PRDParseResult>>;
    /**
     * 从文件解析PRD
     * @param filePath PRD文件路径
     * @param options 解析选项
     */
    parsePRDFromFile(filePath: string, options?: ParseOptions): Promise<{
        success: boolean;
        data: ParsedPRD;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 根据PRD生成任务计划
     * @param prdResult PRD解析结果
     * @param options 规划选项
     */
    generateTaskPlan(prdResult: any, options?: PlanningOptions): Promise<{
        success: boolean;
        data: TaskPlan;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 保存任务计划
     * @param taskPlan 任务计划
     * @param outputPath 输出路径
     */
    saveTaskPlan(taskPlan: any, outputPath: string): Promise<{
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
    }>;
    /**
     * 加载任务计划
     * @param filePath 任务计划文件路径
     */
    loadTaskPlan(filePath: string): Promise<{
        success: boolean;
        data: TaskPlan;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取所有任务
     */
    getAllTasks(): {
        success: boolean;
        data: Task[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 根据ID获取任务
     * @param id 任务ID
     */
    getTaskById(id: string): {
        success: boolean;
        error: string;
        data?: undefined;
    } | {
        success: boolean;
        data: Task;
        error?: undefined;
    };
    /**
     * 过滤任务
     * @param filter 过滤条件
     */
    filterTasks(filter: TaskFilter): {
        success: boolean;
        data: Task[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 更新任务
     * @param id 任务ID
     * @param data 更新数据
     */
    updateTask(id: string, data: TaskUpdateData): {
        success: boolean;
        error: string;
        data?: undefined;
    } | {
        success: boolean;
        data: Task;
        error?: undefined;
    };
    /**
     * 获取下一个要处理的任务
     */
    getNextTasks(): {
        success: boolean;
        data: Task[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 使用聊天模型进行对话
     * @param messages 消息数组
     * @param modelType 模型类型
     * @param options 调用选项
     */
    chat(messages: any[], modelType?: ModelType, options?: any): Promise<{
        success: boolean;
        data: ModelResponse;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取所有可用的模型类型
     */
    getAvailableModelTypes(): {
        success: boolean;
        data: ModelType[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 验证指定类型模型的API密钥
     * @param modelType 模型类型
     */
    validateModelApiKey(modelType: ModelType): Promise<{
        success: boolean;
        data: {
            valid: boolean;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 更新配置
     * @param config 配置对象
     * @param isProjectLevel 是否为项目级配置
     */
    updateConfig(config: any, isProjectLevel?: boolean): {
        success: boolean;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
    };
    /**
     * 获取完整配置
     */
    getConfig(): {
        success: boolean;
        data: {
            [x: string]: unknown;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 获取任务状态概览
     */
    getTaskStatus(): {
        success: boolean;
        data: {
            total: number;
            pending: number;
            in_progress: number;
            completed: number;
            cancelled: number;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 更新任务状态
     * @param taskId 任务ID
     * @param status 新状态
     * @param data 额外数据
     */
    updateTaskStatus(taskId: string, status: string, data?: any): {
        success: boolean;
        error: string;
        data?: undefined;
    } | {
        success: boolean;
        data: Task;
        error?: undefined;
    };
    /**
     * 获取推荐任务
     */
    getRecommendedTask(): {
        success: boolean;
        data: Task | null;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    };
    /**
     * 生成可视化
     * @param type 可视化类型
     * @param options 选项
     */
    generateVisualization(type: string, options?: any): Promise<{
        success: boolean;
        data: {
            type: string;
            data: Task[];
            options: any;
            generatedAt: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 创建项目
     * @param projectData 项目数据
     */
    createProject(projectData: any): Promise<{
        success: boolean;
        data: any;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取项目列表
     * @param options 查询选项
     */
    getProjects(options?: any): Promise<{
        success: boolean;
        data: {
            id: string;
            name: string;
            description: string;
            status: string;
            createdAt: string;
        }[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取项目详情
     * @param id 项目ID
     */
    getProject(id: string): Promise<{
        success: boolean;
        data: {
            id: string;
            name: string;
            description: string;
            status: string;
            createdAt: string;
            tasks: Task[];
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 更新项目
     * @param id 项目ID
     * @param updateData 更新数据
     */
    updateProject(id: string, updateData: any): Promise<{
        success: boolean;
        data: any;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 删除项目
     * @param id 项目ID
     */
    deleteProject(id: string): Promise<{
        success: boolean;
        message: string;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        message?: undefined;
    }>;
    /**
     * 获取项目任务
     * @param id 项目ID
     * @param options 查询选项
     */
    getProjectTasks(id: string, options?: any): Promise<{
        success: boolean;
        data: Task[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取项目统计
     * @param id 项目ID
     */
    getProjectStats(id: string): Promise<{
        success: boolean;
        data: {
            totalTasks: number;
            completedTasks: number;
            inProgressTasks: number;
            pendingTasks: number;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 生成任务
     * @param req 请求对象
     * @param res 响应对象
     */
    generateTasks(req: any, res: any): Promise<{
        success: boolean;
        data: {
            id: string;
            title: string;
            description: string;
            status: string;
            priority: string;
        }[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 编排任务
     * @param req 请求对象
     * @param res 响应对象
     */
    orchestrateTasks(req: any, res: any): Promise<{
        success: boolean;
        data: any;
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 生成文档
     * @param req 请求对象
     * @param res 响应对象
     */
    generateDocuments(req: any, res: any): Promise<{
        success: boolean;
        data: {
            type: any;
            content: string;
            generatedAt: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 生成图表
     * @param req 请求对象
     * @param res 响应对象
     */
    generateCharts(req: any, res: any): Promise<{
        success: boolean;
        data: {
            type: any;
            data: any;
            options: any;
            generatedAt: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 聊天流式响应
     * @param req 请求对象
     * @param res 响应对象
     */
    chatStream(req: any, res: any): Promise<void>;
    /**
     * 获取模型列表
     * @param req 请求对象
     * @param res 响应对象
     */
    getModels(req: any, res: any): Promise<{
        success: boolean;
        data: ModelType[];
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取模型状态
     * @param req 请求对象
     * @param res 响应对象
     */
    getModelStatus(req: any, res: any): Promise<{
        success: boolean;
        data: {
            modelType: any;
            status: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 验证需求
     * @param req 请求对象
     * @param res 响应对象
     */
    validateRequirements(req: any, res: any): Promise<{
        success: boolean;
        data: {
            valid: boolean;
            issues: never[];
            suggestions: string[];
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 估算工作量
     * @param req 请求对象
     * @param res 响应对象
     */
    estimateEffort(req: any, res: any): Promise<{
        success: boolean;
        data: {
            totalHours: number;
            breakdown: any;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 获取使用统计
     * @param req 请求对象
     * @param res 响应对象
     */
    getUsageStats(req: any, res: any): Promise<{
        success: boolean;
        data: {
            totalRequests: number;
            successfulRequests: number;
            failedRequests: number;
            averageResponseTime: number;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 归档项目
     * @param req 请求对象
     * @param res 响应对象
     */
    archiveProject(req: any, res: any): Promise<{
        success: boolean;
        data: {
            id: any;
            status: string;
            archivedAt: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 恢复项目
     * @param id 项目ID
     */
    restoreProject(id: string): Promise<any>;
    /**
     * 恢复项目
     * @param req 请求对象
     * @param res 响应对象
     */
    restoreProject(req: any, res: any): Promise<any>;
    /**
     * 生成项目报告
     * @param id 项目ID
     * @param options 报告选项
     */
    generateProjectReport(id: string, options?: any): Promise<{
        success: boolean;
        data: {
            project: {
                id: string;
                name: string;
                description: string;
                status: string;
                createdAt: string;
                tasks: Task[];
            } | undefined;
            tasks: Task[];
            statistics: {
                totalTasks: number;
                completedTasks: number;
                inProgressTasks: number;
                pendingTasks: number;
            } | undefined;
            generatedAt: string;
            format: any;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 导出项目
     * @param id 项目ID
     * @param format 导出格式
     */
    exportProject(id: string, format: string): Promise<{
        success: boolean;
        data: {
            project: {
                id: string;
                name: string;
                description: string;
                status: string;
                createdAt: string;
                tasks: Task[];
            } | undefined;
            tasks: Task[];
            exportedAt: string;
            format: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
    /**
     * 克隆项目
     * @param id 项目ID
     * @param options 克隆选项
     */
    cloneProject(id: string, options: any): Promise<{
        success: boolean;
        data: {
            id: string;
            name: any;
            description: any;
            clonedFrom: string;
            createdAt: string;
        };
        error?: undefined;
    } | {
        success: boolean;
        error: string;
        data?: undefined;
    }>;
}
declare const taskFlowService: TaskFlowService;

/**
 * TaskFlow AI
 * 智能PRD文档解析与任务管理助手，专为开发团队设计的AI驱动任务编排工具
 */

declare const VERSION = "1.3.0";

export { FileType, LogLevel, MessageRole, ModelType, PRDParser, TaskFlowEngine, TaskFlowService, TaskManager, TaskPlanner, TaskPriority, TaskStatus, TaskType, TaskVisualizer, VERSION, VisualizationType, chat, executeTool, generateTaskPlan, generateTests, getAllTasks, getAvailableModelTypes, getConfig, getNextTasks, getServerInfo, getTaskById, getTools, parsePRD, parsePRDFromFile, taskFlowService, updateConfig, updateTaskStatus, validateModelApiKey };
export type { Feature, ModelCallOptions, PRDParseResult, ParseOptions, ParsedPRD, ServiceResponse, Task, TaskPlan };