feat(github): add GitHub Context Agent

Implements GitHubAgent following coordinator pattern:

**Agent Implementation:**
- Follows Explorer/Planner agent patterns
- Implements Agent interface (initialize, handleMessage, healthCheck, shutdown)
- Handles 4 actions: index, search, context, related
- Integrates GitHubIndexer for document management
- Proper error handling and logging

**Message Handling:**
- Request/response pattern via coordinator
- Supports all GitHubContextRequest actions
- Returns GitHubContextResult or GitHubContextError
- Compatible with coordinator message routing

**Exports:**
- GitHubAgent class
- GitHubAgentConfig interface
- All utilities and types available

**Fixed:**
- Consistent TypeScript imports (no .js extensions)
- Proper Message interface compliance (priority field)
- Type-safe payload handling

Ready for coordinator integration ✅

Author: prosdev

packages/subagents/src/github/agent.ts

@@ -0,0 +1,161 @@
+/**
+ * GitHub Context Agent
+ * Provides rich context from GitHub issues, PRs, and discussions
+ */
+
+import type { RepositoryIndexer } from '@lytics/dev-agent-core';
+import type { Agent, AgentContext, Message } from '../types';
+import { GitHubIndexer } from './indexer';
+import type {
+  GitHubContextError,
+  GitHubContextRequest,
+  GitHubContextResult,
+  GitHubIndexOptions,
+} from './types';
+
+export interface GitHubAgentConfig {
+  repositoryPath: string;
+  codeIndexer: RepositoryIndexer;
+  storagePath?: string;
+}
+
+export class GitHubAgent implements Agent {
+  name = 'github';
+  capabilities = ['github-index', 'github-search', 'github-context', 'github-related'];
+
+  private context?: AgentContext;
+  private indexer?: GitHubIndexer;
+  private config: GitHubAgentConfig;
+
+  constructor(config: GitHubAgentConfig) {
+    this.config = config;
+  }
+
+  async initialize(context: AgentContext): Promise<void> {
+    this.context = context;
+    this.name = context.agentName;
+
+    this.indexer = new GitHubIndexer(this.config.codeIndexer);
+
+    context.logger.info('GitHub agent initialized', {
+      capabilities: this.capabilities,
+      repository: this.config.repositoryPath,
+    });
+  }
+
+  async handleMessage(message: Message): Promise<Message | null> {
+    if (!this.context || !this.indexer) {
+      throw new Error('GitHub agent not initialized');
+    }
+
+    const { logger } = this.context;
+
+    if (message.type !== 'request') {
+      logger.debug('Ignoring non-request message', { type: message.type });
+      return null;
+    }
+
+    try {
+      const request = message.payload as unknown as GitHubContextRequest;
+      logger.debug('Processing GitHub request', { action: request.action });
+
+      let result: GitHubContextResult | GitHubContextError;
+
+      switch (request.action) {
+        case 'index':
+          result = await this.handleIndex(request.indexOptions);
+          break;
+        case 'search':
+          result = await this.handleSearch(request.query || '', request.searchOptions);
+          break;
+        case 'context':
+          result = await this.handleGetContext(request.issueNumber!);
+          break;
+        case 'related':
+          result = await this.handleFindRelated(request.issueNumber!);
+          break;
+        default:
+          result = {
+            action: 'index',
+            error: `Unknown action: ${(request as GitHubContextRequest).action}`,
+          };
+      }
+
+      return {
+        id: `${message.id}-response`,
+        type: 'response',
+        sender: this.name,
+        recipient: message.sender,
+        correlationId: message.id,
+        payload: result as unknown as Record<string, unknown>,
+        priority: message.priority,
+        timestamp: Date.now(),
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(errorMsg);
+
+      const errorResult = {
+        action: 'index' as const,
+        error: errorMsg,
+      };
+
+      return {
+        id: `${message.id}-error`,
+        type: 'response',
+        sender: this.name,
+        recipient: message.sender,
+        correlationId: message.id,
+        payload: errorResult as Record<string, unknown>,
+        priority: message.priority,
+        timestamp: Date.now(),
+      };
+    }
+  }
+
+  private async handleIndex(options?: GitHubIndexOptions): Promise<GitHubContextResult> {
+    const stats = await this.indexer!.index(options);
+    return {
+      action: 'index',
+      stats,
+    };
+  }
+
+  private async handleSearch(
+    query: string,
+    options?: { limit?: number }
+  ): Promise<GitHubContextResult> {
+    const results = await this.indexer!.search(query, options);
+    return {
+      action: 'search',
+      results,
+    };
+  }
+
+  private async handleGetContext(issueNumber: number): Promise<GitHubContextResult> {
+    const context = await this.indexer!.getContext(issueNumber);
+    return {
+      action: 'context',
+      context: context || undefined,
+    };
+  }
+
+  private async handleFindRelated(issueNumber: number): Promise<GitHubContextResult> {
+    const related = await this.indexer!.findRelated(issueNumber);
+    return {
+      action: 'related',
+      related,
+    };
+  }
+
+  async healthCheck(): Promise<boolean> {
+    return this.indexer !== undefined;
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.context) {
+      this.context.logger.info('GitHub agent shutting down');
+    }
+    this.indexer = undefined;
+  }
+}

packages/subagents/src/github/index.ts

@@ -0,0 +1,10 @@
+/**
+ * GitHub Context Subagent
+ * Index and search GitHub issues, PRs, and discussions
+ */
+
+export type { GitHubAgentConfig } from './agent';
+export { GitHubAgent } from './agent';
+export { GitHubIndexer } from './indexer';
+export * from './types';
+export * from './utils';

packages/subagents/src/index.ts

@@ -31,10 +31,12 @@ export type {
   SimilarCodeRequest,
   SimilarCodeResult,
 } from './explorer/types';
-// GitHub Context
-export { GitHubIndexer } from './github/indexer.js';
+export type { GitHubAgentConfig } from './github/agent';
+// GitHub Context Agent
+export { GitHubAgent } from './github/agent';
+export { GitHubIndexer } from './github/indexer';
 export type * from './github/types';
-export * from './github/utils/index.js';
+export * from './github/utils';
 // Logger module
 export { CoordinatorLogger } from './logger';
 // Agent modules