opencode-pilot 0.9.3 → 0.11.0

package/README.md

@@ -45,6 +45,7 @@ See [examples/config.yaml](examples/config.yaml) for a complete example with all
 
 ### Key Sections
 
+- **`server_port`** - Preferred OpenCode server port (e.g., `4096`). When multiple OpenCode instances are running, pilot attaches sessions to this port.
 - **`defaults`** - Default values applied to all sources
 - **`sources`** - What to poll (presets, shorthand, or full config)
 - **`tools`** - Field mappings to normalize different MCP APIs
@@ -93,6 +94,18 @@ opencode-pilot test-mapping MCP   # Test field mappings
 
 ## Known Issues
 
+### Sessions attached to global server run in wrong directory
+
+When using `server_port` to attach sessions to a global OpenCode server (e.g., OpenCode Desktop with worktree="/"), sessions are created in the server's working directory (typically home) instead of the project directory. This means:
+
+- File tools resolve paths relative to home, not the project
+- The agent sees the wrong `Working directory` in system prompt
+- Git operations may target the wrong repository
+
+**Workaround**: Don't set `server_port` in your config. Sessions will run in the correct directory but won't appear in OpenCode Desktop.
+
+**Upstream issue**: [anomalyco/opencode#7376](https://github.com/anomalyco/opencode/issues/7376)
+
 ### Working directory doesn't switch when templates create worktrees/devcontainers
 
 When a template instructs the agent to create a git worktree or switch to a devcontainer, OpenCode's internal working directory context (`Instance.directory`) doesn't update. This means:

package/examples/config.yaml

@@ -1,6 +1,11 @@
 # Example config.yaml for opencode-pilot
 # Copy to ~/.config/opencode-pilot/config.yaml
 
+# Preferred OpenCode server port for attaching sessions
+# When multiple OpenCode instances are running, pilot will attach new sessions
+# to this port. If not set, pilot discovers servers automatically.
+# server_port: 4096
+
 defaults:
   agent: plan
   prompt: default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-pilot",
-  "version": "0.9.3",
+  "version": "0.11.0",
   "type": "module",
   "main": "plugin/index.js",
   "description": "Automation daemon for OpenCode - polls for work and spawns sessions",

package/service/actions.js

@@ -9,6 +9,7 @@ import { spawn, execSync } from "child_process";
 import { readFileSync, existsSync } from "fs";
 import { debug } from "./logger.js";
 import { getNestedValue } from "./utils.js";
+import { getServerPort } from "./repo-config.js";
 import path from "path";
 import os from "os";
 
@@ -99,10 +100,11 @@ function isServerHealthy(project) {
  * Discover a running opencode server that matches the target directory
  * 
  * Queries all running opencode servers and finds the best match based on:
- * 1. Exact sandbox match (highest priority)
- * 2. Exact worktree match
- * 3. Target is subdirectory of worktree
- * 4. Global server (worktree="/") as fallback
+ * 1. Configured server_port (highest priority if set and healthy)
+ * 2. Exact sandbox match
+ * 3. Exact worktree match
+ * 4. Target is subdirectory of worktree
+ * 5. Global server (worktree="/") as fallback
  * 
  * Global servers are used as a fallback when no project-specific match is found,
  * since OpenCode Desktop may be connected to a global server that can display
@@ -112,11 +114,13 @@ function isServerHealthy(project) {
  * @param {object} [options] - Options for testing/mocking
  * @param {function} [options.getPorts] - Function to get server ports
  * @param {function} [options.fetch] - Function to fetch URLs
+ * @param {number} [options.preferredPort] - Preferred port to use (overrides config)
  * @returns {Promise<string|null>} Server URL (e.g., "http://localhost:4096") or null
  */
 export async function discoverOpencodeServer(targetDir, options = {}) {
   const getPorts = options.getPorts || getOpencodePorts;
   const fetchFn = options.fetch || fetch;
+  const preferredPort = options.preferredPort ?? getServerPort();
   
   const ports = await getPorts();
   if (ports.length === 0) {
@@ -124,7 +128,24 @@ export async function discoverOpencodeServer(targetDir, options = {}) {
     return null;
   }
   
-  debug(`discoverOpencodeServer: checking ${ports.length} servers for ${targetDir}`);
+  debug(`discoverOpencodeServer: checking ${ports.length} servers for ${targetDir}, preferredPort=${preferredPort}`);
+  
+  // If preferred port is configured and running, check it first
+  if (preferredPort && ports.includes(preferredPort)) {
+    const url = `http://localhost:${preferredPort}`;
+    try {
+      const response = await fetchFn(`${url}/project/current`);
+      if (response.ok) {
+        const project = await response.json();
+        if (isServerHealthy(project)) {
+          debug(`discoverOpencodeServer: using preferred port ${preferredPort}`);
+          return url;
+        }
+      }
+    } catch (err) {
+      debug(`discoverOpencodeServer: preferred port ${preferredPort} error: ${err.message}`);
+    }
+  }
   
   let bestMatch = null;
   let bestScore = 0;

package/service/poll-service.js

@@ -10,7 +10,7 @@
  */
 
 import { loadRepoConfig, getRepoConfig, getAllSources, getToolProviderConfig, resolveRepoForItem, getCleanupTtlDays } from "./repo-config.js";
-import { createPoller, pollGenericSource } from "./poller.js";
+import { createPoller, pollGenericSource, enrichItemsWithComments } from "./poller.js";
 import { evaluateReadiness, sortByPriority } from "./readiness.js";
 import { executeAction, buildCommand } from "./actions.js";
 import { debug } from "./logger.js";
@@ -126,6 +126,12 @@ export async function pollOnce(options = {}) {
         toolProviderConfig = getToolProviderConfig(source.tool.mcp);
         items = await pollGenericSource(source, { toolProviderConfig });
         debug(`Fetched ${items.length} items from ${sourceName}`);
+        
+        // Enrich items with comments for bot filtering if configured
+        if (source.filter_bot_comments) {
+          items = await enrichItemsWithComments(items, source);
+          debug(`Enriched ${items.length} items with comments for bot filtering`);
+        }
       } catch (err) {
         console.error(`[poll] Error fetching from ${sourceName}: ${err.message}`);
         continue;

package/service/poller.js

@@ -273,6 +273,120 @@ export async function pollGenericSource(source, options = {}) {
   }
 }
 
+/**
+ * Fetch comments for a GitHub issue/PR and enrich the item
+ * 
+ * Uses the github_get_pull_request_comments tool to fetch review comments,
+ * or falls back to direct API call for issue comments.
+ * 
+ * @param {object} item - Item with owner, repo_short, and number fields
+ * @param {object} [options] - Options
+ * @param {number} [options.timeout] - Timeout in ms (default: 30000)
+ * @param {string} [options.opencodeConfigPath] - Path to opencode.json for MCP config
+ * @returns {Promise<Array>} Array of comment objects
+ */
+export async function fetchGitHubComments(item, options = {}) {
+  const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
+  
+  // Extract owner and repo from item
+  // The item should have repository_full_name (e.g., "owner/repo") from mapping
+  const fullName = item.repository_full_name;
+  if (!fullName) {
+    console.error("[poller] Cannot fetch comments: missing repository_full_name");
+    return [];
+  }
+  
+  const [owner, repo] = fullName.split("/");
+  const number = item.number;
+  
+  if (!owner || !repo || !number) {
+    console.error("[poller] Cannot fetch comments: missing owner, repo, or number");
+    return [];
+  }
+  
+  let mcpConfig;
+  try {
+    mcpConfig = getMcpConfig("github", options.opencodeConfigPath);
+  } catch {
+    console.error("[poller] GitHub MCP not configured, cannot fetch comments");
+    return [];
+  }
+  
+  const client = new Client({ name: "opencode-pilot", version: "1.0.0" });
+  
+  try {
+    const transport = await createTransport(mcpConfig);
+    
+    await Promise.race([
+      client.connect(transport),
+      createTimeout(timeout, "MCP connection for comments"),
+    ]);
+    
+    // Use github_get_pull_request_comments for PR review comments
+    const result = await Promise.race([
+      client.callTool({ 
+        name: "github_get_pull_request_comments", 
+        arguments: { owner, repo, pull_number: number } 
+      }),
+      createTimeout(timeout, "fetch comments"),
+    ]);
+    
+    const text = result.content?.[0]?.text;
+    if (!text) return [];
+    
+    try {
+      const comments = JSON.parse(text);
+      return Array.isArray(comments) ? comments : [];
+    } catch {
+      return [];
+    }
+  } catch (err) {
+    console.error(`[poller] Error fetching comments: ${err.message}`);
+    return [];
+  } finally {
+    try {
+      await Promise.race([
+        client.close(),
+        new Promise(resolve => setTimeout(resolve, 3000)),
+      ]);
+    } catch {
+      // Ignore close errors
+    }
+  }
+}
+
+/**
+ * Enrich items with comments for bot filtering
+ * 
+ * For items from sources with filter_bot_comments: true, fetches comments
+ * and attaches them as _comments field for readiness evaluation.
+ * 
+ * @param {Array} items - Items to enrich
+ * @param {object} source - Source configuration with optional filter_bot_comments
+ * @param {object} [options] - Options passed to fetchGitHubComments
+ * @returns {Promise<Array>} Items with _comments field added
+ */
+export async function enrichItemsWithComments(items, source, options = {}) {
+  // Skip if not configured or not a GitHub source
+  if (!source.filter_bot_comments || source.tool?.mcp !== "github") {
+    return items;
+  }
+  
+  // Fetch comments for each item (could be parallelized with Promise.all for speed)
+  const enrichedItems = [];
+  for (const item of items) {
+    // Only fetch if item has comments
+    if (item.comments > 0) {
+      const comments = await fetchGitHubComments(item, options);
+      enrichedItems.push({ ...item, _comments: comments });
+    } else {
+      enrichedItems.push(item);
+    }
+  }
+  
+  return enrichedItems;
+}
+
 /**
  * Create a poller instance with state tracking
  * 

package/service/presets/github.yaml

@@ -57,3 +57,6 @@ my-prs-feedback:
   reprocess_on:
     - state
     - updated_at
+  # Filter out PRs where all comments are from bots or the PR author
+  # Fetches comments via API and enriches items with _comments for readiness check
+  filter_bot_comments: true

package/service/readiness.js

@@ -4,9 +4,12 @@
  * Evaluates whether an issue is ready to be worked on based on:
  * - Label constraints (blocking labels, required labels)
  * - Dependencies (blocked by references in body)
+ * - Bot comment filtering (for PR feedback sources)
  * - Priority scoring (label weights, age bonus)
  */
 
+import { hasNonBotFeedback } from "./utils.js";
+
 /**
  * Dependency reference patterns in issue body
  */
@@ -131,6 +134,45 @@ export function checkDependencies(issue, config) {
   return { ready: true };
 }
 
+/**
+ * Check if a PR/issue has meaningful (non-bot, non-author) comments
+ * 
+ * This check is only applied when the item has been enriched with `_comments`
+ * (an array of comment objects with user.login and user.type fields).
+ * Items without `_comments` are considered ready (check is skipped).
+ * 
+ * Used to filter PRs from feedback sources where bot comments (CI, coverage, etc.)
+ * should not trigger the author to take action.
+ * 
+ * @param {object} item - Item with optional _comments array and user.login
+ * @param {object} config - Repo config (currently unused but kept for API consistency)
+ * @returns {object} { ready: boolean, reason?: string }
+ */
+export function checkBotComments(item, config) {
+  // Skip check if no _comments field (item not enriched)
+  if (!item._comments) {
+    return { ready: true };
+  }
+  
+  // Empty comments array means no comments - consider ready (no feedback)
+  if (item._comments.length === 0) {
+    return { ready: true };
+  }
+  
+  // Get author username
+  const authorUsername = item.user?.login;
+  
+  // Check if there's non-bot, non-author feedback
+  if (hasNonBotFeedback(item._comments, authorUsername)) {
+    return { ready: true };
+  }
+  
+  return {
+    ready: false,
+    reason: "Only bot or author comments - no human feedback requiring action",
+  };
+}
+
 /**
  * Calculate priority score for an issue
  * @param {object} issue - Issue with labels and created_at
@@ -194,6 +236,16 @@ export function evaluateReadiness(issue, config) {
     };
   }
 
+  // Check bot comments (for PRs enriched with _comments)
+  const botResult = checkBotComments(issue, config);
+  if (!botResult.ready) {
+    return {
+      ready: false,
+      reason: botResult.reason,
+      priority: 0,
+    };
+  }
+
   // Calculate priority for ready issues
   const priority = calculatePriority(issue, config);
 

package/service/repo-config.js

@@ -310,6 +310,15 @@ export function getCleanupTtlDays() {
   return config?.cleanup?.ttl_days ?? 30;
 }
 
+/**
+ * Get preferred OpenCode server port from config
+ * @returns {number|null} Port number or null if not configured
+ */
+export function getServerPort() {
+  const config = getRawConfig();
+  return config?.server_port ?? null;
+}
+
 /**
  * Clear config cache (for testing)
  */

package/service/utils.js

@@ -19,3 +19,65 @@ export function getNestedValue(obj, path) {
   }
   return value;
 }
+
+/**
+ * Check if a username represents a bot account
+ * 
+ * Detects bots by:
+ * 1. Username suffix: [bot] (e.g., "github-actions[bot]", "dependabot[bot]")
+ * 2. User type field: "Bot" (GitHub API provides this)
+ * 
+ * @param {string} username - GitHub username to check
+ * @param {string} [type] - User type from API (e.g., "Bot", "User")
+ * @returns {boolean} True if the user is a bot
+ */
+export function isBot(username, type) {
+  // Handle null/undefined/empty
+  if (!username) return false;
+  
+  // Check user type field (GitHub API provides "Bot" type)
+  if (type && type.toLowerCase() === "bot") return true;
+  
+  // Check for [bot] suffix in username
+  if (username.toLowerCase().endsWith("[bot]")) return true;
+  
+  return false;
+}
+
+/**
+ * Check if a PR/issue has non-bot feedback (comments from humans other than the author)
+ * 
+ * Used to filter out PRs where only bots have commented, since those don't
+ * require the author's attention for human feedback.
+ * 
+ * @param {Array} comments - Array of comment objects with user.login and user.type
+ * @param {string} authorUsername - Username of the PR/issue author
+ * @returns {boolean} True if there's at least one non-bot, non-author comment
+ */
+export function hasNonBotFeedback(comments, authorUsername) {
+  // Handle null/undefined/empty
+  if (!comments || !Array.isArray(comments) || comments.length === 0) {
+    return false;
+  }
+  
+  const authorLower = authorUsername?.toLowerCase();
+  
+  for (const comment of comments) {
+    const user = comment.user;
+    if (!user) continue;
+    
+    const username = user.login;
+    const userType = user.type;
+    
+    // Skip if it's a bot
+    if (isBot(username, userType)) continue;
+    
+    // Skip if it's the author themselves
+    if (authorLower && username?.toLowerCase() === authorLower) continue;
+    
+    // Found a non-bot, non-author comment
+    return true;
+  }
+  
+  return false;
+}

package/test/unit/readiness.test.js

@@ -0,0 +1,210 @@
+/**
+ * Tests for readiness.js - Issue/PR readiness evaluation
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('readiness.js', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'opencode-pilot-readiness-test-'));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('checkLabels', () => {
+    test('returns ready when no label constraints', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { labels: ['bug', 'help wanted'] };
+      const config = {};
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when has blocking label', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { labels: ['bug', 'wip'] };
+      const config = {
+        readiness: {
+          labels: {
+            exclude: ['wip', 'do-not-merge']
+          }
+        }
+      };
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('wip'));
+    });
+
+    test('returns not ready when missing required label', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { labels: ['bug'] };
+      const config = {
+        readiness: {
+          labels: {
+            required: ['approved', 'ready']
+          }
+        }
+      };
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('approved'));
+    });
+
+    test('handles label objects with name property', async () => {
+      const { checkLabels } = await import('../../service/readiness.js');
+      
+      const issue = { 
+        labels: [
+          { name: 'bug' },
+          { name: 'approved' }
+        ]
+      };
+      const config = {
+        readiness: {
+          labels: {
+            required: ['approved']
+          }
+        }
+      };
+      
+      const result = checkLabels(issue, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
+  describe('checkBotComments', () => {
+    test('returns ready when there are non-bot comments', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'reviewer', type: 'User' }, body: 'Please fix the bug' },
+        ]
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns not ready when all comments are from bots', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'codecov[bot]', type: 'Bot' }, body: 'Coverage report' },
+        ]
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('bot'));
+    });
+
+    test('returns not ready when only author and bots have commented', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'athal7' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'athal7', type: 'User' }, body: 'Added screenshots' },
+        ]
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+    });
+
+    test('returns ready when no _comments field (skip check)', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        comments: 5  // count only, no _comments enrichment
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+
+    test('returns ready when _comments is empty (no comments yet)', async () => {
+      const { checkBotComments } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: []
+      };
+      const config = {};
+      
+      const result = checkBotComments(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+
+  describe('evaluateReadiness', () => {
+    test('checks bot comments when _comments is present', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'dependabot[bot]', type: 'Bot' }, body: 'Bump dependency' },
+        ]
+      };
+      const config = {};
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, false);
+      assert.ok(result.reason.includes('bot'));
+    });
+
+    test('passes when there is real human feedback', async () => {
+      const { evaluateReadiness } = await import('../../service/readiness.js');
+      
+      const pr = {
+        user: { login: 'author' },
+        _comments: [
+          { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+          { user: { login: 'teammate', type: 'User' }, body: 'LGTM!' },
+        ]
+      };
+      const config = {};
+      
+      const result = evaluateReadiness(pr, config);
+      
+      assert.strictEqual(result.ready, true);
+    });
+  });
+});

package/test/unit/utils.test.js

@@ -6,6 +6,102 @@ import { test, describe } from 'node:test';
 import assert from 'node:assert';
 
 describe('utils.js', () => {
+  describe('isBot', () => {
+    test('detects GitHub bot usernames with [bot] suffix', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot('github-actions[bot]'), true);
+      assert.strictEqual(isBot('dependabot[bot]'), true);
+      assert.strictEqual(isBot('renovate[bot]'), true);
+      assert.strictEqual(isBot('codecov[bot]'), true);
+    });
+
+    test('detects bots by type field', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      // When user object has type: "Bot"
+      assert.strictEqual(isBot('some-user', 'Bot'), true);
+      assert.strictEqual(isBot('another-user', 'bot'), true);
+    });
+
+    test('returns false for regular users', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot('athal7'), false);
+      assert.strictEqual(isBot('octocat'), false);
+      assert.strictEqual(isBot('some-developer'), false);
+    });
+
+    test('returns false for regular users with type User', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot('athal7', 'User'), false);
+      assert.strictEqual(isBot('octocat', 'user'), false);
+    });
+
+    test('handles edge cases', async () => {
+      const { isBot } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isBot(''), false);
+      assert.strictEqual(isBot(null), false);
+      assert.strictEqual(isBot(undefined), false);
+    });
+  });
+
+  describe('hasNonBotFeedback', () => {
+    test('returns true when there are non-bot, non-author comments', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'reviewer', type: 'User' }, body: 'Please fix the bug' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), true);
+    });
+
+    test('returns false when all comments are from bots', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'codecov[bot]', type: 'Bot' }, body: 'Coverage report' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
+    test('returns false when only author has commented', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'athal7', type: 'User' }, body: 'Added screenshots' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
+    test('returns false for empty comments array', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      assert.strictEqual(hasNonBotFeedback([], 'athal7'), false);
+      assert.strictEqual(hasNonBotFeedback(null, 'athal7'), false);
+      assert.strictEqual(hasNonBotFeedback(undefined, 'athal7'), false);
+    });
+
+    test('handles nested user object with login and type', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      const comments = [
+        { user: { login: 'dependabot[bot]', type: 'Bot' }, body: 'Bump lodash' },
+        { user: { login: 'maintainer', type: 'User' }, body: 'LGTM' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'contributor'), true);
+    });
+  });
+
   describe('getNestedValue', () => {
     test('gets top-level value', async () => {
       const { getNestedValue } = await import('../../service/utils.js');