feat(config): add custom trigger pattern support for watch mode

Author: stefanoamorelli

codex-cli/src/utils/config.ts

@@ -105,6 +105,17 @@ export type StoredConfig = {
   /** Disable server-side response storage (send full transcript each request) */
   disableResponseStorage?: boolean;
   providers?: Record<string, { name: string; baseURL: string; envKey: string }>;
+  /** Configuration for watch mode */
+  watchMode?: {
+    /** 
+     * Custom trigger pattern. Default is '/(?:\/\/|#|--|;|\'|%|REM)\s*(.*?)(?:,\s*)?AI[!?]/i'.
+     * Must be a valid regular expression string, with the first capture group containing the instruction.
+     * Examples:
+     * - '/(?:\/\/|#)\s*AI:(TODO|FIXME)\s+(.*)/i' to match "// AI:TODO fix this" or "# AI:FIXME handle errors"
+     * - '/(?:\/\/|#)\s*codex[!?]\s+(.*)/i' to match "// codex! fix this" or "# codex? what does this do"
+     */
+    triggerPattern?: string;
+  };
   history?: {
     maxSize?: number;
     saveHistory?: boolean;
@@ -142,6 +153,17 @@ export type AppConfig = {
   /** Enable the "flex-mode" processing mode for supported models (o3, o4-mini) */
   flexMode?: boolean;
   providers?: Record<string, { name: string; baseURL: string; envKey: string }>;
+  /** Configuration for watch mode */
+  watchMode?: {
+    /** 
+     * Custom trigger pattern. Default is '/(?:\/\/|#|--|;|\'|%|REM)\s*(.*?)(?:,\s*)?AI[!?]/i'.
+     * Must be a valid regular expression string, with the first capture group containing the instruction.
+     * Examples:
+     * - '/(?:\/\/|#)\s*AI:(TODO|FIXME)\s+(.*)/i' to match "// AI:TODO fix this" or "# AI:FIXME handle errors"
+     * - '/(?:\/\/|#)\s*codex[!?]\s+(.*)/i' to match "// codex! fix this" or "# codex? what does this do"
+     */
+    triggerPattern?: string;
+  };
   history?: {
     maxSize: number;
     saveHistory: boolean;
@@ -334,6 +356,7 @@ export const loadConfig = (
     notify: storedConfig.notify === true,
     approvalMode: storedConfig.approvalMode,
     disableResponseStorage: storedConfig.disableResponseStorage ?? false,
+    watchMode: storedConfig.watchMode,
   };
 
   // -----------------------------------------------------------------------
@@ -448,6 +471,7 @@ export const saveConfig = (
     provider: config.provider,
     providers: config.providers,
     approvalMode: config.approvalMode,
+    watchMode: config.watchMode,
   };
 
   // Add history settings if they exist

codex-cli/src/utils/watch-mode-utils.ts

@@ -1,29 +1,78 @@
+import { loadConfig } from "./config";
+
 /**
- * Pattern to match various "AI!" style trigger comments with possible instructions
- * Supports multiple single-line programming language comment styles:
- *   - Double slash comment (C, C++, JavaScript, TypeScript, Java, etc.)
- *   - Hash comment (Python, Ruby, Perl, Shell scripts, YAML, etc.)
- *   - Double dash comment (SQL, Haskell, Lua)
- *   - Semicolon comment (Lisp, Clojure, Assembly)
- *   - Single quote comment (VB, VBA)
- *   - Percent comment (LaTeX, Matlab, Erlang)
- *   - REM comment (Batch files)
- *
+ * Custom trigger patterns for watch mode
+ * 
+ * Users can define their own trigger patterns in config.json:
+ * ```json
+ * {
+ *   "watchMode": {
+ *     "triggerPattern": "/(?:\\/\\/|#)\\s*AI:(TODO|FIXME)\\s+(.*)/i"
+ *   }
+ * }
+ * ```
+ * 
+ * The pattern MUST include at least one capture group that will contain the instruction.
+ * 
  * Examples:
+ * 
+ * Default pattern (single-line comments ending with AI! or AI?):
  * - "// what does this function do, AI?"
  * - "# Fix this code, AI!"
  * - "-- Optimize this query, AI!"
+ * 
+ * Custom pattern for task management:
+ * - "// AI:TODO fix this bug"
+ * - "// AI:FIXME handle error case"
+ * - "# AI:BUG this crashes with null input"
+ * 
+ * Custom pattern with different keyword:
+ * - "// codex! fix this"
+ * - "# codex? what does this function do"
  */
 
-export const TRIGGER_PATTERN =
-  /(?:\/\/|#|--|;|'|%|REM)\s*(.*?)(?:,\s*)?AI[!?]/i;
+// Default trigger pattern
+const DEFAULT_TRIGGER_PATTERN = '/(?:\\/\\/|#|--|;|\'|%|REM)\\s*(.*?)(?:,\\s*)?AI[!?]/i';
+
+/**
+ * Get the configured trigger pattern from config.json or use the default
+ * @returns A RegExp object for the trigger pattern
+ */
+export function getTriggerPattern(): RegExp {
+  const config = loadConfig();
+  
+  // Get the pattern string from config or use default
+  const patternString = config.watchMode?.triggerPattern || DEFAULT_TRIGGER_PATTERN;
+  
+  try {
+    // Parse the regex from the string - first remove enclosing slashes and extract flags
+    const match = patternString.match(/^\/(.*)\/([gimuy]*)$/);
+    
+    if (match) {
+      const [, pattern, flags] = match;
+      return new RegExp(pattern, flags);
+    } else {
+      // If not in /pattern/flags format, try to use directly as a RegExp
+      return new RegExp(patternString, 'i');
+    }
+  } catch (error) {
+    console.warn(`Invalid trigger pattern in config: ${patternString}. Using default.`);
+    // Parse default pattern
+    const match = DEFAULT_TRIGGER_PATTERN.match(/^\/(.*)\/([gimuy]*)$/);
+    const [, pattern, flags] = match!;
+    return new RegExp(pattern, flags);
+  }
+}
 
 /**
- * Function to find all AI trigger matches in a file content
+ * Function to find all trigger matches in a file content
+ * Uses the configured trigger pattern from config.json
  */
 export function findAllTriggers(content: string): Array<RegExpMatchArray> {
   const matches: Array<RegExpMatchArray> = [];
-  const regex = new RegExp(TRIGGER_PATTERN, "g");
+  const pattern = getTriggerPattern();
+  // We need to ensure the global flag is set for .exec() to work properly
+  const regex = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : pattern.flags + 'g');
 
   let match;
   while ((match = regex.exec(content)) != null) {
@@ -58,15 +107,22 @@ export function extractContextAroundTrigger(
   // Join the context lines back together
   const context = contextLines.join("\n");
 
-  // Extract the instruction from the capture groups for different comment styles
-  // There are multiple capture groups for different comment syntaxes
-  // Find the first non-undefined capture group
-  let instruction =
-    Array.from(
-      { length: triggerMatch.length - 1 },
-      (_, i) => triggerMatch[i + 1],
-    ).find((group) => group !== undefined) || "fix or improve this code";
-    
+  // Get instruction from capture groups
+  // For custom patterns, check all capture groups and use the last non-empty one
+  // This allows patterns like /AI:(TODO|FIXME)\s+(.*)/ where we want the second group
+  // For the default pattern, it will be the first capture group
+  const captureGroups = Array.from(
+    { length: triggerMatch.length - 1 },
+    (_, i) => triggerMatch[i + 1]
+  ).filter(group => group !== undefined);
+  
+  // Use the last non-empty capture group as the instruction
+  // For simple patterns with one capture, this will be that capture
+  // For patterns with multiple captures (like task types), this will be the actual instruction
+  let instruction = captureGroups.length > 0 
+    ? captureGroups[captureGroups.length - 1] 
+    : "fix or improve this code";
+  
   // Remove any comment prefixes that might have been captured
   instruction = instruction.replace(/^(?:\/\/|#|--|;|'|%|REM)\s*/, "");
 

codex-cli/tests/watch-mode-trigger-extraction.test.ts

@@ -5,6 +5,7 @@ import { describe, it, expect } from "vitest";
 import {
   findAllTriggers,
   extractContextAroundTrigger,
+  getTriggerPattern
 } from "../src/utils/watch-mode-utils";
 
 // For testing, we'll use a larger context size
@@ -127,6 +128,39 @@ describe("Watch mode trigger pattern matching", () => {
     expect(matches[0]![1]).toBe("Optimize this query");
   });
 
+  
+  it("should handle custom trigger patterns", () => {
+    // Create custom patterns for testing
+    const customPatternString = '/(?:\\/\\/|#)\\s*AI:(TODO|FIXME)\\s+(.*)/i';
+    const match = customPatternString.match(/^\/(.*)\/([gimuy]*)$/);
+    const [, pattern, flags] = match!;
+    const customPattern = new RegExp(pattern, flags + 'g');
+    
+    const content = `
+    function testFunction() {
+      // This is a normal comment
+      // AI:TODO Fix this bug
+      return 1 + 1;
+    }
+    
+    function anotherFunction() {
+      # AI:FIXME Handle null input
+      return x * 2;
+    }
+    `;
+
+    const matches: Array<RegExpMatchArray> = [];
+    let matchResult;
+    while ((matchResult = customPattern.exec(content)) != null) {
+      matches.push(matchResult);
+    }
+
+    expect(matches.length).toBe(2);
+    expect(matches[0]![0]).toContain("AI:TODO Fix this bug");
+    expect(matches[0]![2]).toBe("Fix this bug");
+    expect(matches[1]![0]).toContain("AI:FIXME Handle null input");
+    expect(matches[1]![2]).toBe("Handle null input");
+  });
 });
 
 describe("Context extraction around AI triggers", () => {