opencode-pilot 0.19.0 → 0.20.0

package/.github/dependabot.yml

@@ -0,0 +1,33 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    # Group updates to reduce PR noise
+    groups:
+      # Group all dev dependencies together
+      dev-dependencies:
+        dependency-type: "development"
+        update-types:
+          - "minor"
+          - "patch"
+      # Group production dependencies together
+      production-dependencies:
+        dependency-type: "production"
+        update-types:
+          - "minor"
+          - "patch"
+    # Keep major updates separate for careful review
+    open-pull-requests-limit: 10
+    commit-message:
+      prefix: "chore(deps)"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    commit-message:
+      prefix: "chore(deps)"

package/README.md

@@ -31,7 +31,7 @@ npm install -g opencode-pilot
    }
    ```
 
-   The daemon will auto-start when OpenCode launches.
+   The daemon will auto-start when OpenCode launches. If a newer version of the plugin is installed, the daemon will automatically restart to pick up the new version.
 
    Or start manually:
 
@@ -117,7 +117,8 @@ sources:
 
 ```bash
 opencode-pilot start              # Start the service (foreground)
-opencode-pilot status             # Check status
+opencode-pilot stop               # Stop the running service
+opencode-pilot status             # Show version and service status
 opencode-pilot config             # Validate and show config
 opencode-pilot clear              # Show state summary
 opencode-pilot clear --all        # Clear all processed state

package/bin/opencode-pilot

@@ -13,7 +13,7 @@
 
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
 import { execSync } from "child_process";
 import os from "os";
 import YAML from "yaml";
@@ -39,12 +39,73 @@ function findServiceDir() {
 const serviceDir = findServiceDir();
 
 // Paths
-const PILOT_CONFIG_FILE = join(os.homedir(), ".config/opencode/pilot/config.yaml");
-const PILOT_TEMPLATES_DIR = join(os.homedir(), ".config/opencode/pilot/templates");
+const PILOT_CONFIG_DIR = join(os.homedir(), ".config/opencode/pilot");
+const PILOT_CONFIG_FILE = join(PILOT_CONFIG_DIR, "config.yaml");
+const PILOT_TEMPLATES_DIR = join(PILOT_CONFIG_DIR, "templates");
+const PILOT_PID_FILE = join(PILOT_CONFIG_DIR, "pilot.pid");
 
 // Default port
 const DEFAULT_PORT = 4097;
 
+/**
+ * Write PID file
+ */
+function writePidFile() {
+  try {
+    mkdirSync(PILOT_CONFIG_DIR, { recursive: true });
+    writeFileSync(PILOT_PID_FILE, String(process.pid));
+  } catch (err) {
+    console.warn(`[opencode-pilot] Could not write PID file: ${err.message}`);
+  }
+}
+
+/**
+ * Remove PID file
+ */
+function removePidFile() {
+  try {
+    if (existsSync(PILOT_PID_FILE)) {
+      unlinkSync(PILOT_PID_FILE);
+    }
+  } catch {
+    // Ignore errors on cleanup
+  }
+}
+
+/**
+ * Read PID from file
+ * @returns {number|null} PID or null if not found/invalid
+ */
+function readPidFile() {
+  try {
+    if (existsSync(PILOT_PID_FILE)) {
+      const content = readFileSync(PILOT_PID_FILE, "utf8").trim();
+      const pid = parseInt(content, 10);
+      if (!isNaN(pid) && pid > 0) {
+        return pid;
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null;
+}
+
+/**
+ * Check if a process is running
+ * @param {number} pid - Process ID
+ * @returns {boolean} True if process is running
+ */
+function isProcessRunning(pid) {
+  try {
+    // Signal 0 doesn't kill, just checks if process exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Load port from config file
  * @returns {number} Port number
@@ -114,7 +175,8 @@ Usage:
 
 Commands:
   start                Start the polling service (foreground)
-  status               Show service status
+  stop                 Stop the running service
+  status               Show service status and version
   config               Validate and show configuration
   clear                Clear processed state entries
   test-source NAME     Test a source by fetching items and showing mappings
@@ -133,7 +195,8 @@ The service handles:
 
 Examples:
   opencode-pilot start                   # Start service (foreground)
-  opencode-pilot status                  # Check status
+  opencode-pilot stop                    # Stop the service
+  opencode-pilot status                  # Check status and version
   opencode-pilot config                  # Validate and show config
   opencode-pilot clear --all             # Clear all processed state
   opencode-pilot clear --expired         # Clear expired entries
@@ -157,6 +220,9 @@ async function startCommand() {
 
   console.log("[opencode-pilot] Starting polling service...");
   
+  // Write PID file
+  writePidFile();
+  
   // Dynamic import of the service module
   const { startService, stopService } = await import(serverPath);
   
@@ -167,29 +233,91 @@ async function startCommand() {
   const service = await startService(config);
   
   // Handle graceful shutdown
-  process.on("SIGTERM", async () => {
-    console.log("[opencode-pilot] Received SIGTERM, shutting down...");
+  const shutdown = async (signal) => {
+    console.log(`[opencode-pilot] Received ${signal}, shutting down...`);
+    removePidFile();
     await stopService(service);
     process.exit(0);
-  });
+  };
   
-  process.on("SIGINT", async () => {
-    console.log("[opencode-pilot] Received SIGINT, shutting down...");
-    await stopService(service);
-    process.exit(0);
-  });
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
   
   // Keep running until signal received
   await new Promise(() => {});
 }
 
+// ============================================================================
+// Stop Command
+// ============================================================================
+
+function stopCommand() {
+  const pid = readPidFile();
+  
+  if (!pid) {
+    console.log("Service is not running (no PID file found)");
+    process.exit(0);
+  }
+  
+  if (!isProcessRunning(pid)) {
+    console.log(`Service is not running (stale PID file for pid ${pid})`);
+    removePidFile();
+    process.exit(0);
+  }
+  
+  console.log(`Stopping opencode-pilot (pid ${pid})...`);
+  
+  try {
+    process.kill(pid, "SIGTERM");
+    
+    // Wait for process to exit (up to 5 seconds)
+    let attempts = 0;
+    const maxAttempts = 50;
+    const checkInterval = 100;
+    
+    const waitForExit = () => {
+      if (!isProcessRunning(pid)) {
+        console.log("Service stopped");
+        process.exit(0);
+      }
+      
+      attempts++;
+      if (attempts >= maxAttempts) {
+        console.log("Service did not stop gracefully, sending SIGKILL...");
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+          // Process may have exited
+        }
+        removePidFile();
+        console.log("Service killed");
+        process.exit(0);
+      }
+      
+      setTimeout(waitForExit, checkInterval);
+    };
+    
+    setTimeout(waitForExit, checkInterval);
+  } catch (err) {
+    if (err.code === "ESRCH") {
+      console.log("Service is not running");
+      removePidFile();
+    } else {
+      console.error(`Failed to stop service: ${err.message}`);
+      process.exit(1);
+    }
+  }
+}
+
 // ============================================================================
 // Status Command
 // ============================================================================
 
-function statusCommand() {
-  console.log("opencode-pilot status");
-  console.log("=====================");
+async function statusCommand() {
+  const { getVersion } = await import(join(serviceDir, "version.js"));
+  const version = getVersion();
+  console.log(`opencode-pilot v${version}`);
+  console.log("=".repeat(`opencode-pilot v${version}`.length));
   console.log("");
 
   // Service running? Check if HTTP responds
@@ -702,8 +830,12 @@ async function main() {
       await startCommand();
       break;
 
+    case "stop":
+      stopCommand();
+      break;
+
     case "status":
-      statusCommand();
+      await statusCommand();
       break;
 
     case "config":

package/package.json

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

package/plugin/index.js

@@ -2,12 +2,14 @@
 //
 // Add "opencode-pilot" to your opencode.json plugins array to enable.
 // The plugin checks if the daemon is running and starts it if needed.
+// If the running daemon has a different version, it will be restarted.
 
 import { existsSync, readFileSync } from 'fs'
-import { spawn } from 'child_process'
+import { spawn, spawnSync } from 'child_process'
 import { join } from 'path'
 import { homedir } from 'os'
 import YAML from 'yaml'
+import { getVersion } from '../service/version.js'
 
 const DEFAULT_PORT = 4097
 const CONFIG_PATH = join(homedir(), '.config', 'opencode', 'pilot', 'config.yaml')
@@ -32,31 +34,67 @@ function getPort() {
 }
 
 /**
- * OpenCode plugin that auto-starts the daemon if not running
+ * Start the daemon as a detached background process
+ */
+function startDaemon() {
+  try {
+    const child = spawn('npx', ['opencode-pilot', 'start'], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+  } catch {
+    // Ignore start errors
+  }
+}
+
+/**
+ * Stop the daemon synchronously
+ */
+function stopDaemon() {
+  try {
+    spawnSync('npx', ['opencode-pilot', 'stop'], {
+      stdio: 'ignore',
+      timeout: 10000,
+    })
+  } catch {
+    // Ignore stop errors
+  }
+}
+
+/**
+ * OpenCode plugin that auto-starts the daemon if not running.
+ * If a daemon is running with a different version, it will be restarted.
  */
 export const PilotPlugin = async () => {
   const port = getPort()
+  const ourVersion = getVersion()
   
   try {
     // Check if daemon is already running
     const res = await fetch(`http://localhost:${port}/health`, {
       signal: AbortSignal.timeout(1000)
     })
+    
     if (res.ok) {
-      // Already running, nothing to do
+      // Check version
+      const data = await res.json()
+      const runningVersion = data.version
+      
+      if (runningVersion && runningVersion !== ourVersion && ourVersion !== 'unknown') {
+        // Version mismatch - restart daemon
+        console.log(`[opencode-pilot] Version mismatch (running: ${runningVersion}, plugin: ${ourVersion}), restarting...`)
+        stopDaemon()
+        // Small delay to ensure port is released
+        await new Promise(resolve => setTimeout(resolve, 500))
+        startDaemon()
+      }
+      // else: same version, nothing to do
       return {}
     }
   } catch {
-    // Not running, start it as detached background process
-    try {
-      const child = spawn('npx', ['opencode-pilot', 'start'], {
-        detached: true,
-        stdio: 'ignore',
-      })
-      child.unref()
-    } catch {
-      // Ignore start errors
-    }
+    // Not running or error, start it
+    startDaemon()
   }
   
   return {}

package/service/poller.js

@@ -437,21 +437,54 @@ async function fetchPrReviewCommentsViaCli(owner, repo, number, timeout) {
   }
 }
 
+/**
+ * Fetch PR reviews using gh CLI
+ * 
+ * Fetches formal PR reviews (APPROVED, CHANGES_REQUESTED, COMMENTED state).
+ * These are separate from inline comments and issue comments.
+ * 
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} number - PR number
+ * @param {number} timeout - Timeout in ms
+ * @returns {Promise<Array>} Array of review objects with user, state, body
+ */
+async function fetchPrReviewsViaCli(owner, repo, number, timeout) {
+  const { exec } = await import('child_process');
+  const { promisify } = await import('util');
+  const execAsync = promisify(exec);
+  
+  try {
+    const { stdout } = await Promise.race([
+      execAsync(`gh api repos/${owner}/${repo}/pulls/${number}/reviews`),
+      createTimeout(timeout, "gh api call for PR reviews"),
+    ]);
+    
+    const reviews = JSON.parse(stdout);
+    return Array.isArray(reviews) ? reviews : [];
+  } catch (err) {
+    console.error(`[poller] Error fetching PR reviews via gh: ${err.message}`);
+    return [];
+  }
+}
+
 /**
  * Fetch comments for a GitHub issue/PR and enrich the item
  * 
- * Fetches BOTH types of comments using gh CLI:
+ * Fetches THREE types of feedback using gh CLI:
  * 1. PR review comments (inline code comments) via gh api pulls/{number}/comments
  * 2. Issue comments (conversation thread) via gh api issues/{number}/comments
+ * 3. PR reviews (formal reviews) via gh api pulls/{number}/reviews
  * 
  * This is necessary because:
  * - Bots like Linear post to issue comments, not PR review comments
  * - Human reviewers post inline feedback as PR review comments
+ * - Formal PR reviews (APPROVED, CHANGES_REQUESTED, COMMENTED) are stored separately
  * 
  * @param {object} item - Item with repository_full_name and number fields
  * @param {object} [options] - Options
  * @param {number} [options.timeout] - Timeout in ms (default: 30000)
- * @returns {Promise<Array>} Array of comment objects (merged from both endpoints)
+ * @returns {Promise<Array>} Array of comment/review objects (merged from all endpoints)
  */
 export async function fetchGitHubComments(item, options = {}) {
   const timeout = options.timeout || DEFAULT_MCP_TIMEOUT;
@@ -473,16 +506,18 @@ export async function fetchGitHubComments(item, options = {}) {
   }
   
   try {
-    // Fetch both PR review comments AND issue comments in parallel via gh CLI
-    const [prComments, issueComments] = await Promise.all([
+    // Fetch PR review comments, issue comments, AND PR reviews in parallel via gh CLI
+    const [prComments, issueComments, prReviews] = await Promise.all([
       // PR review comments (inline code comments from reviewers)
       fetchPrReviewCommentsViaCli(owner, repo, number, timeout),
       // Issue comments (conversation thread where Linear bot posts)
       fetchIssueCommentsViaCli(owner, repo, number, timeout),
+      // PR reviews (formal reviews: APPROVED, CHANGES_REQUESTED, COMMENTED)
+      fetchPrReviewsViaCli(owner, repo, number, timeout),
     ]);
     
-    // Return merged comments from both sources
-    return [...prComments, ...issueComments];
+    // Return merged feedback from all sources
+    return [...prComments, ...issueComments, ...prReviews];
   } catch (err) {
     console.error(`[poller] Error fetching comments: ${err.message}`);
     return [];

package/service/server.js

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'url'
 import { homedir } from 'os'
 import { join } from 'path'
 import YAML from 'yaml'
+import { getVersion } from './version.js'
 
 // Default configuration
 const DEFAULT_HTTP_PORT = 4097
@@ -56,10 +57,11 @@ function createHttpServer_(port) {
       return
     }
     
-    // GET /health - Health check
+    // GET /health - Health check with version
     if (req.method === 'GET' && url.pathname === '/health') {
-      res.writeHead(200, { 'Content-Type': 'text/plain' })
-      res.end('OK')
+      const version = getVersion()
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ status: 'ok', version }))
       return
     }
     

package/service/utils.js

@@ -70,17 +70,64 @@ export function isBot(username, type) {
 }
 
 /**
- * Check if a PR/issue has non-bot feedback (comments from humans other than the author)
+ * Check if feedback is a PR review (has state field from /pulls/{number}/reviews)
+ * 
+ * PR reviews have a state field: APPROVED, CHANGES_REQUESTED, COMMENTED, PENDING, DISMISSED
+ * Regular comments (from /issues/{number}/comments or /pulls/{number}/comments) don't have state.
+ * 
+ * @param {object} feedback - Comment or review object
+ * @returns {boolean} True if this is a PR review (not a regular comment)
+ */
+export function isPrReview(feedback) {
+  return feedback && typeof feedback.state === 'string';
+}
+
+/**
+ * Check if feedback is an inline PR comment (from /pulls/{number}/comments)
+ * 
+ * Inline comments have path, position, or diff_hunk fields that top-level comments don't have.
+ * They may also have in_reply_to_id if they're replies to other inline comments.
+ * 
+ * @param {object} feedback - Comment or review object
+ * @returns {boolean} True if this is an inline PR comment
+ */
+export function isInlineComment(feedback) {
+  if (!feedback) return false;
+  // Inline comments have path (file path) and usually diff_hunk or position
+  return typeof feedback.path === 'string' || typeof feedback.diff_hunk === 'string';
+}
+
+/**
+ * Check if feedback is a reply to another comment
+ * 
+ * @param {object} feedback - Comment or review object
+ * @returns {boolean} True if this is a reply
+ */
+export function isReply(feedback) {
+  if (!feedback) return false;
+  // PR review comments use in_reply_to_id for replies
+  return feedback.in_reply_to_id !== undefined && feedback.in_reply_to_id !== null;
+}
+
+/**
+ * Check if a PR/issue has actionable feedback
  * 
  * Used to filter out PRs where only bots have commented, since those don't
- * require the author's attention for human feedback.
+ * require the author's attention.
+ * 
+ * Logic for author's own feedback:
+ * - Author's inline comments (standalone) → trigger (self-review on code)
+ * - Author's inline comments (replies) → ignore (responding to reviewer)
+ * - Author's PR reviews → trigger (formal self-review)
+ * - Author's top-level comments → ignore (conversation noise)
  * 
- * Also skips approval-only reviews (APPROVED state with no body text) since
- * approvals don't require action from the author.
+ * Logic for others' feedback:
+ * - Bot comments → ignore
+ * - Human comments/reviews → trigger (except approval-only with no body)
  * 
- * @param {Array} comments - Array of comment objects with user.login and user.type
+ * @param {Array} comments - Array of comment/review 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, actionable comment
+ * @returns {boolean} True if there's at least one actionable feedback item
  */
 export function hasNonBotFeedback(comments, authorUsername) {
   // Handle null/undefined/empty
@@ -97,16 +144,30 @@ export function hasNonBotFeedback(comments, authorUsername) {
     const username = user.login;
     const userType = user.type;
     
-    // Skip if it's a bot
+    // Skip if it's a bot (but Copilot is NOT in bot list, so Copilot reviews are kept)
     if (isBot(username, userType)) continue;
     
-    // Skip if it's the author themselves
-    if (authorLower && username?.toLowerCase() === authorLower) continue;
+    // For author's own feedback, apply special rules
+    if (authorLower && username?.toLowerCase() === authorLower) {
+      // Author's PR reviews → trigger
+      if (isPrReview(comment)) {
+        // Continue to check if it's actionable (not approval-only)
+      }
+      // Author's inline comments (standalone only) → trigger
+      else if (isInlineComment(comment)) {
+        if (isReply(comment)) continue; // Skip replies
+        // Standalone inline comment - continue to actionable check
+      }
+      // Author's top-level comments → ignore
+      else {
+        continue;
+      }
+    }
     
     // Skip approval-only reviews (no actionable feedback)
     if (isApprovalOnly(comment)) continue;
     
-    // Found a non-bot, non-author, actionable comment
+    // Found actionable feedback
     return true;
   }
   

package/service/version.js

@@ -0,0 +1,34 @@
+// Shared version utility for opencode-pilot
+//
+// Returns the version from package.json
+
+import { existsSync, readFileSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+/**
+ * Get version from package.json
+ * Checks multiple locations for compatibility with different install methods
+ * @returns {string} Version string or 'unknown'
+ */
+export function getVersion() {
+  const candidates = [
+    join(__dirname, '..', 'package.json'),      // Development: service/../package.json
+    join(__dirname, '..', '..', 'package.json'), // Homebrew: libexec/../package.json
+  ]
+  
+  for (const packagePath of candidates) {
+    try {
+      if (existsSync(packagePath)) {
+        const pkg = JSON.parse(readFileSync(packagePath, 'utf8'))
+        if (pkg.version) return pkg.version
+      }
+    } catch {
+      // Try next candidate
+    }
+  }
+  return 'unknown'
+}

package/test/unit/server.test.js

@@ -0,0 +1,90 @@
+/**
+ * Tests for service/server.js - HTTP server and health endpoint
+ */
+
+import { test, describe, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get expected version from package.json
+function getExpectedVersion() {
+  const packagePath = join(__dirname, '..', '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+  return pkg.version;
+}
+
+describe('service/server.js', () => {
+  let service = null;
+
+  afterEach(async () => {
+    if (service) {
+      const { stopService } = await import('../../service/server.js');
+      await stopService(service);
+      service = null;
+    }
+  });
+
+  describe('health endpoint', () => {
+    test('returns JSON with status and version', async () => {
+      const { startService, stopService } = await import('../../service/server.js');
+      
+      // Start service on random port
+      service = await startService({ 
+        httpPort: 0,  // Let OS assign port
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/health`);
+      
+      assert.strictEqual(res.status, 200);
+      assert.strictEqual(res.headers.get('content-type'), 'application/json');
+      
+      const data = await res.json();
+      assert.strictEqual(data.status, 'ok');
+      assert.strictEqual(typeof data.version, 'string');
+      assert.strictEqual(data.version, getExpectedVersion());
+    });
+
+  });
+
+  describe('CORS', () => {
+    test('OPTIONS returns CORS headers', async () => {
+      const { startService } = await import('../../service/server.js');
+      
+      service = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/health`, {
+        method: 'OPTIONS'
+      });
+      
+      assert.strictEqual(res.status, 204);
+      assert.strictEqual(res.headers.get('access-control-allow-origin'), '*');
+    });
+  });
+
+  describe('unknown routes', () => {
+    test('returns 404 for unknown paths', async () => {
+      const { startService } = await import('../../service/server.js');
+      
+      service = await startService({ 
+        httpPort: 0,
+        enablePolling: false 
+      });
+      
+      const port = service.httpServer.address().port;
+      const res = await fetch(`http://localhost:${port}/unknown`);
+      
+      assert.strictEqual(res.status, 404);
+    });
+  });
+});

package/test/unit/utils.test.js

@@ -71,9 +71,10 @@ describe('utils.js', () => {
       assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
     });
 
-    test('returns false when only author has commented', async () => {
+    test('returns false when only author has top-level comments', async () => {
       const { hasNonBotFeedback } = await import('../../service/utils.js');
       
+      // Top-level comments from author (no state, no path) are ignored
       const comments = [
         { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
         { user: { login: 'athal7', type: 'User' }, body: 'Added screenshots' },
@@ -82,6 +83,62 @@ describe('utils.js', () => {
       assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
     });
 
+    test('returns true when author has submitted a PR review (self-review)', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // PR reviews from author (have state field) ARE actionable - self-review feedback
+      const comments = [
+        { user: { login: 'github-actions[bot]', type: 'Bot' }, body: 'CI passed' },
+        { user: { login: 'athal7', type: 'User' }, state: 'COMMENTED', body: 'TODO: add tests' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), true);
+    });
+
+    test('returns true when author has standalone inline comment', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // Standalone inline comments from author (have path, no in_reply_to_id) ARE actionable
+      const comments = [
+        { 
+          user: { login: 'athal7', type: 'User' }, 
+          body: 'Need to refactor this', 
+          path: 'src/index.js',
+          diff_hunk: '@@ -1,3 +1,4 @@',
+        },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), true);
+    });
+
+    test('returns false when author has reply inline comment', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // Reply inline comments from author (have in_reply_to_id) are ignored
+      const comments = [
+        { 
+          user: { login: 'athal7', type: 'User' }, 
+          body: 'Fixed!', 
+          path: 'src/index.js',
+          diff_hunk: '@@ -1,3 +1,4 @@',
+          in_reply_to_id: 12345,
+        },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
+    test('returns false when author self-approves with no feedback', async () => {
+      const { hasNonBotFeedback } = await import('../../service/utils.js');
+      
+      // Author's approval-only (no body) should not trigger
+      const comments = [
+        { user: { login: 'athal7', type: 'User' }, state: 'APPROVED', body: '' },
+      ];
+      
+      assert.strictEqual(hasNonBotFeedback(comments, 'athal7'), false);
+    });
+
     test('returns false for empty comments array', async () => {
       const { hasNonBotFeedback } = await import('../../service/utils.js');
       
@@ -173,6 +230,66 @@ describe('utils.js', () => {
     });
   });
 
+  describe('isPrReview', () => {
+    test('returns true for objects with state field', async () => {
+      const { isPrReview } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isPrReview({ state: 'APPROVED' }), true);
+      assert.strictEqual(isPrReview({ state: 'CHANGES_REQUESTED' }), true);
+      assert.strictEqual(isPrReview({ state: 'COMMENTED' }), true);
+    });
+
+    test('returns false for objects without state field', async () => {
+      const { isPrReview } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isPrReview({ body: 'Comment' }), false);
+      assert.strictEqual(isPrReview({}), false);
+      // null/undefined returns falsy (null), which is fine for boolean checks
+      assert.ok(!isPrReview(null));
+      assert.ok(!isPrReview(undefined));
+    });
+  });
+
+  describe('isInlineComment', () => {
+    test('returns true for comments with path field', async () => {
+      const { isInlineComment } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isInlineComment({ path: 'src/index.js', body: 'Fix this' }), true);
+    });
+
+    test('returns true for comments with diff_hunk field', async () => {
+      const { isInlineComment } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isInlineComment({ diff_hunk: '@@ -1,3 +1,4 @@', body: 'Nice' }), true);
+    });
+
+    test('returns false for top-level comments', async () => {
+      const { isInlineComment } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isInlineComment({ body: 'Great work!' }), false);
+      assert.strictEqual(isInlineComment({}), false);
+      assert.strictEqual(isInlineComment(null), false);
+    });
+  });
+
+  describe('isReply', () => {
+    test('returns true for comments with in_reply_to_id', async () => {
+      const { isReply } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isReply({ in_reply_to_id: 12345 }), true);
+      assert.strictEqual(isReply({ in_reply_to_id: 0 }), true);
+    });
+
+    test('returns false for standalone comments', async () => {
+      const { isReply } = await import('../../service/utils.js');
+      
+      assert.strictEqual(isReply({ body: 'Standalone' }), false);
+      assert.strictEqual(isReply({ in_reply_to_id: null }), false);
+      assert.strictEqual(isReply({ in_reply_to_id: undefined }), false);
+      assert.strictEqual(isReply(null), false);
+    });
+  });
+
   describe('getNestedValue', () => {
     test('gets top-level value', async () => {
       const { getNestedValue } = await import('../../service/utils.js');