openmatrix 0.1.0

package/dist/orchestrator/git-commit-manager.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitCommitManager = void 0;
+// src/orchestrator/git-commit-manager.ts
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * GitCommitManager - Git 自动提交管理器
+ *
+ * 功能:
+ * 1. 自动生成详细提交信息
+ * 2. 包含任务名、修改内容、影响范围
+ * 3. 支持每个子任务完成后自动提交
+ */
+class GitCommitManager {
+    repoPath;
+    enabled = true;
+    constructor(repoPath = process.cwd()) {
+        this.repoPath = repoPath;
+    }
+    /**
+     * 设置是否启用自动提交
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * 检查是否在 Git 仓库中
+     */
+    async isGitRepo() {
+        try {
+            await execAsync('git rev-parse --is-inside-work-tree', { cwd: this.repoPath });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 获取当前分支名
+     */
+    async getCurrentBranch() {
+        const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: this.repoPath });
+        return stdout.trim();
+    }
+    /**
+     * 获取未提交的文件列表
+     */
+    async getUncommittedFiles() {
+        try {
+            const { stdout } = await execAsync('git status --porcelain', { cwd: this.repoPath });
+            return stdout
+                .split('\n')
+                .filter(line => line.trim())
+                .map(line => line.slice(3).trim());
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 获取已修改的文件差异统计
+     */
+    async getDiffStats() {
+        const stats = new Map();
+        try {
+            const { stdout } = await execAsync('git diff --stat', { cwd: this.repoPath });
+            const lines = stdout.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                const match = line.match(/^(.+?)\s+\|\s+(\d+)\s+([+-]+)/);
+                if (match) {
+                    const file = match[1].trim();
+                    const changes = match[3] || '';
+                    stats.set(file, {
+                        additions: (changes.match(/\+/g) || []).length,
+                        deletions: (changes.match(/-/g) || []).length
+                    });
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return stats;
+    }
+    /**
+     * 分析影响范围
+     */
+    async analyzeImpactScope(files) {
+        const scopes = new Set();
+        for (const file of files) {
+            // 根据文件路径分析影响范围
+            if (file.includes('src/cli/'))
+                scopes.add('CLI');
+            if (file.includes('src/orchestrator/'))
+                scopes.add('Orchestrator');
+            if (file.includes('src/agents/'))
+                scopes.add('Agents');
+            if (file.includes('src/storage/'))
+                scopes.add('Storage');
+            if (file.includes('src/types/'))
+                scopes.add('Types');
+            if (file.includes('skills/'))
+                scopes.add('Skills');
+            if (file.includes('docs/'))
+                scopes.add('Documentation');
+            if (file.includes('tests/'))
+                scopes.add('Tests');
+            if (file.endsWith('.md'))
+                scopes.add('Documentation');
+            if (file.endsWith('package.json'))
+                scopes.add('Dependencies');
+            if (file.endsWith('tsconfig.json'))
+                scopes.add('TypeScript Config');
+        }
+        return Array.from(scopes);
+    }
+    /**
+     * 生成提交信息
+     */
+    generateCommitMessage(info) {
+        const lines = [];
+        // 标题行 - 包含任务 ID 和标题
+        const phaseEmoji = {
+            tdd: '🧪',
+            develop: '✨',
+            verify: '✅',
+            accept: '🎉'
+        };
+        const title = info.taskTitle.length > 50
+            ? info.taskTitle.slice(0, 47) + '...'
+            : info.taskTitle;
+        lines.push(`${phaseEmoji[info.phase]} (${info.taskId}): ${title}`);
+        lines.push('');
+        // 修改内容
+        if (info.changes.length > 0) {
+            lines.push('## 修改内容');
+            for (const change of info.changes.slice(0, 10)) {
+                lines.push(`- ${change}`);
+            }
+            if (info.changes.length > 10) {
+                lines.push(`- ... 及其他 ${info.changes.length - 10} 项修改`);
+            }
+            lines.push('');
+        }
+        // 影响范围
+        if (info.impactScope.length > 0) {
+            lines.push('## 影响范围');
+            lines.push(`模块: ${info.impactScope.join(', ')}`);
+            lines.push('');
+        }
+        // 元数据
+        lines.push('---');
+        lines.push(`Task-ID: ${info.taskId}`);
+        lines.push(`Run-ID: ${info.runId}`);
+        lines.push(`Phase: ${info.phase}`);
+        lines.push(`Co-Authored-By: OpenMatrix Agent <agent@openmatrix.dev>`);
+        return lines.join('\n');
+    }
+    /**
+     * 执行提交
+     */
+    async commit(info) {
+        if (!this.enabled) {
+            return { success: false, message: 'Auto-commit is disabled' };
+        }
+        try {
+            // 检查是否在 Git 仓库中
+            if (!await this.isGitRepo()) {
+                return { success: false, error: 'Not a git repository' };
+            }
+            // 获取未提交的文件
+            const files = await this.getUncommittedFiles();
+            if (files.length === 0) {
+                return { success: false, message: 'No changes to commit' };
+            }
+            // 分析影响范围
+            const impactScope = await this.analyzeImpactScope(files);
+            // 更新 commit info
+            const fullInfo = {
+                ...info,
+                changes: files,
+                impactScope: info.impactScope.length > 0 ? info.impactScope : impactScope
+            };
+            // 生成提交信息
+            const commitMessage = this.generateCommitMessage(fullInfo);
+            // 添加所有文件
+            await execAsync('git add -A', { cwd: this.repoPath });
+            // 执行提交
+            const { stdout } = await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd: this.repoPath });
+            // 提取 commit hash
+            const hashMatch = stdout.match(/\[.+?\s+([a-f0-9]+)\]/);
+            const commitHash = hashMatch ? hashMatch[1] : undefined;
+            return {
+                success: true,
+                commitHash,
+                message: `Committed ${files.length} files`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    /**
+     * 提交任务完成
+     */
+    async commitTaskCompletion(task, runId) {
+        return this.commit({
+            taskId: task.id,
+            taskTitle: task.title,
+            runId,
+            phase: 'develop',
+            changes: [],
+            impactScope: []
+        });
+    }
+    /**
+     * 提交验证阶段完成
+     */
+    async commitVerifyComplete(task, runId, testResults) {
+        return this.commit({
+            taskId: task.id,
+            taskTitle: task.title,
+            runId,
+            phase: 'verify',
+            changes: testResults,
+            impactScope: ['Tests']
+        });
+    }
+    /**
+     * 提交验收阶段完成
+     */
+    async commitAcceptComplete(task, runId) {
+        return this.commit({
+            taskId: task.id,
+            taskTitle: task.title,
+            runId,
+            phase: 'accept',
+            changes: [],
+            impactScope: []
+        });
+    }
+}
+exports.GitCommitManager = GitCommitManager;

package/dist/orchestrator/interactive-question-generator.d.ts

@@ -0,0 +1,90 @@
+import type { ParsedTask } from '../types/index.js';
+/**
+ * 交互式问题 - 支持多轮追问
+ */
+export interface InteractiveQuestion {
+    id: string;
+    question: string;
+    type: 'single' | 'multiple' | 'text' | 'confirm';
+    options?: QuestionOption[];
+    required: boolean;
+    /** 追问条件 - 根据回答触发 */
+    followUpCondition?: {
+        /** 触发追问的选项 key */
+        triggerKeys: string[];
+        /** 追问问题 */
+        followUpQuestions: InteractiveQuestion[];
+    };
+    /** 问题分类 */
+    category: 'objective' | 'technical' | 'scope' | 'quality' | 'constraint' | 'risk';
+    /** 优先级 (1-7, 1 最高) */
+    priority: number;
+}
+export interface QuestionOption {
+    key: string;
+    label: string;
+    description?: string;
+}
+export interface QuestionAnswer {
+    questionId: string;
+    selectedKeys: string[];
+    textValue?: string;
+}
+export interface QuestionSession {
+    sessionId: string;
+    taskId: string;
+    questions: InteractiveQuestion[];
+    answers: QuestionAnswer[];
+    currentQuestionIndex: number;
+    status: 'pending' | 'in_progress' | 'completed';
+    createdAt: string;
+    completedAt?: string;
+}
+/**
+ * InteractiveQuestionGenerator - 交互式问题生成器
+ *
+ * 特性:
+ * 1. 多轮追问 - 根据回答动态生成新问题
+ * 2. 优先级排序 - 按重要性顺序提问
+ * 3. 条件分支 - 不同回答触发不同追问
+ * 4. 交互友好 - 支持单步/批量回答
+ */
+export declare class InteractiveQuestionGenerator {
+    private session;
+    /**
+     * 开始新的问答会话
+     */
+    startSession(parsedTask: ParsedTask): QuestionSession;
+    /**
+     * 获取当前问题
+     */
+    getCurrentQuestion(): InteractiveQuestion | null;
+    /**
+     * 获取下一个问题 (支持交互式逐个提问)
+     */
+    getNextQuestion(): InteractiveQuestion | null;
+    /**
+     * 回答当前问题
+     */
+    answerCurrentQuestion(answer: QuestionAnswer): InteractiveQuestion | null;
+    /**
+     * 批量回答问题
+     */
+    answerMultiple(answers: QuestionAnswer[]): QuestionSession;
+    /**
+     * 获取会话状态
+     */
+    getSession(): QuestionSession | null;
+    /**
+     * 获取所有问题和答案的摘要
+     */
+    getSummary(): string;
+    /**
+     * 生成基础问题集
+     */
+    private generateBaseQuestions;
+    /**
+     * 根据任务内容动态添加问题
+     */
+    addContextualQuestions(task: ParsedTask, questions: InteractiveQuestion[]): InteractiveQuestion[];
+}

package/dist/orchestrator/interactive-question-generator.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveQuestionGenerator = void 0;
+/**
+ * InteractiveQuestionGenerator - 交互式问题生成器
+ *
+ * 特性:
+ * 1. 多轮追问 - 根据回答动态生成新问题
+ * 2. 优先级排序 - 按重要性顺序提问
+ * 3. 条件分支 - 不同回答触发不同追问
+ * 4. 交互友好 - 支持单步/批量回答
+ */
+class InteractiveQuestionGenerator {
+    session = null;
+    /**
+     * 开始新的问答会话
+     */
+    startSession(parsedTask) {
+        const baseQuestions = this.generateBaseQuestions(parsedTask);
+        this.session = {
+            sessionId: `qs-${Date.now().toString(36)}`,
+            taskId: parsedTask.title,
+            questions: baseQuestions.sort((a, b) => a.priority - b.priority),
+            answers: [],
+            currentQuestionIndex: 0,
+            status: 'in_progress',
+            createdAt: new Date().toISOString()
+        };
+        return this.session;
+    }
+    /**
+     * 获取当前问题
+     */
+    getCurrentQuestion() {
+        if (!this.session || this.session.status !== 'in_progress') {
+            return null;
+        }
+        return this.session.questions[this.session.currentQuestionIndex] || null;
+    }
+    /**
+     * 获取下一个问题 (支持交互式逐个提问)
+     */
+    getNextQuestion() {
+        if (!this.session || this.session.status !== 'in_progress') {
+            return null;
+        }
+        // 检查是否有追问
+        const lastAnswer = this.session.answers[this.session.answers.length - 1];
+        if (lastAnswer) {
+            const lastQuestion = this.session.questions.find(q => q.id === lastAnswer.questionId);
+            if (lastQuestion?.followUpCondition) {
+                const shouldFollowUp = lastQuestion.followUpCondition.triggerKeys.some(key => lastAnswer.selectedKeys.includes(key));
+                if (shouldFollowUp) {
+                    // 插入追问到队列
+                    const followUps = lastQuestion.followUpCondition.followUpQuestions;
+                    const insertIndex = this.session.currentQuestionIndex + 1;
+                    this.session.questions.splice(insertIndex, 0, ...followUps);
+                }
+            }
+        }
+        this.session.currentQuestionIndex++;
+        if (this.session.currentQuestionIndex >= this.session.questions.length) {
+            this.session.status = 'completed';
+            this.session.completedAt = new Date().toISOString();
+            return null;
+        }
+        return this.session.questions[this.session.currentQuestionIndex];
+    }
+    /**
+     * 回答当前问题
+     */
+    answerCurrentQuestion(answer) {
+        if (!this.session) {
+            throw new Error('No active session');
+        }
+        // 记录答案
+        this.session.answers.push(answer);
+        // 获取下一个问题
+        return this.getNextQuestion();
+    }
+    /**
+     * 批量回答问题
+     */
+    answerMultiple(answers) {
+        if (!this.session) {
+            throw new Error('No active session');
+        }
+        for (const answer of answers) {
+            this.session.answers.push(answer);
+        }
+        // 处理追问
+        for (const answer of answers) {
+            const question = this.session.questions.find(q => q.id === answer.questionId);
+            if (question?.followUpCondition) {
+                const shouldFollowUp = question.followUpCondition.triggerKeys.some(key => answer.selectedKeys.includes(key));
+                if (shouldFollowUp) {
+                    this.session.questions.push(...question.followUpCondition.followUpQuestions);
+                }
+            }
+        }
+        this.session.status = 'completed';
+        this.session.completedAt = new Date().toISOString();
+        return this.session;
+    }
+    /**
+     * 获取会话状态
+     */
+    getSession() {
+        return this.session;
+    }
+    /**
+     * 获取所有问题和答案的摘要
+     */
+    getSummary() {
+        if (!this.session) {
+            return 'No active session';
+        }
+        const lines = ['## 问题回答摘要\n'];
+        for (const answer of this.session.answers) {
+            const question = this.session.questions.find(q => q.id === answer.questionId);
+            if (question) {
+                const answerText = answer.textValue ||
+                    answer.selectedKeys.map(k => {
+                        const opt = question.options?.find(o => o.key === k);
+                        return opt?.label || k;
+                    }).join(', ');
+                lines.push(`**${question.question}**`);
+                lines.push(`> ${answerText}\n`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 生成基础问题集
+     */
+    generateBaseQuestions(task) {
+        const questions = [];
+        // 1. 核心目标
+        questions.push({
+            id: 'objective',
+            question: '这个任务的主要目标是什么？',
+            type: 'single',
+            required: true,
+            category: 'objective',
+            priority: 1,
+            options: [
+                { key: 'new_feature', label: '实现新功能', description: '添加新的功能特性' },
+                { key: 'bug_fix', label: '修复 Bug', description: '修复已知问题' },
+                { key: 'refactor', label: '重构优化', description: '改进代码结构或性能' },
+                { key: 'other', label: '其他', description: '其他类型任务' }
+            ],
+            followUpCondition: {
+                triggerKeys: ['other'],
+                followUpQuestions: [
+                    {
+                        id: 'objective_other_detail',
+                        question: '请详细描述任务目标:',
+                        type: 'text',
+                        required: true,
+                        category: 'objective',
+                        priority: 1.5
+                    }
+                ]
+            }
+        });
+        // 2. 技术栈
+        questions.push({
+            id: 'tech_stack',
+            question: '使用什么技术栈？',
+            type: 'multiple',
+            required: true,
+            category: 'technical',
+            priority: 2,
+            options: [
+                { key: 'typescript', label: 'TypeScript', description: '类型安全的 JavaScript' },
+                { key: 'javascript', label: 'JavaScript', description: '标准 JavaScript' },
+                { key: 'react', label: 'React', description: 'React 前端框架' },
+                { key: 'vue', label: 'Vue', description: 'Vue 前端框架' },
+                { key: 'node', label: 'Node.js', description: 'Node.js 后端' },
+                { key: 'python', label: 'Python', description: 'Python 语言' },
+                { key: 'other', label: '其他', description: '其他技术栈' }
+            ],
+            followUpCondition: {
+                triggerKeys: ['other'],
+                followUpQuestions: [
+                    {
+                        id: 'tech_stack_other_detail',
+                        question: '请描述使用的技术栈:',
+                        type: 'text',
+                        required: true,
+                        category: 'technical',
+                        priority: 2.5
+                    }
+                ]
+            }
+        });
+        // 3. 数据存储
+        questions.push({
+            id: 'data_storage',
+            question: '需要什么类型的存储？',
+            type: 'single',
+            required: true,
+            category: 'technical',
+            priority: 3,
+            options: [
+                { key: 'postgresql', label: 'PostgreSQL', description: '关系型数据库' },
+                { key: 'mongodb', label: 'MongoDB', description: '文档数据库' },
+                { key: 'sqlite', label: 'SQLite', description: '本地数据库' },
+                { key: 'none', label: '无需存储', description: '不需要数据持久化' }
+            ]
+        });
+        // 4. 认证方式
+        questions.push({
+            id: 'auth_method',
+            question: '需要用户认证吗？',
+            type: 'single',
+            required: true,
+            category: 'technical',
+            priority: 4,
+            options: [
+                { key: 'jwt', label: 'JWT Token', description: '无状态认证' },
+                { key: 'oauth', label: 'OAuth 2.0', description: '第三方授权' },
+                { key: 'session', label: 'Session Cookie', description: '传统会话' },
+                { key: 'none', label: '无需认证', description: '无用户系统' }
+            ]
+        });
+        // 5. API 风格
+        questions.push({
+            id: 'api_style',
+            question: 'API 采用什么风格？',
+            type: 'single',
+            required: true,
+            category: 'technical',
+            priority: 5,
+            options: [
+                { key: 'rest', label: 'RESTful', description: 'REST API' },
+                { key: 'graphql', label: 'GraphQL', description: 'GraphQL API' },
+                { key: 'grpc', label: 'gRPC', description: '高性能 RPC' },
+                { key: 'mixed', label: '混合', description: '多种风格混合' }
+            ]
+        });
+        // 6. 测试要求
+        questions.push({
+            id: 'test_coverage',
+            question: '测试覆盖率要求？',
+            type: 'single',
+            required: true,
+            category: 'quality',
+            priority: 6,
+            options: [
+                { key: 'high', label: '>80% (严格)', description: '完整单元测试和集成测试' },
+                { key: 'medium', label: '>60% (标准)', description: '核心功能测试' },
+                { key: 'low', label: '>40% (基础)', description: '关键路径测试' },
+                { key: 'none', label: '无要求', description: '不需要测试' }
+            ]
+        });
+        // 7. 文档要求
+        questions.push({
+            id: 'doc_level',
+            question: '需要什么级别的文档？',
+            type: 'single',
+            required: true,
+            category: 'quality',
+            priority: 7,
+            options: [
+                { key: 'full', label: '完整文档', description: 'API + 使用指南 + 架构' },
+                { key: 'basic', label: '基础文档', description: 'README + API' },
+                { key: 'minimal', label: '最小文档', description: '仅 README' },
+                { key: 'none', label: '无需文档', description: '不生成文档' }
+            ]
+        });
+        return questions;
+    }
+    /**
+     * 根据任务内容动态添加问题
+     */
+    addContextualQuestions(task, questions) {
+        // 如果有多个目标，询问优先级
+        if (task.goals.length > 1) {
+            questions.push({
+                id: 'goal_priority',
+                question: '以下目标中，哪些是核心必须完成的？（可多选）',
+                type: 'multiple',
+                required: true,
+                category: 'scope',
+                priority: 1.5,
+                options: task.goals.map((goal, index) => ({
+                    key: `goal_${index}`,
+                    label: goal.slice(0, 50) + (goal.length > 50 ? '...' : '')
+                }))
+            });
+        }
+        // 如果有约束条件，确认是否遵循
+        if (task.constraints.length > 0) {
+            questions.push({
+                id: 'constraints_confirm',
+                question: '请确认约束条件:',
+                type: 'confirm',
+                required: true,
+                category: 'constraint',
+                priority: 3.5,
+                options: [
+                    { key: 'confirm', label: '确认遵循所有约束', description: '按照约束条件执行' },
+                    { key: 'modify', label: '需要调整约束', description: '部分约束需要修改' },
+                    { key: 'ignore', label: '忽略约束', description: '不遵循约束条件' }
+                ]
+            });
+        }
+        return questions;
+    }
+}
+exports.InteractiveQuestionGenerator = InteractiveQuestionGenerator;