team-anya 0.1.0

package/packages/mcp-tools/dist/layer2/loid/delivery-upload.js

@@ -0,0 +1,18 @@
+import { fileUpload } from '../../layer3/file-upload.js';
+/**
+ * delivery.upload - 上传文件产物
+ *
+ * 委托给 file.upload 实现。target 参数暂不使用（预留给后续上传到指定位置的场景）。
+ */
+export async function deliveryUpload(deps, input) {
+    const result = await fileUpload(deps, {
+        file_path: input.file_path,
+    });
+    return {
+        status: 'uploaded',
+        url: result.url,
+        file_name: result.file_name,
+        file_size: result.file_size,
+    };
+}
+//# sourceMappingURL=delivery-upload.js.map

package/packages/mcp-tools/dist/layer2/loid/project-remove.js

@@ -0,0 +1,16 @@
+import { getProject, softDeleteProject, insertAuditEvent } from '@team-anya/db';
+export async function projectRemove(db, _workspacePath, input) {
+    const existing = getProject(db, input.project_id);
+    if (!existing) {
+        return { removed: false, message: `Project ${input.project_id} not found` };
+    }
+    softDeleteProject(db, input.project_id);
+    insertAuditEvent(db, {
+        event_type: 'project_removed',
+        actor: 'loid',
+        summary: `Project ${input.project_id} soft-deleted: ${input.reason}`,
+        detail: JSON.stringify({ project_id: input.project_id, reason: input.reason }),
+    });
+    return { removed: true, message: `Project ${input.project_id} archived` };
+}
+//# sourceMappingURL=project-remove.js.map

package/packages/mcp-tools/dist/layer2/loid/project-upsert.js

@@ -0,0 +1,33 @@
+import { getProject, upsertProject, syncProjectRepos, insertAuditEvent } from '@team-anya/db';
+export async function projectUpsert(db, _workspacePath, input) {
+    const existing = getProject(db, input.project_id);
+    const action = existing ? 'updated' : 'created';
+    upsertProject(db, {
+        project_id: input.project_id,
+        name: input.name,
+        description: input.description ?? null,
+        platform: input.platform ?? 'github',
+        claude_md: input.claude_md ?? null,
+    });
+    const repos = input.repos ?? [];
+    if (repos.length > 0) {
+        syncProjectRepos(db, input.project_id, repos.map(r => ({
+            name: r.name,
+            git_url: r.git_url,
+            repo_path: r.repo_path,
+            default_branch: r.default_branch ?? 'main',
+        })));
+    }
+    insertAuditEvent(db, {
+        event_type: `project_${action}`,
+        actor: 'loid',
+        summary: `Project ${input.project_id} ${action}`,
+        detail: JSON.stringify({
+            project_id: input.project_id,
+            platform: input.platform ?? 'github',
+            repo_count: repos.length,
+        }),
+    });
+    return { project_id: input.project_id, action };
+}
+//# sourceMappingURL=project-upsert.js.map

package/packages/mcp-tools/dist/layer2/loid/task-dispatch.js

@@ -0,0 +1,177 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { execFile as execFileCb } from 'node:child_process';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { createTask, updateTask, insertAuditEvent, getTodayMaxSequence, } from '@team-anya/db';
+import { TaskStatus, generateTaskId, assertTransition } from '@team-anya/core';
+const execFile = promisify(execFileCb);
+/**
+ * 创建任务、写 brief、自动准备工作区
+ *
+ * 派工两步走：task.dispatch(MCP) → yor.spawn(MCP)
+ * dispatch 内部自动根据 project mode 准备隔离工作区（git worktree / mkdir）。
+ * 工作区准备失败时标记 BLOCKED 并返回 error，不抛异常。
+ */
+export async function taskDispatch(deps, input) {
+    const { db, workspacePath, logger } = deps;
+    const seq = getTodayMaxSequence(db) + 1;
+    const taskId = generateTaskId(seq);
+    // 1. 创建任务
+    createTask(db, {
+        task_id: taskId,
+        title: input.title,
+        status: TaskStatus.NEW,
+        source_type: 'feishu',
+        source_ref: input.source_message_id ?? null,
+        objective: input.objective,
+        acceptance_criteria: input.acceptance_criteria ? JSON.stringify(input.acceptance_criteria) : undefined,
+        context: input.context,
+        project_id: input.project_id,
+        created_by: input.created_by ?? null,
+        source_chat_id: input.source_chat_id ?? null,
+    });
+    // 2. 写 brief 到 workspace
+    const taskDir = join(workspacePath, 'yor', 'tasks', taskId);
+    await mkdir(taskDir, { recursive: true });
+    const briefPath = join(taskDir, 'brief.md');
+    await writeFile(briefPath, input.brief, 'utf-8');
+    // 3. 审计日志
+    insertAuditEvent(db, {
+        event_type: 'task_dispatched',
+        actor: 'loid',
+        task_id: taskId,
+        summary: `Loid 派工: ${input.title}`,
+        detail: JSON.stringify({ brief_length: input.brief.length, project: input.project_id }),
+    });
+    // 4. 获取项目配置
+    const project = deps.getProjectConfig
+        ? await deps.getProjectConfig(input.project_id)
+        : undefined;
+    logger?.info(`[anya:pipeline] [Loid] 创建任务 ${taskId} "${input.title}"${input.project_id ? ` | project=${input.project_id} mode=${project?.mode}` : ''}`);
+    // 5. 自动准备工作区
+    const workspaceResult = await prepareWorkspace(taskId, taskDir, project, logger);
+    if (!workspaceResult.ok) {
+        // 工作区准备失败 → NEW → BLOCKED（经状态机校验）
+        assertTransition(TaskStatus.NEW, TaskStatus.BLOCKED);
+        updateTask(db, taskId, { status: TaskStatus.BLOCKED });
+        insertAuditEvent(db, {
+            event_type: 'task_status_changed',
+            actor: 'loid',
+            task_id: taskId,
+            summary: `NEW → BLOCKED: 工作区准备失败: ${workspaceResult.error}`,
+            detail: JSON.stringify({ from: 'NEW', to: 'BLOCKED', reason: workspaceResult.error }),
+        });
+        return { task_id: taskId, status: 'blocked', brief_path: briefPath, error: workspaceResult.error };
+    }
+    // 6. 工作区就绪 → NEW → READY，同时回写工作区信息
+    assertTransition(TaskStatus.NEW, TaskStatus.READY);
+    const branchName = project?.mode === 'project' ? `feat/anya-${taskId}` : undefined;
+    updateTask(db, taskId, {
+        status: TaskStatus.READY,
+        workspace_path: workspaceResult.workingDir,
+        assignee: 'yor',
+        ...(branchName ? { branch: branchName } : {}),
+    });
+    insertAuditEvent(db, {
+        event_type: 'task_status_changed',
+        actor: 'loid',
+        task_id: taskId,
+        summary: 'NEW → READY: 工作区准备完成',
+        detail: JSON.stringify({ from: 'NEW', to: 'READY', workspace_path: workspaceResult.workingDir, branch: branchName }),
+    });
+    return { task_id: taskId, status: 'dispatched', brief_path: briefPath, working_dir: workspaceResult.workingDir };
+}
+async function prepareWorkspace(taskId, taskDir, project, logger) {
+    const mode = project?.mode ?? 'adhoc';
+    try {
+        switch (mode) {
+            case 'project': {
+                const repos = project.repos;
+                const workingDir = taskDir;
+                const createdWorktrees = [];
+                try {
+                    for (const repo of repos) {
+                        const defaultBranch = repo.default_branch ?? 'main';
+                        const wtPath = join(workingDir, repo.name);
+                        await execFile('git', ['-C', repo.repo_path, 'fetch', 'origin']);
+                        await execFile('git', ['-C', repo.repo_path, 'worktree', 'add', wtPath, '-b', `feat/anya-${taskId}`, `origin/${defaultBranch}`]);
+                        createdWorktrees.push({ repoPath: repo.repo_path, wtPath });
+                    }
+                }
+                catch (err) {
+                    // 回滚已创建的 worktree
+                    for (const wt of createdWorktrees) {
+                        try {
+                            await execFile('git', ['-C', wt.repoPath, 'worktree', 'remove', wt.wtPath, '--force']);
+                        }
+                        catch {
+                            // 回滚失败忽略
+                        }
+                    }
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return { ok: false, error: `worktree 准备失败: ${msg}` };
+                }
+                // git init 为 CC 提供项目边界（防止全局搜索）
+                await execFile('git', ['init', workingDir]);
+                // .gitignore 忽略所有 worktree 子目录（它们各自有独立的 .git）
+                const ignoreContent = repos.map(r => `/${r.name}/`).join('\n') + '\n';
+                await writeFile(join(workingDir, '.gitignore'), ignoreContent, 'utf-8');
+                // 写入 CLAUDE.md 帮助 CC 理解工作区结构
+                const claudeMd = buildProjectClaudeMd(taskId, repos, project.claudeMd);
+                await writeFile(join(workingDir, 'CLAUDE.md'), claudeMd, 'utf-8');
+                // 提交到 git，否则 CC 不会加载 untracked 的 CLAUDE.md
+                await execFile('git', ['-C', workingDir, 'add', 'CLAUDE.md', '.gitignore']);
+                await execFile('git', ['-C', workingDir, 'commit', '-m', 'init: workspace config']);
+                logger?.info(`[anya:pipeline] [Loid] worktrees 已创建 (${repos.length} repos): ${workingDir}`);
+                return { ok: true, workingDir };
+            }
+            case 'adhoc':
+            default: {
+                const workingDir = taskDir;
+                await mkdir(join(workingDir, 'adhoc'), { recursive: true });
+                // 在任务级目录 git init，版本管理整个任务目录
+                await execFile('git', ['init', workingDir]);
+                await writeFile(join(workingDir, '.gitignore'), '*.tmp\nnode_modules/\n.DS_Store\n', 'utf-8');
+                await execFile('git', ['-C', workingDir, 'add', '.']);
+                await execFile('git', ['-C', workingDir, 'commit', '-m', `chore: init task ${taskId}`]);
+                logger?.info(`[anya:pipeline] [Loid] adhoc 目录已创建并 git init: ${workingDir}`);
+                return { ok: true, workingDir };
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `工作区准备失败 (${mode}): ${msg}` };
+    }
+}
+// ── 工作区 CLAUDE.md 生成 ──
+function buildProjectClaudeMd(taskId, repos, projectClaudeMd) {
+    const lines = [
+        `# 任务工作区 ${taskId}`,
+        '',
+        '本目录是任务工作区根目录。每个子目录是一个独立的 git worktree。',
+        '',
+        '## 仓库列表',
+        '',
+        '| 目录 | 分支 |',
+        '|------|------|',
+    ];
+    for (const repo of repos) {
+        lines.push(`| \`${repo.name}/\` | \`feat/anya-${taskId}\` (基于 ${repo.default_branch}) |`);
+    }
+    lines.push('');
+    lines.push('## 重要');
+    lines.push('');
+    lines.push('- 每个子目录是独立的 git 仓库（worktree），搜索代码时请进入对应子目录');
+    lines.push('- git 操作（add/commit/push）必须在对应子目录内执行');
+    lines.push('- 不要在根目录执行 git commit');
+    lines.push('- 任务产物请读取 `brief.md` 了解详情');
+    if (projectClaudeMd) {
+        lines.push('');
+        lines.push('## 项目技术栈');
+        lines.push('');
+        lines.push(projectClaudeMd);
+    }
+    return lines.join('\n') + '\n';
+}
+//# sourceMappingURL=task-dispatch.js.map

package/packages/mcp-tools/dist/layer2/loid/task-lookup.js

@@ -0,0 +1,38 @@
+import { getTask, getTasksByStatus } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+/**
+ * 查询任务状态和历史
+ *
+ * 可按 task_id 或 status 过滤。不传参数时返回所有活跃任务。
+ */
+export async function taskLookup(db, input) {
+    let tasks;
+    if (input.task_id) {
+        const task = getTask(db, input.task_id);
+        tasks = task ? [task] : [];
+    }
+    else if (input.status) {
+        tasks = getTasksByStatus(db, input.status);
+    }
+    else {
+        // 默认返回活跃任务
+        tasks = [
+            ...getTasksByStatus(db, TaskStatus.IN_PROGRESS),
+            ...getTasksByStatus(db, TaskStatus.READY),
+            ...getTasksByStatus(db, TaskStatus.NEED_CLARIFICATION),
+            ...getTasksByStatus(db, TaskStatus.DELIVERING),
+            ...getTasksByStatus(db, TaskStatus.BLOCKED),
+        ];
+    }
+    return {
+        tasks: tasks.map(t => ({
+            task_id: t.task_id,
+            title: t.title,
+            status: t.status,
+            assignee: t.assignee,
+            created_at: t.created_at,
+            pr_url: t.pr_url ?? null,
+        })),
+    };
+}
+//# sourceMappingURL=task-lookup.js.map

package/packages/mcp-tools/dist/layer2/loid/task-review.js

@@ -0,0 +1,151 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getTask, updateTask, insertAuditEvent, getMessageLogBySourceRef, } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+/**
+ * 验收审核（合并 approve_delivery + reject_delivery）
+ *
+ * 支持三级判断：
+ * - PASS: 验收通过 → DONE + 通知人类
+ * - REVISE: 打回返工 → retry_count++ + feedback + 重派
+ * - ESCALATE: 升级 → BLOCKED + 通知人类
+ */
+export async function taskReview(deps, input) {
+    const { db, workspacePath, dispatcher, logger } = deps;
+    const task = getTask(db, input.task_id);
+    if (!task) {
+        return {
+            task_id: input.task_id,
+            judgment: input.judgment,
+            success: false,
+            message: '任务不存在',
+        };
+    }
+    switch (input.judgment) {
+        case 'PASS': {
+            updateTask(db, input.task_id, { status: TaskStatus.DONE });
+            insertAuditEvent(db, {
+                event_type: 'delivery_approved',
+                actor: 'loid',
+                task_id: input.task_id,
+                summary: `Loid 验收通过: ${input.summary ?? '无评语'}`,
+            });
+            // 通知人类
+            let notified = false;
+            if (input.notify_human !== false && deps.channelSend) {
+                try {
+                    let chatId = null;
+                    if (task.source_ref) {
+                        const sourceMsg = getMessageLogBySourceRef(db, task.source_ref);
+                        chatId = sourceMsg?.chat_id ?? null;
+                    }
+                    if (chatId) {
+                        const prPart = task.pr_url ? `，PR: ${task.pr_url}` : '';
+                        await deps.channelSend(`feishu://${chatId}`, `${input.task_id} 搞定了——${input.summary ?? task.title}${prPart}`, { task_id: input.task_id });
+                        notified = true;
+                    }
+                }
+                catch (err) {
+                    logger?.error(`[anya:pipeline] [Loid] 任务完成通知发送失败 (${input.task_id}):`, err);
+                }
+            }
+            logger?.info(`[anya:pipeline] [Loid] 验收通过 ${input.task_id}${notified ? ' (已通知)' : ''}`);
+            return { task_id: input.task_id, judgment: 'PASS', success: true, notified };
+        }
+        case 'REVISE': {
+            const retryCount = (task.retry_count ?? 0) + 1;
+            const maxRetries = task.max_retries ?? 3;
+            if (retryCount > maxRetries) {
+                // 超过最大重试次数，标记为 BLOCKED
+                updateTask(db, input.task_id, {
+                    status: TaskStatus.BLOCKED,
+                    blocked_reason: `超过最大返工次数 (${maxRetries}): ${input.feedback ?? '未说明'}`,
+                    blocked_since: new Date().toISOString(),
+                    retry_count: retryCount,
+                });
+                insertAuditEvent(db, {
+                    event_type: 'delivery_rejected_max_retries',
+                    actor: 'loid',
+                    task_id: input.task_id,
+                    summary: `Loid 打回但已达上限 (${retryCount}/${maxRetries}): ${input.feedback ?? ''}`,
+                });
+                logger?.info(`[anya:pipeline] [Loid] 打回 ${input.task_id} (已达上限 ${retryCount}/${maxRetries}, BLOCKED)`);
+                return {
+                    task_id: input.task_id,
+                    judgment: 'REVISE',
+                    success: true,
+                    retry_count: retryCount,
+                    max_retries: maxRetries,
+                    blocked: true,
+                    message: `已达最大返工次数 ${maxRetries}，任务已阻塞`,
+                };
+            }
+            // 更新任务状态和反馈
+            updateTask(db, input.task_id, {
+                status: TaskStatus.READY,
+                retry_count: retryCount,
+                blocked_reason: null,
+                blocked_since: null,
+            });
+            // 写返工反馈
+            const taskDir = join(workspacePath, 'yor', input.task_id);
+            await mkdir(taskDir, { recursive: true });
+            const feedbackContent = `# 返工反馈 (第 ${retryCount} 次)\n\n## 打回原因\n${input.feedback ?? '未说明'}\n\n## 修改意见\n${input.feedback ?? '无'}\n`;
+            await writeFile(join(taskDir, `feedback-${retryCount}.md`), feedbackContent, 'utf-8');
+            insertAuditEvent(db, {
+                event_type: 'delivery_rejected',
+                actor: 'loid',
+                task_id: input.task_id,
+                summary: `Loid 打回 (${retryCount}/${maxRetries}): ${input.feedback ?? ''}`,
+                detail: JSON.stringify({ feedback: input.feedback }),
+            });
+            // 重新派工
+            if (dispatcher) {
+                await dispatcher.dispatch(input.task_id);
+            }
+            logger?.info(`[anya:pipeline] [Loid] 打回 ${input.task_id} → 返工 (${retryCount}/${maxRetries})`);
+            return {
+                task_id: input.task_id,
+                judgment: 'REVISE',
+                success: true,
+                retry_count: retryCount,
+                max_retries: maxRetries,
+            };
+        }
+        case 'ESCALATE': {
+            updateTask(db, input.task_id, {
+                status: TaskStatus.BLOCKED,
+                blocked_reason: `需人类决策: ${input.escalation_note ?? '未说明'}`,
+                blocked_since: new Date().toISOString(),
+            });
+            insertAuditEvent(db, {
+                event_type: 'delivery_escalated',
+                actor: 'loid',
+                task_id: input.task_id,
+                summary: `Loid 升级: ${input.escalation_note ?? '需人类介入'}`,
+                detail: JSON.stringify({ escalation_note: input.escalation_note }),
+            });
+            // 通过通道向人类发升级通知
+            let notified = false;
+            if (deps.channelSend) {
+                try {
+                    let chatId = null;
+                    if (task.source_ref) {
+                        const sourceMsg = getMessageLogBySourceRef(db, task.source_ref);
+                        chatId = sourceMsg?.chat_id ?? null;
+                    }
+                    if (chatId) {
+                        await deps.channelSend(`feishu://${chatId}`, `${input.task_id} 需要你来决定——${input.escalation_note ?? '详见任务'}`, { task_id: input.task_id, intent: 'escalation' });
+                        notified = true;
+                    }
+                }
+                catch (err) {
+                    logger?.error(`[anya:pipeline] [Loid] 升级通知发送失败 (${input.task_id}):`, err);
+                }
+            }
+            logger?.info(`[anya:pipeline] [Loid] 升级 ${input.task_id}: ${input.escalation_note ?? '需人类决策'}${notified ? ' (已通知)' : ''}`);
+            return { task_id: input.task_id, judgment: 'ESCALATE', success: true, notified };
+        }
+    }
+}
+//# sourceMappingURL=task-review.js.map

package/packages/mcp-tools/dist/layer2/loid/workspace-cleanup.js

@@ -0,0 +1,7 @@
+export async function workspaceCleanup(deps, input) {
+    const { worktreeManager, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] workspace.cleanup ${input.task_id}`);
+    await worktreeManager.cleanup(input.task_id, input.project_id);
+    return { task_id: input.task_id, cleaned: true };
+}
+//# sourceMappingURL=workspace-cleanup.js.map

package/packages/mcp-tools/dist/layer2/loid/workspace-info.js

@@ -0,0 +1,31 @@
+export async function workspaceInfo(deps, input) {
+    const { worktreeManager } = deps;
+    await worktreeManager.loadConfig();
+    const product = worktreeManager.findProduct(input.project_id);
+    if (product) {
+        return {
+            type: 'product',
+            project_id: product.productId,
+            name: product.name,
+            description: product.description,
+            repos: product.repos.map(r => ({
+                name: r.name,
+                gitUrl: r.gitUrl,
+                repoPath: worktreeManager.resolveRepoPath(r.repoPath, r.name),
+                defaultBranch: r.defaultBranch,
+            })),
+        };
+    }
+    const project = worktreeManager.findProject(input.project_id);
+    if (project) {
+        return {
+            type: 'project',
+            project_id: project.projectId,
+            gitUrl: project.gitUrl,
+            repoPath: worktreeManager.resolveRepoPath(project.repoPath, project.projectId),
+            defaultBranch: project.defaultBranch,
+        };
+    }
+    return { type: 'not_found', project_id: input.project_id };
+}
+//# sourceMappingURL=workspace-info.js.map

package/packages/mcp-tools/dist/layer2/loid/workspace-prepare.js

@@ -0,0 +1,12 @@
+export async function workspacePrepare(deps, input) {
+    const { worktreeManager, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] workspace.prepare ${input.task_id} | project=${input.project_id ?? 'none'}`);
+    const result = await worktreeManager.prepare(input.task_id, input.project_id);
+    return {
+        path: result.workingDir,
+        branch: result.branch,
+        type: result.mode,
+        repos: result.repos,
+    };
+}
+//# sourceMappingURL=workspace-prepare.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-approve.js

@@ -0,0 +1,8 @@
+export function yorApprove(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.approve task=${input.task_id}`);
+    const message = input.message ?? '审核通过，任务完成。你可以做最后的清理工作。';
+    yorOrchestrator.approveAndShutdown(input.task_id, message);
+    return { task_id: input.task_id, approved: true };
+}
+//# sourceMappingURL=yor-approve.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-kill.js

@@ -0,0 +1,7 @@
+export async function yorKill(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.kill task=${input.task_id}`);
+    const result = await yorOrchestrator.kill(input.task_id);
+    return { task_id: input.task_id, killed: result.success };
+}
+//# sourceMappingURL=yor-kill.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-rework.js

@@ -0,0 +1,7 @@
+export function yorRework(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.rework task=${input.task_id}`);
+    yorOrchestrator.sendRework(input.task_id, input.feedback);
+    return { task_id: input.task_id, sent: true };
+}
+//# sourceMappingURL=yor-rework.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-spawn.js

@@ -0,0 +1,15 @@
+export async function yorSpawn(deps, input) {
+    const { yorOrchestrator, logger } = deps;
+    logger?.info(`[anya:pipeline] [Loid] yor.spawn ${input.task_id} | dir=${input.working_dir}`);
+    const result = await yorOrchestrator.spawnAndExecute({
+        taskId: input.task_id,
+        workingDir: input.working_dir,
+        briefPath: input.brief_path,
+        env: input.env,
+    });
+    return {
+        instance_id: result.instanceId,
+        task_id: input.task_id,
+    };
+}
+//# sourceMappingURL=yor-spawn.js.map

package/packages/mcp-tools/dist/layer2/loid/yor-status.js

@@ -0,0 +1,8 @@
+export function yorStatus(deps) {
+    const instances = deps.yorOrchestrator.status();
+    return {
+        total: instances.length,
+        instances,
+    };
+}
+//# sourceMappingURL=yor-status.js.map

package/packages/mcp-tools/dist/layer2/yor/code-lint.js

@@ -0,0 +1,47 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+const execAsync = promisify(exec);
+/**
+ * code.lint - 运行 lint 检查
+ *
+ * 自动检测包管理器，运行 lint 脚本。
+ * 返回 lint 结果。
+ */
+export async function codeLint(input) {
+    const { working_dir } = input;
+    let command;
+    if (existsSync(join(working_dir, 'pnpm-lock.yaml')) || existsSync(join(working_dir, 'pnpm-workspace.yaml'))) {
+        command = 'pnpm lint';
+    }
+    else if (existsSync(join(working_dir, 'yarn.lock'))) {
+        command = 'yarn lint';
+    }
+    else {
+        command = 'npm run lint';
+    }
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: working_dir,
+            timeout: 3 * 60 * 1000, // 3 分钟超时
+            maxBuffer: 10 * 1024 * 1024, // 10MB
+        });
+        const output = [stdout, stderr].filter(Boolean).join('\n');
+        return { success: true, passed: true, output };
+    }
+    catch (err) {
+        const output = [err.stdout, err.stderr].filter(Boolean).join('\n');
+        const isLintFailure = err.code !== undefined && err.code !== null;
+        if (isLintFailure) {
+            return { success: true, passed: false, output };
+        }
+        return {
+            success: false,
+            passed: false,
+            output: output || '',
+            error: err.message,
+        };
+    }
+}
+//# sourceMappingURL=code-lint.js.map

package/packages/mcp-tools/dist/layer2/yor/code-test.js

@@ -0,0 +1,52 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+const execAsync = promisify(exec);
+/**
+ * code.test - 运行测试
+ *
+ * 默认运行 pnpm test 或 npm test，可指定自定义测试命令。
+ * 返回测试输出和通过/失败状态。
+ */
+export async function codeTest(input) {
+    const { working_dir } = input;
+    let command = input.command;
+    if (!command) {
+        // 自动检测包管理器
+        if (existsSync(join(working_dir, 'pnpm-lock.yaml')) || existsSync(join(working_dir, 'pnpm-workspace.yaml'))) {
+            command = 'pnpm test';
+        }
+        else if (existsSync(join(working_dir, 'yarn.lock'))) {
+            command = 'yarn test';
+        }
+        else {
+            command = 'npm test';
+        }
+    }
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: working_dir,
+            timeout: 5 * 60 * 1000, // 5 分钟超时
+            maxBuffer: 10 * 1024 * 1024, // 10MB
+        });
+        const output = [stdout, stderr].filter(Boolean).join('\n');
+        return { success: true, passed: true, output };
+    }
+    catch (err) {
+        // 测试失败但命令执行了（exit code !== 0）
+        const output = [err.stdout, err.stderr].filter(Boolean).join('\n');
+        const isTestFailure = err.code !== undefined && err.code !== null;
+        if (isTestFailure) {
+            return { success: true, passed: false, output };
+        }
+        // 命令本身执行失败
+        return {
+            success: false,
+            passed: false,
+            output: output || '',
+            error: err.message,
+        };
+    }
+}
+//# sourceMappingURL=code-test.js.map