opencode-pilot 0.20.0 → 0.20.2

package/package.json

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

package/service/actions.js

@@ -14,6 +14,84 @@ import { resolveWorktreeDirectory, getProjectInfo, getProjectInfoForDirectory }
 import path from "path";
 import os from "os";
 
+/**
+ * Parse a slash command from the beginning of a prompt
+ * Returns null if the prompt doesn't start with a slash command
+ * 
+ * @param {string} prompt - The prompt text
+ * @returns {object|null} { command, arguments, rest } or null
+ */
+export function parseSlashCommand(prompt) {
+  if (!prompt || typeof prompt !== 'string') {
+    return null;
+  }
+  
+  // Match /command at the start, followed by optional arguments on the same line
+  // Command names can contain letters, numbers, hyphens, and underscores
+  const match = prompt.match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/m);
+  
+  if (!match) {
+    return null;
+  }
+  
+  const command = match[1];
+  const firstLineArgs = match[2]?.trim() || '';
+  
+  // Find where the first line ends to get the "rest" of the prompt
+  const firstNewline = prompt.indexOf('\n');
+  const rest = firstNewline >= 0 ? prompt.slice(firstNewline + 1).trim() : '';
+  
+  return {
+    command,
+    arguments: firstLineArgs,
+    rest,
+  };
+}
+
+/**
+ * Send a command to a session via the /command endpoint
+ * 
+ * @param {string} serverUrl - Server URL
+ * @param {string} sessionId - Session ID
+ * @param {string} directory - Working directory
+ * @param {object} parsedCommand - Parsed command from parseSlashCommand
+ * @param {object} [options] - Options
+ * @param {string} [options.agent] - Agent to use
+ * @param {string} [options.model] - Model to use
+ * @param {function} [options.fetch] - Custom fetch function (for testing)
+ * @returns {Promise<Response>} The fetch response
+ */
+async function sendCommand(serverUrl, sessionId, directory, parsedCommand, options = {}) {
+  const fetchFn = options.fetch || fetch;
+  
+  const commandUrl = new URL(`/session/${sessionId}/command`, serverUrl);
+  commandUrl.searchParams.set('directory', directory);
+  
+  // Build command body per OpenCode API schema
+  const commandBody = {
+    command: parsedCommand.command,
+    arguments: parsedCommand.arguments,
+  };
+  
+  // Add agent if specified
+  if (options.agent) {
+    commandBody.agent = options.agent;
+  }
+  
+  // Add model if specified (the /command endpoint takes model as a single string)
+  if (options.model) {
+    commandBody.model = options.model;
+  }
+  
+  debug(`sendCommand: POST ${commandUrl} command=${parsedCommand.command} args=${parsedCommand.arguments}`);
+  
+  return fetchFn(commandUrl.toString(), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(commandBody),
+  });
+}
+
 /**
  * Get running opencode server ports by parsing lsof output
  * @returns {Promise<number[]>} Array of port numbers
@@ -455,50 +533,65 @@ export async function sendMessageToSession(serverUrl, sessionId, directory, prom
       debug(`sendMessageToSession: updated title for session ${sessionId}`);
     }
     
-    // Step 2: Send the message
-    const messageUrl = new URL(`/session/${sessionId}/message`, serverUrl);
-    messageUrl.searchParams.set('directory', directory);
-    
-    const messageBody = {
-      parts: [{ type: 'text', text: prompt }],
-    };
-    
-    if (options.agent) {
-      messageBody.agent = options.agent;
-    }
-    
-    if (options.model) {
-      const [providerID, modelID] = options.model.includes('/') 
-        ? options.model.split('/', 2) 
-        : ['anthropic', options.model];
-      messageBody.providerID = providerID;
-      messageBody.modelID = modelID;
-    }
+    // Step 2: Check if the prompt starts with a slash command
+    const parsedCommand = parseSlashCommand(prompt);
     
     // Use AbortController with timeout (same pattern as createSessionViaApi)
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10000);
     
     try {
-      const messageResponse = await fetchFn(messageUrl.toString(), {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(messageBody),
-        signal: controller.signal,
-      });
+      let response;
+      
+      if (parsedCommand) {
+        // Use the /command endpoint for slash commands
+        debug(`sendMessageToSession: detected command /${parsedCommand.command}`);
+        response = await sendCommand(serverUrl, sessionId, directory, parsedCommand, {
+          agent: options.agent,
+          model: options.model,
+          fetch: (url, opts) => fetchFn(url, { ...opts, signal: controller.signal }),
+        });
+      } else {
+        // Use the /message endpoint for regular prompts
+        const messageUrl = new URL(`/session/${sessionId}/message`, serverUrl);
+        messageUrl.searchParams.set('directory', directory);
+        
+        const messageBody = {
+          parts: [{ type: 'text', text: prompt }],
+        };
+        
+        if (options.agent) {
+          messageBody.agent = options.agent;
+        }
+        
+        if (options.model) {
+          const [providerID, modelID] = options.model.includes('/') 
+            ? options.model.split('/', 2) 
+            : ['anthropic', options.model];
+          messageBody.providerID = providerID;
+          messageBody.modelID = modelID;
+        }
+        
+        response = await fetchFn(messageUrl.toString(), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(messageBody),
+          signal: controller.signal,
+        });
+      }
       
       clearTimeout(timeoutId);
       
-      if (!messageResponse.ok) {
-        const errorText = await messageResponse.text();
-        throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to send ${parsedCommand ? 'command' : 'message'}: ${response.status} ${errorText}`);
       }
       
-      debug(`sendMessageToSession: sent message to session ${sessionId}`);
+      debug(`sendMessageToSession: sent ${parsedCommand ? 'command' : 'message'} to session ${sessionId}`);
     } catch (abortErr) {
       clearTimeout(timeoutId);
       if (abortErr.name === 'AbortError') {
-        debug(`sendMessageToSession: message request started for session ${sessionId} (response aborted as expected)`);
+        debug(`sendMessageToSession: request started for session ${sessionId} (response aborted as expected)`);
       } else {
         throw abortErr;
       }
@@ -610,58 +703,72 @@ export async function createSessionViaApi(serverUrl, directory, prompt, options
       });
     }
     
-    // Step 3: Send the initial message
-    const messageUrl = new URL(`/session/${session.id}/message`, serverUrl);
-    messageUrl.searchParams.set('directory', directory);
-    
-    // Build message body
-    const messageBody = {
-      parts: [{ type: 'text', text: prompt }],
-    };
-    
-    // Add agent if specified
-    if (options.agent) {
-      messageBody.agent = options.agent;
-    }
-    
-    // Add model if specified (format: provider/model)
-    if (options.model) {
-      const [providerID, modelID] = options.model.includes('/') 
-        ? options.model.split('/', 2) 
-        : ['anthropic', options.model];
-      messageBody.providerID = providerID;
-      messageBody.modelID = modelID;
-    }
+    // Step 3: Check if the prompt starts with a slash command
+    const parsedCommand = parseSlashCommand(prompt);
     
-    // Use AbortController with timeout for the message POST
-    // The /session/{id}/message endpoint returns a chunked/streaming response
-    // that stays open until the agent completes. We only need to verify the
-    // request was accepted (2xx status), not wait for the full response.
+    // Use AbortController with timeout for the request
+    // The endpoints return a chunked/streaming response that stays open until
+    // the agent completes. We only need to verify the request was accepted.
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
     
     try {
-      const messageResponse = await fetchFn(messageUrl.toString(), {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(messageBody),
-        signal: controller.signal,
-      });
+      let response;
+      
+      if (parsedCommand) {
+        // Use the /command endpoint for slash commands
+        debug(`createSessionViaApi: detected command /${parsedCommand.command}`);
+        response = await sendCommand(serverUrl, session.id, directory, parsedCommand, {
+          agent: options.agent,
+          model: options.model,
+          fetch: (url, opts) => fetchFn(url, { ...opts, signal: controller.signal }),
+        });
+      } else {
+        // Use the /message endpoint for regular prompts
+        const messageUrl = new URL(`/session/${session.id}/message`, serverUrl);
+        messageUrl.searchParams.set('directory', directory);
+        
+        // Build message body
+        const messageBody = {
+          parts: [{ type: 'text', text: prompt }],
+        };
+        
+        // Add agent if specified
+        if (options.agent) {
+          messageBody.agent = options.agent;
+        }
+        
+        // Add model if specified (format: provider/model)
+        if (options.model) {
+          const [providerID, modelID] = options.model.includes('/') 
+            ? options.model.split('/', 2) 
+            : ['anthropic', options.model];
+          messageBody.providerID = providerID;
+          messageBody.modelID = modelID;
+        }
+        
+        response = await fetchFn(messageUrl.toString(), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(messageBody),
+          signal: controller.signal,
+        });
+      }
       
       clearTimeout(timeoutId);
       
-      if (!messageResponse.ok) {
-        const errorText = await messageResponse.text();
-        throw new Error(`Failed to send message: ${messageResponse.status} ${errorText}`);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to send ${parsedCommand ? 'command' : 'message'}: ${response.status} ${errorText}`);
       }
       
-      debug(`createSessionViaApi: sent message to session ${session.id}`);
+      debug(`createSessionViaApi: sent ${parsedCommand ? 'command' : 'message'} to session ${session.id}`);
     } catch (abortErr) {
       clearTimeout(timeoutId);
       // AbortError is expected - we intentionally abort after verifying the request started
-      // The server accepted our message, we just don't need to wait for the response
+      // The server accepted our request, we just don't need to wait for the response
       if (abortErr.name === 'AbortError') {
-        debug(`createSessionViaApi: message request started for session ${session.id} (response aborted as expected)`);
+        debug(`createSessionViaApi: request started for session ${session.id} (response aborted as expected)`);
       } else {
         throw abortErr;
       }

package/service/presets/github.yaml

@@ -10,6 +10,7 @@ _provider:
     html_url: url
     repository_full_name: repository.nameWithOwner
     updated_at: updatedAt
+    comments: commentsCount
   # Reprocess items when state changes (e.g., reopened issues)
   # Note: updated_at is NOT included because our own changes would trigger reprocessing
   reprocess_on:

package/test/unit/actions.test.js

@@ -97,6 +97,96 @@ describe('actions.js', () => {
     });
   });
 
+  describe('parseSlashCommand', () => {
+    test('parses /review command with URL argument', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/review https://github.com/org/repo/pull/123');
+      
+      assert.strictEqual(result.command, 'review');
+      assert.strictEqual(result.arguments, 'https://github.com/org/repo/pull/123');
+      assert.strictEqual(result.rest, '');
+    });
+
+    test('parses /devcontainer command with URL argument', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/devcontainer https://github.com/org/repo/issues/456');
+      
+      assert.strictEqual(result.command, 'devcontainer');
+      assert.strictEqual(result.arguments, 'https://github.com/org/repo/issues/456');
+      assert.strictEqual(result.rest, '');
+    });
+
+    test('parses command with multiline rest content', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const prompt = `/review https://github.com/org/repo/pull/123
+
+Review this pull request:
+
+Check for bugs and security issues.`;
+      
+      const result = parseSlashCommand(prompt);
+      
+      assert.strictEqual(result.command, 'review');
+      assert.strictEqual(result.arguments, 'https://github.com/org/repo/pull/123');
+      assert.ok(result.rest.includes('Review this pull request'));
+      assert.ok(result.rest.includes('Check for bugs'));
+    });
+
+    test('parses command without arguments', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/help');
+      
+      assert.strictEqual(result.command, 'help');
+      assert.strictEqual(result.arguments, '');
+      assert.strictEqual(result.rest, '');
+    });
+
+    test('parses command with hyphen in name', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/my-custom-command arg1 arg2');
+      
+      assert.strictEqual(result.command, 'my-custom-command');
+      assert.strictEqual(result.arguments, 'arg1 arg2');
+    });
+
+    test('returns null for regular prompt without slash', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('Fix the bug in the login page');
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('returns null for prompt with slash in middle', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('Check the path/to/file for issues');
+      
+      assert.strictEqual(result, null);
+    });
+
+    test('returns null for empty string', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      assert.strictEqual(parseSlashCommand(''), null);
+      assert.strictEqual(parseSlashCommand(null), null);
+      assert.strictEqual(parseSlashCommand(undefined), null);
+    });
+
+    test('returns null for just a slash', async () => {
+      const { parseSlashCommand } = await import('../../service/actions.js');
+      
+      const result = parseSlashCommand('/');
+      
+      assert.strictEqual(result, null);
+    });
+  });
+
   describe('getActionConfig', () => {
     test('merges source, repo, and defaults', async () => {
       const { getActionConfig } = await import('../../service/actions.js');
@@ -903,6 +993,253 @@ describe('actions.js', () => {
       assert.ok(result.warning, 'Should include warning about message failure');
       assert.ok(result.warning.includes('Failed to send message'), 'Warning should mention message failure');
     });
+
+    test('uses /command endpoint for slash commands', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_cmd123';
+      let commandCalled = false;
+      let commandUrl = null;
+      let commandBody = null;
+      let messageCalled = false;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          commandUrl = url;
+          commandBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        // PATCH for title update
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        '/review https://github.com/org/repo/pull/123',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(commandCalled, 'Should call /command endpoint');
+      assert.ok(!messageCalled, 'Should NOT call /message endpoint');
+      assert.ok(commandUrl.includes('/command'), 'URL should be /command endpoint');
+      assert.strictEqual(commandBody.command, 'review', 'Should pass command name');
+      assert.strictEqual(commandBody.arguments, 'https://github.com/org/repo/pull/123', 'Should pass arguments');
+    });
+
+    test('uses /message endpoint for regular prompts (not slash commands)', async () => {
+      const { createSessionViaApi } = await import('../../service/actions.js');
+      
+      const mockSessionId = 'ses_msg123';
+      let commandCalled = false;
+      let messageCalled = false;
+      let messageBody = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname === '/session' && opts?.method === 'POST') {
+          return {
+            ok: true,
+            json: async () => ({ id: mockSessionId }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          messageBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await createSessionViaApi(
+        'http://localhost:4096',
+        '/path/to/project',
+        'Fix the bug in the login page',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(!commandCalled, 'Should NOT call /command endpoint');
+      assert.ok(messageCalled, 'Should call /message endpoint');
+      assert.strictEqual(messageBody.parts[0].text, 'Fix the bug in the login page', 'Should pass prompt as message text');
+    });
+  });
+
+  describe('sendMessageToSession slash command routing', () => {
+    test('uses /command endpoint for slash commands', async () => {
+      const { sendMessageToSession } = await import('../../service/actions.js');
+      
+      let commandCalled = false;
+      let commandBody = null;
+      let messageCalled = false;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          commandBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        // PATCH for title update
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await sendMessageToSession(
+        'http://localhost:4096',
+        'ses_existing',
+        '/path/to/project',
+        '/devcontainer https://github.com/org/repo/issues/456',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(commandCalled, 'Should call /command endpoint');
+      assert.ok(!messageCalled, 'Should NOT call /message endpoint');
+      assert.strictEqual(commandBody.command, 'devcontainer', 'Should pass command name');
+      assert.strictEqual(commandBody.arguments, 'https://github.com/org/repo/issues/456', 'Should pass arguments');
+    });
+
+    test('uses /message endpoint for regular prompts', async () => {
+      const { sendMessageToSession } = await import('../../service/actions.js');
+      
+      let commandCalled = false;
+      let messageCalled = false;
+      let messageBody = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandCalled = true;
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        if (urlObj.pathname.includes('/message') && opts?.method === 'POST') {
+          messageCalled = true;
+          messageBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      const result = await sendMessageToSession(
+        'http://localhost:4096',
+        'ses_existing',
+        '/path/to/project',
+        'Please fix the bug',
+        { fetch: mockFetch }
+      );
+      
+      assert.ok(result.success, 'Should succeed');
+      assert.ok(!commandCalled, 'Should NOT call /command endpoint');
+      assert.ok(messageCalled, 'Should call /message endpoint');
+      assert.strictEqual(messageBody.parts[0].text, 'Please fix the bug', 'Should pass prompt as message text');
+    });
+
+    test('passes agent and model to /command endpoint', async () => {
+      const { sendMessageToSession } = await import('../../service/actions.js');
+      
+      let commandBody = null;
+      
+      const mockFetch = async (url, opts) => {
+        const urlObj = new URL(url);
+        
+        if (urlObj.pathname.includes('/command') && opts?.method === 'POST') {
+          commandBody = JSON.parse(opts.body);
+          return {
+            ok: true,
+            json: async () => ({ success: true }),
+          };
+        }
+        
+        // PATCH for title update
+        if (opts?.method === 'PATCH') {
+          return { ok: true, json: async () => ({}) };
+        }
+        
+        return { ok: false, text: async () => 'Not found' };
+      };
+      
+      await sendMessageToSession(
+        'http://localhost:4096',
+        'ses_existing',
+        '/path/to/project',
+        '/review https://github.com/org/repo/pull/123',
+        { 
+          fetch: mockFetch,
+          agent: 'code',
+          model: 'anthropic/claude-sonnet-4-20250514',
+        }
+      );
+      
+      assert.strictEqual(commandBody.agent, 'code', 'Should pass agent');
+      assert.strictEqual(commandBody.model, 'anthropic/claude-sonnet-4-20250514', 'Should pass model as string');
+    });
   });
 
   describe('session reuse', () => {

package/test/unit/poller.test.js

@@ -786,6 +786,31 @@ describe('poller.js', () => {
       
       assert.strictEqual(mapped.number, undefined);
     });
+
+    test('maps commentsCount to comments for GitHub PR enrichment', async () => {
+      const { applyMappings } = await import('../../service/poller.js');
+      
+      // gh search prs returns commentsCount, but enrichItemsWithComments checks for 'comments'
+      const item = {
+        number: 123,
+        title: 'Fix mobile overflow',
+        commentsCount: 4,
+        repository: { nameWithOwner: 'anomalyco/opencode' }
+      };
+      const mappings = {
+        comments: 'commentsCount',
+        repository_full_name: 'repository.nameWithOwner'
+      };
+      
+      const mapped = applyMappings(item, mappings);
+      
+      // comments field should be set from commentsCount
+      assert.strictEqual(mapped.comments, 4);
+      // Original commentsCount preserved
+      assert.strictEqual(mapped.commentsCount, 4);
+      // Other mappings work too
+      assert.strictEqual(mapped.repository_full_name, 'anomalyco/opencode');
+    });
   });
 
   describe('fetchGitHubComments', () => {