loreli 0.0.0 → 1.0.0

package/packages/mcp/src/tools/hitl.js

@@ -0,0 +1,149 @@
+import { logger } from 'loreli/log';
+import { check } from 'loreli/config';
+import { has, parse } from 'loreli/marker';
+
+const log = logger('hitl');
+
+/**
+ * Human In The Loop (HITL) tools.
+ *
+ * `hitl` hands off a PR to human reviewers after agent approval.
+ * `watch` checks for new human feedback using timestamp filtering.
+ */
+export default {
+  hitl: {
+    title: 'HITL',
+    description: 'Hand off a PR to human reviewers. Requests review, assigns users, posts a summary comment tagging reviewers. Only meaningful when merge.hitl is true.',
+    schema: {
+      type: 'object',
+      properties: {
+        repo: { type: 'string', description: 'Target repository (owner/name).' },
+        pr: { type: 'number', description: 'Pull request number.' }
+      },
+      required: ['repo', 'pr']
+    },
+    /**
+     * @param {object} args - Tool arguments.
+     * @param {object} ctx - Execution context.
+     * @returns {Promise<object>} HITL result with reviewer list.
+     */
+    async exec(args, ctx) {
+      check.repo(args.repo);
+      check.positive(args.pr, 'PR number');
+      const { repo, pr } = args;
+      const reviewers = ctx.config?.get?.('reviewers') ?? [];
+
+      if (!reviewers.length) {
+        return {
+          content: [{
+            type: 'text',
+            text: `No reviewers configured — merge.hitl is false. PR #${pr} can be merged directly.`
+          }]
+        };
+      }
+
+      log.info(`hitl PR #${pr} for human review: ${reviewers.join(', ')}`);
+
+      // Delegate to review workflow which handles request, assign, comment, and agent cleanup
+      const result = await ctx.review.hitl(repo, pr);
+
+      // Persist HITL state for watch polling
+      if (ctx.sessionId && ctx.storage) {
+        try {
+          const agents = ctx.storage.agents ? await ctx.storage.agents(ctx.sessionId) : [];
+          for (const name of agents) {
+            const data = await ctx.storage.load(ctx.sessionId, name);
+            if (data) {
+              data.state = 'awaiting_hitl';
+              data.reviewers = result.reviewers;
+              data.hitlAt = result.hitlAt;
+              await ctx.storage.save(ctx.sessionId, name, data);
+            }
+          }
+        } catch { /* best-effort persistence */ }
+      }
+
+      return {
+        content: [{
+          type: 'text',
+          text: [
+            `PR #${pr} handed to Human In The Loop`,
+            `Reviewers: ${result.reviewers.join(', ')}`,
+            `HITL at: ${result.hitlAt}`,
+            'All active agents have been shut down.'
+          ].join('\n')
+        }]
+      };
+    }
+  },
+
+  watch: {
+    title: 'Watch',
+    description: 'Check an HITL PR for new human feedback. Returns comments posted after the HITL timestamp, filtering out known agent comments.',
+    schema: {
+      type: 'object',
+      properties: {
+        repo: { type: 'string', description: 'Target repository (owner/name).' },
+        pr: { type: 'number', description: 'Pull request number.' },
+        since: { type: 'string', description: 'ISO timestamp to filter comments after (hitlAt).' }
+      },
+      required: ['repo', 'pr', 'since']
+    },
+    /**
+     * @param {object} args - Tool arguments.
+     * @param {object} ctx - Execution context.
+     * @returns {Promise<object>} Watch result with status and optional feedback.
+     */
+    async exec(args, ctx) {
+      check.repo(args.repo);
+      check.positive(args.pr, 'PR number');
+      const { repo, pr, since } = args;
+
+      // Inline: pending() was a 3-line hub method — timestamp filter on comments()
+      const allComments = await ctx.hub.comments(repo, pr);
+      const comments = allComments.filter(function afterHitl(c) { return c.created > since; });
+
+      // Filter out comments whose agent marker names an identity in the
+      // registry's active list. Both agent and human comments may carry
+      // the agent marker when posted via hub.as(identity, role).comment();
+      // we distinguish by whether the marker's name is a known agent.
+      const activeNames = new Set(
+        (ctx.identityRegistry?.active?.() ?? []).map(function name(i) { return i.name; })
+      );
+      const human = comments.filter(function notAgent(c) {
+        if (!has(c.body, 'agent')) return true;
+        const data = parse(c.body, 'agent');
+        return !data?.name || !activeNames.has(data.name);
+      });
+
+      if (!human.length) {
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ status: 'waiting', pr, checked: new Date().toISOString() })
+          }]
+        };
+      }
+
+      // Human feedback found — trigger rework via action workflow
+      if (ctx.action) {
+        try {
+          await ctx.action.rework(repo, pr, human);
+        } catch { /* rework is best-effort; we still return the feedback */ }
+      }
+
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            status: 'feedback',
+            pr,
+            comments: human.map(function format(c) {
+              return { author: c.author, body: c.body, created: c.created };
+            })
+          })
+        }]
+      };
+    }
+  }
+};

package/packages/mcp/src/tools/index.js

@@ -0,0 +1,17 @@
+import start from './start.js';
+import agents from './agents.js';
+import work from './work.js';
+import status from './status.js';
+import hitl from './hitl.js';
+import github from './github.js';
+import context from './context.js';
+
+/**
+ * All tool definitions aggregated from individual modules.
+ *
+ * @returns {Record<string, object>} Map of tool name to tool definition.
+ */
+export function allTools() {
+  return { ...start, ...agents, ...work, ...status, ...hitl, ...github, ...context };
+}
+