add schedule & workflow dispatch paths. Also make prepare logic conditional (#353)

* feat: add agent mode for automation scenarios

- Add agent mode that always triggers without checking for mentions
- Implement Mode interface with support for mode-specific tool configuration
- Add getAllowedTools() and getDisallowedTools() methods to Mode interface
- Simplify tests by combining related test cases
- Update documentation and examples to include agent mode
- Fix TypeScript imports to prevent circular dependencies

Agent mode is designed for automation and workflow_dispatch scenarios
where Claude should always run without requiring trigger phrases.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Minor update to readme (from @main to @beta)

* Since workflow_dispatch isn't in the base action, update the examples accordingly

* minor formatting issue

* Update to say beta instead of main

* Fix missed tracking comment to be false

* add schedule & workflow dispatch paths. Also make prepare logic conditional

* tests

* Add test workflow for workflow_dispatch functionality

* Update workflow to use correct branch reference

* remove test workflow dispatch file

* minor lint update

* update workflow dispatch agent example

* minor lint update

* refactor: simplify prepare logic with mode-specific implementations

* ensure tag mode can't work with workflow dispatch and schedule tasks

* simplify: remove workflow_dispatch/schedule from create-prompt

- Remove workflow_dispatch and schedule event handling from create-prompt
  since agent mode doesn't use the standard prompt generation flow
- Enforce mode compatibility at selection time in the registry instead
  of runtime validation in tag mode
- Add explanatory comment in agent mode about why prompt file is needed
- Update tests to reflect simplified event handling

This reduces code duplication and makes the separation between tag mode
(entity-based events) and agent mode (automation events) clearer.

* simplify PR by making agent mode only work with workflow dispatch and schedule events

* remove unnecessary changes

* remove unnecessary changes from PR

- Revert update-comment-link.ts changes (agent mode doesn't use this)
- Revert create-initial.ts changes (agent mode doesn't create comments)
- Remove unused default-branch.ts file
- Revert install-mcp-server.ts changes (agent mode uses minimal MCP)

These files are only used by tag mode for entity-based events, not needed
for workflow_dispatch/schedule support via agent mode.

* fix: handle optional entityNumber for TypeScript

- Add runtime checks in files that require entityNumber
- These files are only used by tag mode which always has entityNumber
- Agent mode (workflow_dispatch/schedule) doesn't use these files

* linting update

---------

Co-authored-by: km-anthropic <km-anthropic@users.noreply.github.com>
Co-authored-by: Claude <noreply@anthropic.com>

test/modes/agent.test.ts

@@ -13,70 +13,52 @@ describe("Agent Mode", () => {
     });
   });
 
-  test("agent mode has correct properties and behavior", () => {
-    // Basic properties
+  test("agent mode has correct properties", () => {
     expect(agentMode.name).toBe("agent");
     expect(agentMode.description).toBe(
-      "Automation mode that always runs without trigger checking",
+      "Automation mode for workflow_dispatch and schedule events",
     );
     expect(agentMode.shouldCreateTrackingComment()).toBe(false);
-
-    // Tool methods return empty arrays
     expect(agentMode.getAllowedTools()).toEqual([]);
     expect(agentMode.getDisallowedTools()).toEqual([]);
-
-    // Always triggers regardless of context
-    const contextWithoutTrigger = createMockContext({
-      eventName: "workflow_dispatch",
-      isPR: false,
-      inputs: {
-        ...createMockContext().inputs,
-        triggerPhrase: "@claude",
-      },
-      payload: {} as any,
-    });
-    expect(agentMode.shouldTrigger(contextWithoutTrigger)).toBe(true);
   });
 
-  test("prepareContext includes all required data", () => {
-    const data = {
-      commentId: 789,
-      baseBranch: "develop",
-      claudeBranch: "claude/automated-task",
-    };
-
-    const context = agentMode.prepareContext(mockContext, data);
-
-    expect(context.mode).toBe("agent");
-    expect(context.githubContext).toBe(mockContext);
-    expect(context.commentId).toBe(789);
-    expect(context.baseBranch).toBe("develop");
-    expect(context.claudeBranch).toBe("claude/automated-task");
-  });
-
-  test("prepareContext works without data", () => {
+  test("prepareContext returns minimal data", () => {
     const context = agentMode.prepareContext(mockContext);
 
     expect(context.mode).toBe("agent");
     expect(context.githubContext).toBe(mockContext);
-    expect(context.commentId).toBeUndefined();
-    expect(context.baseBranch).toBeUndefined();
-    expect(context.claudeBranch).toBeUndefined();
+    // Agent mode doesn't use comment tracking or branch management
+    expect(Object.keys(context)).toEqual(["mode", "githubContext"]);
   });
 
-  test("agent mode triggers for all event types", () => {
-    const events = [
+  test("agent mode only triggers for workflow_dispatch and schedule events", () => {
+    // Should trigger for automation events
+    const workflowDispatchContext = createMockContext({
+      eventName: "workflow_dispatch",
+      isPR: false,
+    });
+    expect(agentMode.shouldTrigger(workflowDispatchContext)).toBe(true);
+
+    const scheduleContext = createMockContext({
+      eventName: "schedule",
+      isPR: false,
+    });
+    expect(agentMode.shouldTrigger(scheduleContext)).toBe(true);
+
+    // Should NOT trigger for other events
+    const otherEvents = [
       "push",
-      "schedule",
-      "workflow_dispatch",
       "repository_dispatch",
       "issue_comment",
       "pull_request",
+      "pull_request_review",
+      "issues",
     ];
 
-    events.forEach((eventName) => {
+    otherEvents.forEach((eventName) => {
       const context = createMockContext({ eventName, isPR: false });
-      expect(agentMode.shouldTrigger(context)).toBe(true);
+      expect(agentMode.shouldTrigger(context)).toBe(false);
     });
   });
 });

test/modes/registry.test.ts

@@ -3,23 +3,60 @@ import { getMode, isValidMode } from "../../src/modes/registry";
 import type { ModeName } from "../../src/modes/types";
 import { tagMode } from "../../src/modes/tag";
 import { agentMode } from "../../src/modes/agent";
+import { createMockContext } from "../mockContext";
 
 describe("Mode Registry", () => {
-  test("getMode returns tag mode by default", () => {
-    const mode = getMode("tag");
+  const mockContext = createMockContext({
+    eventName: "issue_comment",
+  });
+
+  const mockWorkflowDispatchContext = createMockContext({
+    eventName: "workflow_dispatch",
+  });
+
+  const mockScheduleContext = createMockContext({
+    eventName: "schedule",
+  });
+
+  test("getMode returns tag mode for standard events", () => {
+    const mode = getMode("tag", mockContext);
     expect(mode).toBe(tagMode);
     expect(mode.name).toBe("tag");
   });
 
   test("getMode returns agent mode", () => {
-    const mode = getMode("agent");
+    const mode = getMode("agent", mockContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode throws error for tag mode with workflow_dispatch event", () => {
+    expect(() => getMode("tag", mockWorkflowDispatchContext)).toThrow(
+      "Tag mode cannot handle workflow_dispatch events. Use 'agent' mode for automation events.",
+    );
+  });
+
+  test("getMode throws error for tag mode with schedule event", () => {
+    expect(() => getMode("tag", mockScheduleContext)).toThrow(
+      "Tag mode cannot handle schedule events. Use 'agent' mode for automation events.",
+    );
+  });
+
+  test("getMode allows agent mode for workflow_dispatch event", () => {
+    const mode = getMode("agent", mockWorkflowDispatchContext);
+    expect(mode).toBe(agentMode);
+    expect(mode.name).toBe("agent");
+  });
+
+  test("getMode allows agent mode for schedule event", () => {
+    const mode = getMode("agent", mockScheduleContext);
     expect(mode).toBe(agentMode);
     expect(mode.name).toBe("agent");
   });
 
   test("getMode throws error for invalid mode", () => {
     const invalidMode = "invalid" as unknown as ModeName;
-    expect(() => getMode(invalidMode)).toThrow(
+    expect(() => getMode(invalidMode, mockContext)).toThrow(
       "Invalid mode 'invalid'. Valid modes are: 'tag', 'agent'. Please check your workflow configuration.",
     );
   });