v1.2.0: Autonomous agent upgrade — browser skills, web search, routines, self-improvement

Enhanced browser with 7 new actions (scroll, wait, press_key, hover, find_by_text,
switch_tab, new_tab) and React-compatible typeText fix for X/Gmail. Added DuckDuckGo
web search tool (zero dependencies). Added routine scheduler for recurring tasks with
cron expressions. Expanded system prompt from coding assistant to fully autonomous agent
with memory-based self-improvement patterns.

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

Author: zanderone1980

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebot-ai",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Local-first AI coding assistant. Zero dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, and more.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/agent.ts

@@ -225,7 +225,7 @@ export class Agent {
       // memory unavailable
     }
 
-    let prompt = `You are CodeBot, an AI coding assistant. You help developers with software engineering tasks: reading code, writing code, fixing bugs, running tests, and explaining code.
+    let prompt = `You are CodeBot, a fully autonomous AI agent. You help with ANY task: coding, research, sending emails, posting on social media, web automation, and anything else that can be accomplished with a computer.
 
 CRITICAL IDENTITY — you MUST follow this:
 - Your name is CodeBot.
@@ -235,11 +235,19 @@ CRITICAL IDENTITY — you MUST follow this:
 - Never claim to be made by or affiliated with OpenAI, GPT, Claude, Gemini, or any LLM provider. You are CodeBot by Ascendral.
 
 Rules:
-- Always read files before editing them.
-- Prefer editing over rewriting entire files.
-- Be concise and direct.
-- Explain what you're doing and why.
+- When given a goal, break it into steps and execute them using your tools.
+- Always read files before editing them. Prefer editing over rewriting entire files.
+- Be concise and direct. Explain what you're doing and why.
 - Use the memory tool to save important context, user preferences, and patterns you learn. Memory persists across sessions.
+- After completing social media posts, emails, or research tasks, log the outcome to memory (file: "outcomes") for future learning.
+- Before doing social media or email tasks, read your memory files for any saved skills or style guides.
+
+Skills:
+- Web browsing: use the browser tool to navigate, click, type, find elements by text, scroll, press keys, hover, and manage tabs.
+- Research: use web_search for quick lookups, then browser for deep reading of specific pages.
+- Social media: navigate to the platform, find the compose area with find_by_text, type your content, and submit.
+- Email: navigate to Gmail/email, compose and send messages through the browser interface.
+- Routines: use the routine tool to schedule recurring tasks (daily posts, email checks, etc.).
 
 ${repoMap}${memoryBlock}`;
 

src/cli.ts

@@ -8,8 +8,9 @@ import { SessionManager } from './history';
 import { loadConfig, isFirstRun, runSetup } from './setup';
 import { banner, randomGreeting, compactBanner } from './banner';
 import { EditFileTool } from './tools';
+import { Scheduler } from './scheduler';
 
-const VERSION = '1.1.0';
+const VERSION = '1.2.0';
 
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
@@ -112,8 +113,15 @@ export async function main() {
     return;
   }
 
+  // Start the routine scheduler in the background
+  const scheduler = new Scheduler(agent, (text) => process.stdout.write(text));
+  scheduler.start();
+
   // Interactive REPL
   await repl(agent, config, session);
+
+  // Cleanup scheduler on exit
+  scheduler.stop();
 }
 
 function createProvider(config: Config): LLMProvider {
@@ -276,6 +284,7 @@ function handleSlashCommand(input: string, agent: Agent, config: Config) {
   /clear     Clear conversation history
   /compact   Force context compaction
   /auto      Toggle autonomous mode
+  /routines  List scheduled routines
   /undo      Undo last file edit (/undo [path])
   /usage     Show token usage for this session
   /config    Show current config
@@ -339,6 +348,12 @@ function handleSlashCommand(input: string, agent: Agent, config: Config) {
       console.log(`  Total:  ${(sessionTokens.input + sessionTokens.output).toLocaleString()} tokens`);
       break;
     }
+    case '/routines': {
+      const { RoutineTool } = require('./tools/routine');
+      const rt = new RoutineTool();
+      rt.execute({ action: 'list' }).then((out: string) => console.log('\n' + out));
+      break;
+    }
     case '/config':
       console.log(JSON.stringify({ ...config, apiKey: config.apiKey ? '***' : undefined }, null, 2));
       break;

src/scheduler.ts

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Routine, matchesCron } from './tools/routine';
+import { Agent } from './agent';
+import { AgentEvent } from './types';
+
+const ROUTINES_FILE = path.join(os.homedir(), '.codebot', 'routines.json');
+
+export class Scheduler {
+  private agent: Agent;
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private running = false;
+  private onOutput?: (text: string) => void;
+
+  constructor(agent: Agent, onOutput?: (text: string) => void) {
+    this.agent = agent;
+    this.onOutput = onOutput;
+  }
+
+  /** Start the scheduler — checks routines every 60 seconds */
+  start(): void {
+    if (this.interval) return;
+
+    // Check every 60 seconds
+    this.interval = setInterval(() => this.tick(), 60_000);
+
+    // Also do an immediate check
+    this.tick();
+  }
+
+  /** Stop the scheduler */
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+
+  /** Check if any routines need to run right now */
+  private tick(): void {
+    if (this.running) return; // Don't run if already executing a routine
+
+    const routines = this.loadRoutines();
+    const now = new Date();
+
+    for (const routine of routines) {
+      if (!routine.enabled) continue;
+
+      // Check if the cron schedule matches current time
+      if (!matchesCron(routine.schedule, now)) continue;
+
+      // Don't re-run if already ran this minute
+      if (routine.lastRun) {
+        const lastRun = new Date(routine.lastRun);
+        const diffMs = now.getTime() - lastRun.getTime();
+        if (diffMs < 60_000) continue; // Already ran this minute
+      }
+
+      // Run the routine
+      this.executeRoutine(routine, routines);
+      break; // Only run one routine per tick to avoid conflicts
+    }
+  }
+
+  private async executeRoutine(routine: Routine, allRoutines: Routine[]): Promise<void> {
+    this.running = true;
+
+    try {
+      this.onOutput?.(`\n⏰ Running routine: ${routine.name}\n   Task: ${routine.prompt}\n`);
+
+      // Run the agent with the routine's prompt
+      for await (const event of this.agent.run(routine.prompt) as AsyncGenerator<AgentEvent>) {
+        switch (event.type) {
+          case 'text':
+            this.onOutput?.(event.text || '');
+            break;
+          case 'tool_call':
+            this.onOutput?.(`\n⚡ ${event.toolCall?.name}(${Object.entries(event.toolCall?.args || {}).map(([k, v]) => `${k}: ${typeof v === 'string' ? v.substring(0, 40) : v}`).join(', ')})\n`);
+            break;
+          case 'tool_result':
+            this.onOutput?.(`  ✓ ${event.toolResult?.result?.substring(0, 100) || ''}\n`);
+            break;
+          case 'error':
+            this.onOutput?.(`  ✗ Error: ${event.error}\n`);
+            break;
+        }
+      }
+
+      // Update last run time
+      routine.lastRun = new Date().toISOString();
+      this.saveRoutines(allRoutines);
+
+      this.onOutput?.(`\n✓ Routine "${routine.name}" completed.\n`);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.onOutput?.(`\n✗ Routine "${routine.name}" failed: ${msg}\n`);
+    } finally {
+      this.running = false;
+    }
+  }
+
+  private loadRoutines(): Routine[] {
+    try {
+      if (fs.existsSync(ROUTINES_FILE)) {
+        return JSON.parse(fs.readFileSync(ROUTINES_FILE, 'utf-8'));
+      }
+    } catch { /* corrupt file */ }
+    return [];
+  }
+
+  private saveRoutines(routines: Routine[]): void {
+    const dir = path.dirname(ROUTINES_FILE);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(ROUTINES_FILE, JSON.stringify(routines, null, 2) + '\n');
+  }
+}