autosnippet 3.1.15 → 3.2.2

package/lib/external/mcp/handlers/task.js

@@ -0,0 +1,295 @@
+/**
+ * MCP Handler — TaskGraph 任务管理
+ *
+ * 操作路由：
+ *   create / decompose / claim / close / fail / defer / progress
+ *   ready / prime / show / list / blocked / dep_add / dep_tree / stats
+ */
+
+import { envelope } from '../envelope.js';
+
+/**
+ * 统一入口
+ * @param {object} ctx — { container }
+ * @param {object} args — { operation, ...params }
+ */
+export async function taskHandler(ctx, args) {
+  const taskService = ctx.container.get('taskGraphService');
+
+  switch (args.operation) {
+    case 'create':
+      return _create(taskService, args);
+    case 'ready':
+      return _ready(taskService, args);
+    case 'claim':
+      return _claim(taskService, args);
+    case 'close':
+      return _close(taskService, args);
+    case 'fail':
+      return _fail(taskService, args);
+    case 'defer':
+      return _defer(taskService, args);
+    case 'progress':
+      return _progress(taskService, args);
+    case 'prime':
+      return _prime(taskService);
+    case 'decompose':
+      return _decompose(taskService, args);
+    case 'show':
+      return _show(taskService, args);
+    case 'list':
+      return _list(taskService, args);
+    case 'blocked':
+      return _blocked(taskService);
+    case 'dep_add':
+      return _depAdd(taskService, args);
+    case 'dep_tree':
+      return _depTree(taskService, args);
+    case 'stats':
+      return _stats(taskService);
+    default:
+      return envelope({
+        success: false,
+        message: `Unknown operation: ${args.operation}`,
+        meta: { tool: 'autosnippet_task' },
+      });
+  }
+}
+
+// ── create ──
+
+async function _create(svc, args) {
+  if (!args.title) {
+    return envelope({ success: false, message: 'title is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const { task, isDuplicate } = await svc.create({
+    title: args.title,
+    description: args.description || '',
+    design: args.design || '',
+    acceptance: args.acceptance || '',
+    priority: args.priority ?? 2,
+    taskType: args.taskType || 'task',
+    parentId: args.parentId || null,
+  });
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: isDuplicate
+      ? `⚠ Duplicate detected: ${task.id} already exists`
+      : `Created ${task.id}: ${task.title}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── ready ──
+
+async function _ready(svc, args) {
+  const tasks = await svc.ready({
+    limit: args.limit || 10,
+    withKnowledge: args.withKnowledge !== false,
+  });
+  return envelope({
+    success: true,
+    data: tasks.map((t) => (t.toJSON ? t.toJSON() : t)),
+    message: `${tasks.length} task(s) ready`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── claim ──
+
+async function _claim(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const task = await svc.claim(args.id);
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: `Claimed ${args.id}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── close ──
+
+async function _close(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const { task, newlyReady } = await svc.close(args.id, args.reason || 'Completed');
+  return envelope({
+    success: true,
+    data: {
+      closed: task.toJSON(),
+      newlyReady,
+    },
+    message: `Closed ${args.id}. ${newlyReady.length} task(s) newly ready.`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── fail ──
+
+async function _fail(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const task = await svc.fail(args.id, args.reason || 'Agent execution failed');
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: `Failed ${args.id} (attempt #${task.failCount}): ${task.lastFailReason}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── defer ──
+
+async function _defer(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const task = await svc.defer(args.id, args.reason || '');
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: `Deferred ${args.id}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── progress ──
+
+async function _progress(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const note = args.reason || args.description || '';
+  const task = await svc.progress(args.id, note);
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: `Progress updated for ${args.id}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── prime — 会话恢复 ──
+
+async function _prime(svc) {
+  const result = await svc.prime({ withKnowledge: true });
+  return envelope({
+    success: true,
+    data: result,
+    message: `${result.inProgress.length} in-progress, ${result.ready.length} ready, ${result.stats.total} total`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── decompose ──
+
+async function _decompose(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'Epic id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  if (!args.subtasks || !Array.isArray(args.subtasks) || args.subtasks.length === 0) {
+    return envelope({ success: false, message: 'subtasks array is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const tasks = await svc.decompose(args.id, args.subtasks);
+  return envelope({
+    success: true,
+    data: tasks.map((t) => (t.toJSON ? t.toJSON() : t)),
+    message: `Decomposed ${args.id} into ${tasks.length} subtasks`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── show ──
+
+async function _show(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const task = await svc.show(args.id);
+  if (!task) {
+    return envelope({ success: false, message: `Task not found: ${args.id}`, meta: { tool: 'autosnippet_task' } });
+  }
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── list ──
+
+async function _list(svc, args) {
+  const filters = {};
+  if (args.status) filters.status = args.status;
+  if (args.taskType) filters.taskType = args.taskType;
+
+  const tasks = await svc.list(filters, { limit: args.limit || 20 });
+  return envelope({
+    success: true,
+    data: tasks.map((t) => t.toJSON()),
+    message: `${tasks.length} task(s)`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── blocked ──
+
+async function _blocked(svc) {
+  const tasks = await svc.blocked();
+  return envelope({
+    success: true,
+    data: tasks,
+    message: `${tasks.length} blocked task(s)`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── dep_add ──
+
+async function _depAdd(svc, args) {
+  if (!args.id || !args.dependsOn) {
+    return envelope({
+      success: false,
+      message: 'id and dependsOn are required',
+      meta: { tool: 'autosnippet_task' },
+    });
+  }
+  await svc.addDependency(args.id, args.dependsOn, args.depType || 'blocks');
+  return envelope({
+    success: true,
+    message: `${args.id} ${args.depType || 'blocks'} ${args.dependsOn}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── dep_tree ──
+
+async function _depTree(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const tree = await svc.depTree(args.id);
+  return envelope({
+    success: true,
+    data: tree,
+    message: `${tree.length} node(s) in dependency tree`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ── stats ──
+
+async function _stats(svc) {
+  const stats = await svc.stats();
+  return envelope({
+    success: true,
+    data: stats,
+    meta: { tool: 'autosnippet_task' },
+  });
+}

package/lib/external/mcp/tools.js

@@ -1,7 +1,7 @@
 /**
- * MCP 工具定义 — V3 整合版 (15 agent + 4 admin = 19 工具)
+ * MCP 工具定义 — V3 整合版 (16 agent + 4 admin = 20 工具)
  *
- * 从 39 → 19 工具（参数路由合并同类工具 + 外部 Agent 冷启动新架构）。
+ * 从 39 → 20 工具（参数路由合并同类工具 + 外部 Agent 冷启动新架构 + TaskGraph）。
  * 每个工具声明增加 tier 字段（agent / admin）。
  * tools.js 只包含 JSON Schema 声明 + Gateway 映射，不含业务逻辑。
  *
@@ -44,6 +44,20 @@ export const TOOL_GATEWAY_MAP = {
   autosnippet_submit_knowledge: { action: 'knowledge:create', resource: 'knowledge' },
   autosnippet_submit_knowledge_batch: { action: 'knowledge:create', resource: 'knowledge' },
   autosnippet_save_document: { action: 'knowledge:create', resource: 'knowledge' },
+  // task 写操作（create/claim/close/fail/defer/decompose/dep_add）
+  autosnippet_task: {
+    resolver: (args) =>
+      ({
+        create: { action: 'task:create', resource: 'tasks' },
+        claim: { action: 'task:update', resource: 'tasks' },
+        close: { action: 'task:update', resource: 'tasks' },
+        fail: { action: 'task:update', resource: 'tasks' },
+        defer: { action: 'task:update', resource: 'tasks' },
+        progress: { action: 'task:update', resource: 'tasks' },
+        decompose: { action: 'task:create', resource: 'tasks' },
+        dep_add: { action: 'task:update', resource: 'tasks' },
+      })[args?.operation] || null, // ready/prime/show/list/blocked/dep_tree/stats 只读
+  },
   // admin 工具
   autosnippet_enrich_candidates: { action: 'knowledge:update', resource: 'knowledge' },
   autosnippet_knowledge_lifecycle: { action: 'knowledge:update', resource: 'knowledge' },
@@ -53,7 +67,7 @@ export const TOOL_GATEWAY_MAP = {
 
 export const TOOLS = [
   // ══════════════════════════════════════════════════════
-  //  Tier: agent — Agent 核心工具集 (15 个)
+  //  Tier: agent — Agent 核心工具集 (16 个)
   // ══════════════════════════════════════════════════════
 
   // 1. 健康检查
@@ -514,6 +528,89 @@ export const TOOLS = [
     inputSchema: { type: 'object', properties: {}, required: [] },
   },
 
+  // 13. TaskGraph 任务管理
+  {
+    name: 'autosnippet_task',
+    tier: 'agent',
+    description:
+      '任务图管理。创建/查询/认领/关闭任务，管理依赖关系。' +
+      '用于 Agent 自主拆解和执行复杂多步骤工作。' +
+      'ready 返回任务 + 相关知识上下文。prime 恢复会话状态。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        operation: {
+          type: 'string',
+          enum: [
+            'create',
+            'ready',
+            'claim',
+            'close',
+            'fail',
+            'defer',
+            'progress',
+            'show',
+            'list',
+            'blocked',
+            'decompose',
+            'dep_add',
+            'dep_tree',
+            'prime',
+            'stats',
+          ],
+          description: '操作类型',
+        },
+        title: { type: 'string', description: '任务标题（create）' },
+        description: { type: 'string', description: '任务描述（create/progress）' },
+        design: { type: 'string', description: '设计说明（create）' },
+        acceptance: { type: 'string', description: '验收标准（create）' },
+        priority: { type: 'number', description: '优先级 0-4, 0=最高（create）' },
+        taskType: {
+          type: 'string',
+          enum: ['epic', 'task', 'bug', 'chore'],
+          description: '任务类型（create）',
+        },
+        parentId: { type: 'string', description: '父任务 ID（create 子任务）' },
+        id: { type: 'string', description: '任务 ID（claim/close/fail/defer/show/dep_add/dep_tree/progress）' },
+        reason: { type: 'string', description: '原因（close/fail/defer）' },
+        dependsOn: { type: 'string', description: '依赖的任务 ID（dep_add）' },
+        depType: {
+          type: 'string',
+          enum: ['blocks', 'parent-child', 'waits-for', 'discovered-from', 'related', 'knowledge-ref'],
+          default: 'blocks',
+          description: '依赖类型（dep_add）',
+        },
+        limit: { type: 'number', default: 10, description: '结果数量限制（ready/list）' },
+        status: {
+          type: 'string',
+          enum: ['open', 'in_progress', 'deferred', 'closed'],
+          description: '状态过滤（list）',
+        },
+        withKnowledge: {
+          type: 'boolean',
+          default: true,
+          description: '是否附加知识上下文（ready）',
+        },
+        subtasks: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              title: { type: 'string' },
+              description: { type: 'string' },
+              priority: { type: 'number' },
+              taskType: { type: 'string' },
+              blockedByIndex: { type: 'number', description: '被 subtasks 数组中哪个 index 的子任务阻塞' },
+            },
+            required: ['title'],
+          },
+          description: '子任务列表（decompose）',
+        },
+      },
+      required: ['operation'],
+    },
+  },
+
   // ══════════════════════════════════════════════════════
   //  Tier: admin — 管理员/CI 工具 (额外 +4)
   // ══════════════════════════════════════════════════════

package/lib/http/HttpServer.js

@@ -26,6 +26,7 @@ import authRouter from './routes/auth.js';
 import candidatesRouter from './routes/candidates.js';
 import commandsRouter from './routes/commands.js';
 import extractRouter from './routes/extract.js';
+import guardRouter from './routes/guard.js';
 import guardRuleRouter from './routes/guardRules.js';
 import healthRouter from './routes/health.js';
 import knowledgeRouter from './routes/knowledge.js';
@@ -36,6 +37,7 @@ import searchRouter from './routes/search.js';
 import skillsRouter from './routes/skills.js';
 import snippetRouter from './routes/snippets.js';
 import spmRouter from './routes/spm.js';
+import taskRouter from './routes/task.js';
 import violationsRouter from './routes/violations.js';
 import wikiRouter from './routes/wiki.js';
 
@@ -252,9 +254,15 @@ export class HttpServer {
       this.app.use(`${apiPrefix}/monitoring`, monitoringRouter);
     }
 
+    // Guard 实时检查路由（Extension DiagnosticCollection 调用）
+    this.app.use(`${apiPrefix}/guard`, guardRouter);
+
     // 守护规则路由
     this.app.use(`${apiPrefix}/rules`, guardRuleRouter);
 
+    // TaskGraph 路由（Extension taskTool.ts 转发调用）
+    this.app.use(`${apiPrefix}/task`, taskRouter);
+
     // 搜索路由
     this.app.use(`${apiPrefix}/search`, searchRouter);