fix: consolidate actionable review feedback from PRs #4, #6, #26

- Add console.log→stderr redirect with unknown[] type (PR #26)
- Use URLSearchParams for mentions URL + since_id pagination (PR #26)
- Add Array.isArray() guard in fetchThread() (PR #26)
- Add Set pruning with safe { value, done } iterator (PR #26)
- Process mentions oldest-first for chronological pruning (PR #26)
- Use [key: string]: unknown in parseThread, spread sort (PR #26)
- Add mentionPostId param for correct reply targeting (PR #6)
- Fix any type in Grok response parsing (PR #6)
- Fix README broken list numbering (PR #4)

Co-authored-by: groupthinking <154503486+groupthinking@users.noreply.github.com>

Author: Copilot

README.md

@@ -20,8 +20,8 @@ This repository hosts a lightweight, step-by-step guide for setting up an autono
 3. Note the bot user ID (you can fetch this via the API later).
 
 ### xAI / Grok API key
-. Visit <https://console.x.ai>, open the API keys section, and create a key that starts with `xai-`.
-. Store the key securely.
+1. Visit <https://console.x.ai>, open the API keys section, and create a key that starts with `xai-`.
+2. Store the key securely.
 
 ### Local tooling
 - Install Python 3.9+ (3.10–3.13 recommended).

src/examples.ts

@@ -33,7 +33,7 @@ async function example1_fetchAndAnalyzeMention() {
       console.log(`\nThread has ${thread.replies.length + 1} posts`);
 
       // Analyze with Grok
-      const analysis = await grok.analyzeAndDecide(mention.post.text, thread);
+      const analysis = await grok.analyzeAndDecide(mention.post.text, thread, mention.post.id);
 
       console.log(`\nGrok's Decision:`);
       console.log(`  Action: ${analysis.action.type}`);
@@ -139,7 +139,7 @@ async function example5_batchProcessMentions() {
     const thread = await xClient.fetchThread(conversationId);
 
     if (thread) {
-      const analysis = await grok.analyzeAndDecide(mention.post.text, thread);
+      const analysis = await grok.analyzeAndDecide(mention.post.text, thread, mention.post.id);
       console.log(`  → Action: ${analysis.action.type} (${(analysis.confidence * 100).toFixed(0)}% confidence)`);
 
       // In a real scenario, you might execute the action here

src/index.ts

@@ -8,6 +8,10 @@ import { AutonomousAgent } from './services/agent.js';
 import { XMCPServer } from './mcp/server.js';
 
 async function main() {
+  // Redirect console.log to stderr so it doesn't conflict with
+  // MCP StdioServerTransport which uses stdout for protocol messages
+  console.log = (...args: unknown[]) => console.error(...args);
+
   console.log('═══════════════════════════════════════════════════');
   console.log('  MyXstack - Autonomous AI Agent on X (Twitter)');
   console.log('═══════════════════════════════════════════════════\n');

src/services/agent.ts

@@ -11,6 +11,7 @@ export class AutonomousAgent {
   private grokService: GrokService;
   private config: AgentConfig;
   private processedMentions: Set<string> = new Set();
+  private static readonly MAX_PROCESSED_MENTIONS = 10000;
   private isRunning: boolean = false;
   private pollingIntervalId: NodeJS.Timeout | null = null;
   private isProcessing: boolean = false;
@@ -91,10 +92,24 @@ export class AutonomousAgent {
       console.log(`\n📬 [${new Date().toLocaleTimeString()}] Found ${newMentions.length} new mention(s)!\n`);
 
       // Process each mention
-      for (const mention of newMentions) {
+      // Process oldest first so chronological order is preserved in the Set
+      for (const mention of [...newMentions].reverse()) {
         await this.processMention(mention);
         this.processedMentions.add(mention.post.id);
       }
+
+      // Prune oldest entries to prevent unbounded memory growth
+      if (this.processedMentions.size > AutonomousAgent.MAX_PROCESSED_MENTIONS) {
+        const excess = this.processedMentions.size - AutonomousAgent.MAX_PROCESSED_MENTIONS;
+        const iter = this.processedMentions.values();
+        for (let i = 0; i < excess; i++) {
+          const { value, done } = iter.next();
+          if (done) {
+            break;
+          }
+          this.processedMentions.delete(value);
+        }
+      }
     } catch (error) {
       console.error('❌ Error in processing loop:', error);
     } finally {
@@ -129,7 +144,8 @@ export class AutonomousAgent {
       console.log('\n🤖 Analyzing with Grok AI...');
       const analysis = await this.grokService.analyzeAndDecide(
         mention.post.text,
-        thread
+        thread,
+        mention.post.id
       );
 
       console.log(`   Action: ${analysis.action.type.toUpperCase()}`);

src/services/grok.ts

@@ -21,11 +21,12 @@ export class GrokService {
    * Analyze a mention and thread context to determine appropriate action
    * @param mention - The text content of the mention to analyze
    * @param thread - The thread context including root post and replies
+   * @param mentionPostId - The ID of the post where the agent was mentioned
    * @returns Analysis with recommended action
    */
-  async analyzeAndDecide(mention: string, thread: XThread): Promise<GrokAnalysis> {
+  async analyzeAndDecide(mention: string, thread: XThread, mentionPostId: string): Promise<GrokAnalysis> {
     if (this.simulationMode) {
-      return this.simulateAnalysis(mention, thread);
+      return this.simulateAnalysis(mention, thread, mentionPostId);
     }
 
     try {
@@ -58,15 +59,15 @@ export class GrokService {
         throw new Error(`Grok API error: ${response.status}`);
       }
 
-      const data: any = await response.json();
+      const data = await response.json() as { choices: { message?: { content?: string } }[] };
       const analysisText = data.choices[0]?.message?.content || '';
 
-      // Use the root post ID from the thread, not the mention text
-      return this.parseGrokResponse(analysisText, thread.root_post.id);
+      // Use the mention post ID to reply to the specific post that mentioned the agent
+      return this.parseGrokResponse(analysisText, mentionPostId);
     } catch (error) {
       console.error('Error calling Grok API:', error);
       // Fallback to simulation
-      return this.simulateAnalysis(mention, thread);
+      return this.simulateAnalysis(mention, thread, mentionPostId);
     }
   }
 
@@ -145,7 +146,7 @@ export class GrokService {
   /**
    * Simulate Grok analysis for testing
    */
-  private simulateAnalysis(mention: string, thread: XThread): GrokAnalysis {
+  private simulateAnalysis(mention: string, thread: XThread, mentionPostId: string): GrokAnalysis {
     console.log('🤖 Simulated Grok Analysis:');
     console.log(`   Analyzing: "${mention}"`);
 
@@ -159,7 +160,7 @@ export class GrokService {
       const analysis: GrokAnalysis = {
         action: {
           type: 'reply',
-          target_post_id: thread.root_post.id,
+          target_post_id: mentionPostId,
           content: 'Thanks for reaching out! I\'ve analyzed your question and here\'s my insight: Based on the context, I\'d recommend exploring this topic further. Let me know if you need more specific information!',
           reasoning: 'Detected a question, providing helpful response',
         },
@@ -174,7 +175,7 @@ export class GrokService {
       const analysis: GrokAnalysis = {
         action: {
           type: 'analyze',
-          target_post_id: thread.root_post.id,
+          target_post_id: mentionPostId,
           reasoning: 'No clear action needed, just acknowledgment',
         },
         confidence: 0.7,

src/services/xapi.ts

@@ -44,17 +44,31 @@ export class XAPIClient {
         throw new Error('Failed to get user ID from response');
       }
 
-      const mentionsResponse = await this.makeXAPIRequest(
-        `https://api.twitter.com/2/users/${userId}/mentions?max_results=10&expansions=author_id&tweet.fields=created_at,conversation_id,in_reply_to_user_id,referenced_tweets`,
-        'GET'
-      );
+      const params = new URLSearchParams({
+        max_results: '10',
+        expansions: 'author_id',
+        'tweet.fields': 'created_at,conversation_id,in_reply_to_user_id,referenced_tweets',
+      });
+      if (this.lastMentionId) {
+        params.set('since_id', this.lastMentionId);
+      }
+      const mentionsUrl = `https://api.twitter.com/2/users/${userId}/mentions?${params.toString()}`;
+
+      const mentionsResponse = await this.makeXAPIRequest(mentionsUrl, 'GET');
 
       if (!mentionsResponse || !Array.isArray(mentionsResponse.data)) {
         console.warn('Invalid response from X API (mentions)');
         return [];
       }
 
-      return this.parseMentions(mentionsResponse.data);
+      const mentions = this.parseMentions(mentionsResponse.data);
+
+      // Track the newest mention ID for pagination on the next poll
+      if (mentionsResponse.data.length > 0) {
+        this.lastMentionId = mentionsResponse.data[0].id;
+      }
+
+      return mentions;
     } catch (error) {
       console.error('Error fetching mentions:', error);
       return [];
@@ -77,7 +91,17 @@ export class XAPIClient {
         'GET'
       );
 
-      return this.parseThread(response.data || []);
+      if (!response || !response.data) {
+        console.warn('Invalid response from X API (thread)');
+        return null;
+      }
+
+      if (!Array.isArray(response.data)) {
+        console.warn('Unexpected response shape from X API (thread): data is not an array');
+        return null;
+      }
+
+      return this.parseThread(response.data);
     } catch (error) {
       console.error('Error fetching thread:', error);
       return null;
@@ -181,10 +205,10 @@ export class XAPIClient {
     };
   }
 
-  private parseThread(tweets: any[]): XThread | null {
+  private parseThread(tweets: { created_at: string; [key: string]: unknown }[]): XThread | null {
     if (tweets.length === 0) return null;
 
-    const sorted = tweets.sort((a, b) => 
+    const sorted = [...tweets].sort((a, b) =>
       new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
     );