opencode-pilot 0.24.12 → 0.25.1

package/Formula/opencode-pilot.rb

@@ -1,8 +1,8 @@
 class OpencodePilot < Formula
   desc "Automation daemon for OpenCode - polls GitHub/Linear issues and spawns sessions"
   homepage "https://github.com/athal7/opencode-pilot"
-  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.11.tar.gz"
-  sha256 "c0c9e3cdb3b34275d7a1d63b128430dd7e6fdd00dc8fe9e3baa5f3124b955422"
+  url "https://github.com/athal7/opencode-pilot/archive/refs/tags/v0.24.12.tar.gz"
+  sha256 "ea6f7ba7814225f9e312143f0222777bf4094da87cdbadad1e6589208c5323ab"
   license "MIT"
 
   depends_on "node"

package/bin/opencode-pilot

@@ -14,7 +14,7 @@
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
 import os from "os";
 import YAML from "yaml";
 
@@ -179,6 +179,7 @@ Commands:
   status               Show service status and version
   config               Validate and show configuration
   clear                Clear processed state entries
+  logs                 Show debug log output
   test-source NAME     Test a source by fetching items and showing mappings
   test-mapping MCP     Test field mappings with sample JSON input
   help                 Show this help message
@@ -189,6 +190,11 @@ Clear options:
   --item ID            Clear a specific item
   --expired            Clear only expired entries (uses configured TTL)
 
+Logs options:
+  --path               Print the log file path and exit
+  --lines N            Print last N lines (default: 50)
+  --follow             Follow the log file (like tail -f)
+
 The service handles:
 - Polling for GitHub/Linear issues to work on
 - Spawning OpenCode sessions for ready items
@@ -200,6 +206,10 @@ Examples:
   opencode-pilot config                  # Validate and show config
   opencode-pilot clear --all             # Clear all processed state
   opencode-pilot clear --expired         # Clear expired entries
+  opencode-pilot logs                    # Show last 50 log lines
+  opencode-pilot logs --lines 100        # Show last 100 log lines
+  opencode-pilot logs --follow           # Follow the log in real time
+  opencode-pilot logs --path             # Print the log file path
   opencode-pilot test-source my-issues   # Test a source
   echo '{"url":"https://linear.app/team/issue/PROJ-123/title"}' | opencode-pilot test-mapping linear
 `);
@@ -812,6 +822,87 @@ async function clearCommand(flags) {
   }
 }
 
+// ============================================================================
+// Logs Command
+// ============================================================================
+
+// Default log path (mirrors service/logger.js)
+const DEFAULT_LOG_PATH = join(os.homedir(), ".local", "share", "opencode-pilot", "debug.log");
+
+/**
+ * Resolve the debug log file path.
+ * Can be overridden via PILOT_LOG_PATH env var (used in tests).
+ */
+function getLogPath() {
+  return process.env.PILOT_LOG_PATH || DEFAULT_LOG_PATH;
+}
+
+/**
+ * Read the last `n` lines from a file synchronously.
+ * Returns an empty array if the file does not exist.
+ */
+function tailLines(filePath, n) {
+  if (!existsSync(filePath)) return [];
+  const content = readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  // Remove trailing empty line produced by a file ending with \n
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines.slice(-n);
+}
+
+/**
+ * Parse a --lines flag value, falling back to `defaultN` for missing/invalid input.
+ */
+function parseLineCount(value, defaultN) {
+  if (value === undefined || value === true || value === false) return defaultN;
+  const n = parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : defaultN;
+}
+
+async function logsCommand(flags) {
+  const logPath = getLogPath();
+
+  // --path: just print the path and exit
+  if (flags.path) {
+    console.log(logPath);
+    return;
+  }
+
+  // --follow: stream the file using tail -f
+  if (flags.follow) {
+    if (!existsSync(logPath)) {
+      console.log(`No log file yet. Enable debug logging with PILOT_DEBUG=true.`);
+      console.log(`Log path: ${logPath}`);
+      return;
+    }
+    const lineCount = parseLineCount(flags.lines, 50);
+    // Use system `tail -f` for reliable follow behaviour
+    const tail = spawn("tail", ["-f", "-n", String(lineCount), logPath], {
+      stdio: ["ignore", "inherit", "inherit"],
+    });
+    await new Promise((resolve, reject) => {
+      tail.on("error", reject);
+      tail.on("close", resolve);
+    });
+    return;
+  }
+
+  // Default: print last N lines
+  const n = parseLineCount(flags.lines, 50);
+  if (!existsSync(logPath)) {
+    console.log(`No log file found. Debug logging is enabled via PILOT_DEBUG=true.`);
+    console.log(`Log path: ${logPath}`);
+    return;
+  }
+
+  const lines = tailLines(logPath, n);
+  if (lines.length === 0) {
+    console.log(`Log file is empty: ${logPath}`);
+    return;
+  }
+  console.log(lines.join("\n"));
+}
+
 // ============================================================================
 // Main
 // ============================================================================
@@ -846,6 +937,10 @@ async function main() {
       await clearCommand(parseArgs(args).flags);
       break;
 
+    case "logs":
+      await logsCommand(parseArgs(args).flags);
+      break;
+
     case "test-source":
       await testSourceCommand(subcommand);
       break;

package/package.json

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

package/service/poller.js

@@ -1215,7 +1215,20 @@ export function createPoller(options = {}) {
       if (!meta) return false; // Not processed before
       
       // Check if item reappeared after being missing (e.g., uncompleted reminder)
+      // Exception: suppress reprocessing when the item cycled through an intermediate
+      // state (e.g., Linear: In Progress -> In Review -> In Progress). If the stored
+      // state and the current state are both "in progress", the issue just passed
+      // through code review and back — no new work is needed.
       if (meta.wasUnseen) {
+        const storedState = meta.itemState;
+        const currentState = item.state || item.status;
+        if (storedState && currentState) {
+          const stored = storedState.toLowerCase();
+          const current = currentState.toLowerCase();
+          if (stored === 'in progress' && current === 'in progress') {
+            return false;
+          }
+        }
         return true;
       }
       

package/test/unit/logs.test.js

@@ -0,0 +1,120 @@
+/**
+ * Tests for the `logs` CLI command.
+ *
+ * The command prints the debug log path and optionally tails/follows it.
+ * Flags:
+ *   --path     Print only the log file path
+ *   --lines N  Print last N lines (default 50)
+ *   --follow   Follow the log file (tail -f)
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert";
+import { spawnSync } from "child_process";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  writeFileSync,
+  mkdirSync,
+  rmSync,
+  existsSync,
+} from "fs";
+import { tmpdir } from "os";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI = join(__dirname, "..", "..", "bin", "opencode-pilot");
+
+// Helper: run opencode-pilot with overridden log path via env
+function runLogs(args = [], env = {}) {
+  return spawnSync(process.execPath, [CLI, "logs", ...args], {
+    encoding: "utf8",
+    timeout: 5000,
+    env: { ...process.env, ...env },
+  });
+}
+
+describe("logs command", () => {
+  let tmpDir;
+  let logFile;
+
+  // Create a temp log file for each test group
+  function setupLogFile(lines = []) {
+    tmpDir = join(tmpdir(), `opencode-pilot-test-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+    logFile = join(tmpDir, "debug.log");
+    if (lines.length) {
+      writeFileSync(logFile, lines.join("\n") + "\n");
+    }
+    return logFile;
+  }
+
+  function cleanup() {
+    if (tmpDir && existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+
+  describe("--path flag", () => {
+    test("prints the log file path", () => {
+      const path = setupLogFile();
+      const result = runLogs(["--path"], { PILOT_LOG_PATH: path });
+      cleanup();
+      assert.strictEqual(result.status, 0);
+      assert.match(result.stdout.trim(), /debug\.log/);
+    });
+
+    test("prints path even when log file does not exist", () => {
+      const nonExistentPath = join(tmpdir(), "no-such-dir", "debug.log");
+      const result = runLogs(["--path"], { PILOT_LOG_PATH: nonExistentPath });
+      assert.strictEqual(result.status, 0);
+      assert.match(result.stdout.trim(), /debug\.log/);
+    });
+  });
+
+  describe("default output (last N lines)", () => {
+    test("prints last 50 lines by default when log exists", () => {
+      const lines = Array.from({ length: 60 }, (_, i) => `line ${i + 1}`);
+      const path = setupLogFile(lines);
+      const result = runLogs([], { PILOT_LOG_PATH: path });
+      cleanup();
+      assert.strictEqual(result.status, 0);
+      // Should contain lines 11-60 (last 50)
+      assert.match(result.stdout, /line 60/);
+      // Lines 1-10 should be excluded (only last 50 of 60 are shown)
+      assert.doesNotMatch(result.stdout, /^line [1-9]\b/m);
+    });
+
+    test("--lines N prints last N lines", () => {
+      const lines = Array.from({ length: 20 }, (_, i) => `entry ${i + 1}`);
+      const path = setupLogFile(lines);
+      const result = runLogs(["--lines", "5"], { PILOT_LOG_PATH: path });
+      cleanup();
+      assert.strictEqual(result.status, 0);
+      assert.match(result.stdout, /entry 20/);
+      assert.doesNotMatch(result.stdout, /entry 1\n/);
+    });
+
+    test("exits 0 with informational message when log does not exist", () => {
+      const nonExistentPath = join(
+        tmpdir(),
+        `no-log-${Date.now()}`,
+        "debug.log"
+      );
+      const result = runLogs([], { PILOT_LOG_PATH: nonExistentPath });
+      assert.strictEqual(result.status, 0);
+      assert.match(result.stdout, /no log/i);
+    });
+  });
+
+  describe("help text", () => {
+    test("opencode-pilot help includes logs command", () => {
+      const result = spawnSync(process.execPath, [CLI, "help"], {
+        encoding: "utf8",
+        timeout: 5000,
+      });
+      assert.strictEqual(result.status, 0);
+      assert.match(result.stdout, /logs/);
+    });
+  });
+});

package/test/unit/poller.test.js

@@ -746,6 +746,25 @@ describe('poller.js', () => {
       );
     });
 
+    test('shouldReprocess returns false when Linear issue cycles in_progress -> code_review -> in_progress', async () => {
+      const { createPoller } = await import('../../service/poller.js');
+
+      const poller = createPoller({ stateFile });
+      // Issue was processed while in_progress
+      poller.markProcessed('linear:ENG-1', { source: 'linear', itemState: 'In Progress' });
+
+      // Issue moved to In Review - disappears from the "my ready issues" poll
+      poller.markUnseen('linear', []);
+
+      // Issue moved back to In Progress - reappears
+      const item = { id: 'linear:ENG-1', status: 'In Progress' };
+      assert.strictEqual(
+        poller.shouldReprocess(item, { reprocessOn: ['status'] }),
+        false,
+        'should NOT reprocess: issue cycled through code review and returned to same in_progress state'
+      );
+    });
+
     test('shouldReprocess returns true for reappeared item (e.g., uncompleted reminder)', async () => {
       const { createPoller } = await import('../../service/poller.js');