clarity-ai 2.0.0 → 3.0.1

package/AGENTS.md

@@ -0,0 +1,51 @@
+# CLARITY-AI — Agent Guide
+
+## Project
+Single-package Node.js CLI tool (`clarity-ai`) — ESM module (`"type": "module"`).  
+Entry: `bin/clarity.js` → imports `src/index.js`.  
+Install: `npm install -g clarity-ai` → command `clarity`.
+
+## Key Architecture
+- **`src/providers/index.js`**: `sendMessage()` MUST be a plain `function`, NOT `async function`. Wrapping an async generator in `async` returns a Promise instead of an async iterable → `for await...of` breaks ("stream is not async iterable"). Each provider exports `async function* sendMessage(...)`. Provider model lists updated as of June 2026 — see `capabilities` object.
+- **`src/commands/index.js`**: All 40+ slash commands in one file, routed by switch. Single-file design — do NOT split into separate command files without changing the dispatcher. `/model` uses interactive inquirer selector. `/provider` switches provider + auto-filters models.
+- **`src/config/keys.js`**: API keys stored via `conf` package, obfuscated with base64-reverse (not real encryption). Provider regex patterns are strict — Gemini keys must match `/^AIzaSy[A-Za-z0-9_-]{20,}$/`.
+- **`src/ui/chatbox.js`**: Prompt bar design — grey fill (`\x1b[48;5;236m`) + purple outline (`chalk.hex('#7b2ff7')`). `renderPromptBar()` draws the bar, `showPrompt()` writes ` ◆ `. Pressing `/` at the prompt shows all command suggestions via `suggestCommands()` with `rl._refreshLine()`.
+- **`src/ui/prompt.js`**: History management only. `showPrompt()` and `showSuggestions()` moved to `chatbox.js`. `createPrompt()` creates readline interface with `terminal: true` (enables keypress events).
+- **Default model**: `groq/llama-3.3-70b-versatile` (updated in `src/config/settings.js`).
+
+## Termux Quirks
+- No `node-gyp`, no native modules, no `fsevents`.
+- `npm install -g` symlinks don't work for execution on Termux (permission denied across mount points). Postinstall creates a shell wrapper at `$PREFIX/bin/clarity`.
+- `open` package replaced with `termux-open-url` via `exec`.
+- Console clear: `console.clear()` at startup.
+
+## Commands
+```bash
+# Dev workflow (no test/lint scripts configured)
+npm start                    # node bin/clarity.js
+node bin/clarity.js /status  # run individual command
+node bin/clarity.js          # interactive chat mode
+
+# Publishing
+npm version patch && npm publish  # bump + publish (needs npm token with write access)
+```
+
+## Provider Streaming Contract
+Each provider file exports `{ PROVIDER, sendMessage }` where `sendMessage` is:
+```js
+async function* sendMessage(apiKey, messages, model, stream) → AsyncGenerator<string>
+```
+SSE parsing pattern: read `data: ` lines, parse JSON, yield `choices[0].delta.content`.
+
+## Known Gotchas
+- **Provider router must NOT be async**: `src/providers/index.js` `sendMessage` is a regular function returning the async generator directly.
+- **Model name format**: config stores `"provider/modelname"` (e.g. `groq/llama-3.3-70b-versatile`). Router strips prefix before passing to provider.
+- **No boxen/ora deps**: v1.2.0 removed them. Custom ANSI escape shaded boxes in `src/ui/blocks.js`. Custom spinner in `src/ui/spinner.js`.
+- **Config paths**: XDG-compliant (`~/.config/clarity/`, `~/.local/share/clarity/`, `~/.cache/clarity/`).
+- **No test framework**: none configured. No lint/typecheck scripts.
+- **Keypress events**: `process.stdin.on('keypress', ...)` works because `readline.createInterface({ terminal: true })` internally calls `emitKeypressEvents`. Set raw mode BEFORE creating readline if needed.
+- **Prompt bar**: `renderPromptBar()` draws grey-filled purple box. Call after every output cycle so the bar stays at bottom. `showPrompt()` writes ` ◆ `. Always pair: render bar, then show prompt.
+- **No build step (v3)**: All Ink+React components use `React.createElement()` directly — NO JSX. Node.js cannot parse JSX without a transpiler.
+- **TTY check**: `src/index.js` checks `process.stdin.isTTY` before rendering Ink — prevents `Raw mode not supported` error in non-TTY environments.
+- **Global state**: `src/store.js` uses `useReducer` with a reducer function — dispatches `THOUGHT_START`, `TOOL_CALL`, `ADD_MESSAGE`, `SET_TODOS`, etc.
+- **Parallel subagents**: `src/agent/subagent.js` — `shouldParallelize()` detects multi-step tasks, `planSubagents()` calls model for JSON array, `runSubagents()` runs `Promise.all` with AGENT_REGISTER/TOOLCALL dispatches.

package/bin/clarity.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../src/main.js';
+import '../src/index.js';

package/package.json

@@ -1,39 +1,25 @@
 {
   "name": "clarity-ai",
-  "version": "2.0.0",
-  "description": "Autonomous AI Agent CLI for Termux",
+  "version": "3.0.1",
+  "description": "Autonomous AI Agent Terminal — OpenCode-style TUI for Termux",
   "type": "module",
-  "bin": {
-    "clarity": "bin/clarity.js"
-  },
+  "bin": { "clarity": "./bin/clarity.js" },
   "scripts": {
     "start": "node bin/clarity.js",
     "dev": "node --watch bin/clarity.js"
   },
-  "engines": {
-    "node": ">=18.0.0"
-  },
   "dependencies": {
+    "ink": "^4.4.1",
+    "react": "^18.2.0",
     "chalk": "^5.3.0",
-    "figlet": "^1.7.0",
-    "gradient-string": "^2.0.2",
-    "ora": "^8.1.0",
-    "inquirer": "^9.2.12",
-    "conf": "^12.0.0",
-    "marked": "^12.0.0",
-    "marked-terminal": "^7.1.0",
-    "cli-table3": "^0.6.5",
-    "wrap-ansi": "^9.0.1",
-    "semver": "^7.6.0",
-    "glob": "^10.3.12"
+    "figures": "^6.1.0",
+    "ora": "^8.0.1",
+    "dotenv": "^16.4.5",
+    "node-fetch": "^3.3.2",
+    "strip-ansi": "^7.1.0",
+    "wrap-ansi": "^9.0.0",
+    "cli-truncate": "^4.0.0",
+    "ink-text-input": "^5.0.1"
   },
-  "keywords": [
-    "ai",
-    "cli",
-    "termux",
-    "agent",
-    "autonomous",
-    "clarity"
-  ],
-  "license": "MIT"
+  "engines": { "node": ">=18.0.0" }
 }

package/src/agent/intent.js

@@ -0,0 +1,9 @@
+export function detectIntent(message) {
+  const msg = message.toLowerCase();
+  const HIGH = ['create','build','write','make','generate','fix','debug','patch','run','execute','install','setup','search and','find and','look up and'];
+  const LOW = ['can you','please','help me'];
+  let score = 0;
+  for (const w of HIGH) { if (msg.includes(w)) { score += 2; break; } }
+  for (const w of LOW) { if (msg.includes(w)) score += 1; }
+  return score >= 2 ? 'agent' : 'chat';
+}

package/src/agent/loop.js

@@ -0,0 +1,105 @@
+import { toolBox, success, errorBox } from '../blocks.js';
+import { sendMessage } from '../providers/index.js';
+import { executeTool } from './tools.js';
+
+const AGENT_PROMPT = `You are CLARITY, an autonomous AI agent. You have tools available. Respond in JSON:
+{
+  "thought": "your reasoning",
+  "tool": "tool_name",
+  "args": { "key": "value" },
+  "done": false
+}
+When task is complete, set done: true and provide a summary.`;
+
+function extractJSON(text) {
+  const match = text.match(/\{[\s\S]*\}/);
+  if (!match) return null;
+  try {
+    return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+}
+
+export async function agentLoop(conversation, model, apiKey) {
+  const messages = [
+    { role: 'system', content: AGENT_PROMPT },
+    ...conversation
+  ];
+
+  let step = 0;
+
+  while (true) {
+    step++;
+
+    const gen = sendMessage(apiKey, messages, model, false);
+    let raw = '';
+    for await (const chunk of gen) {
+      raw += chunk;
+    }
+
+    let parsed = null;
+    let attempts = 0;
+    while (!parsed && attempts < 3) {
+      parsed = extractJSON(raw);
+      if (!parsed) {
+        attempts++;
+        if (attempts < 3) {
+          const retryGen = sendMessage(apiKey, [
+            { role: 'system', content: AGENT_PROMPT },
+            ...messages,
+            { role: 'user', content: `Your previous response was not valid JSON. Please respond with valid JSON only:\n${raw}\n\nRespond ONLY with valid JSON.` }
+          ], model, false);
+          raw = '';
+          for await (const chunk of retryGen) {
+            raw += chunk;
+          }
+        }
+      }
+    }
+
+    if (!parsed) {
+      errorBox('Agent Error', 'Failed to parse JSON response after 3 attempts');
+      break;
+    }
+
+    const { thought, tool, args, done, summary } = parsed;
+
+    if (done) {
+      success('Task Complete', summary || 'Done');
+      return summary || 'Done';
+    }
+
+    if (!tool) {
+      errorBox('Agent Error', 'No tool specified in response');
+      break;
+    }
+
+    const start = Date.now();
+    let result;
+    let status;
+
+    try {
+      result = await executeTool(tool, args || {});
+      status = 'success';
+    } catch (err) {
+      result = err.message;
+      status = 'error';
+    }
+
+    const elapsed = Date.now() - start;
+
+    toolBox(tool, {
+      args: args || {},
+      status,
+      duration: elapsed + 'ms',
+      result: typeof result === 'string' ? result.slice(0, 500) : JSON.stringify(result).slice(0, 500)
+    });
+
+    messages.push({ role: 'assistant', content: JSON.stringify(parsed) });
+    messages.push({
+      role: 'user',
+      content: `Tool "${tool}" returned: ${typeof result === 'string' ? result.slice(0, 2000) : JSON.stringify(result).slice(0, 2000)}`
+    });
+  }
+}

package/src/agent/planner.js

@@ -0,0 +1,37 @@
+import { sendMessage } from '../providers/index.js';
+
+const PLAN_PROMPT = `You are CLARITY's planning system. Given a user task, create a step-by-step plan using available tools.
+
+Available tools: file_read, file_write, file_append, file_delete, file_list, file_exists, shell_run, shell_run_silent, npm_install, pkg_install, web_search, web_fetch, code_run, git_status, git_commit, sys_info, env_get, env_set, ai_ask, summarize
+
+Respond in JSON:
+{
+  "steps": [
+    { "step": "description of what to do", "tool": "tool_name", "args": { "key": "value" } }
+  ]
+}
+
+Provide only the JSON, no other text.`;
+
+export async function createPlan(task, model, apiKey) {
+  const messages = [
+    { role: 'system', content: PLAN_PROMPT },
+    { role: 'user', content: task }
+  ];
+
+  const gen = sendMessage(apiKey, messages, model, false);
+  let raw = '';
+  for await (const chunk of gen) {
+    raw += chunk;
+  }
+
+  const match = raw.match(/\{[\s\S]*\}/);
+  if (!match) return [{ step: 'Failed to parse plan', tool: null, args: null }];
+
+  try {
+    const parsed = JSON.parse(match[0]);
+    return parsed.steps || [];
+  } catch {
+    return [{ step: 'Failed to parse plan', tool: null, args: null }];
+  }
+}

package/src/agent/runner.js

@@ -0,0 +1,143 @@
+export async function callProvider({ provider, model, apiKey, system, messages, temperature }) {
+  const urls = {
+    groq: 'https://api.groq.com/openai/v1/chat/completions',
+    openrouter: 'https://openrouter.ai/api/v1/chat/completions',
+    openai: 'https://api.openai.com/v1/chat/completions',
+  };
+  const url = urls[provider];
+  if (!url) throw new Error(`Unknown provider: ${provider}`);
+
+  const body = { model, messages: [{ role: 'system', content: system }, ...messages], temperature: temperature || 0.3, stream: false };
+  const headers = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` };
+
+  const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body) });
+  if (!res.ok) throw new Error(`API ${res.status}: ${await res.text()}`);
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content || '';
+}
+
+import { TOOLS, executeTool } from './tools.js';
+
+const AGENT_SYSTEM = `You are CLARITY, an autonomous terminal AI agent.
+Respond ONLY with JSON. Never plain text. Never markdown.
+
+For each step:
+{
+  "thought": "what I'm doing and why (1-2 sentences)",
+  "todos": ["task 1", "task 2", ...],  // only on first step
+  "tool": "tool_name",
+  "args": {},
+  "done": false
+}
+
+When complete:
+{ "thought": "...", "tool": null, "args": {}, "done": true, "summary": "..." }
+
+Tools: file_read, file_write, file_append, file_delete, file_list, file_exists,
+       shell_run, code_run, npm_install, pkg_install,
+       web_search, web_fetch, sys_info, git_status, git_commit
+
+Rules:
+- Write files with file_write, not shell echo
+- Run code with code_run, not shell_run  
+- If a tool errors, try a different approach
+- Max 30 steps
+- Stay focused on the original task`;
+
+export async function runAgent(userMessage, config, dispatch) {
+  const history = [];
+  let step = 0;
+  const MAX = 30;
+
+  // Show thought starting
+  dispatch({ type: 'THOUGHT_START' });
+
+  while (step < MAX) {
+    step++;
+    const thinkStart = Date.now();
+
+    // Call model
+    const raw = await callProvider({
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      system: AGENT_SYSTEM,
+      messages: [
+        ...history,
+        { role: 'user', content: step === 1 ? userMessage : 'Next step.' }
+      ],
+      temperature: 0.3,
+    });
+
+    const elapsed = ((Date.now() - thinkStart) / 1000).toFixed(1);
+
+    // Parse JSON
+    let action;
+    try {
+      const cleaned = raw.replace(/```json|```/g, '').trim();
+      action = JSON.parse(cleaned);
+    } catch {
+      // Retry with explicit reminder
+      history.push({ role: 'assistant', content: raw });
+      history.push({ role: 'user', content: 'ERROR: respond only with valid JSON, no other text.' });
+      continue;
+    }
+
+    // Emit thought
+    dispatch({ type: 'THOUGHT_DONE', payload: { text: action.thought, elapsed } });
+
+    // Emit todos on first step
+    if (action.todos?.length) {
+      dispatch({ type: 'SET_TODOS', payload: action.todos.map((t, i) => ({
+        id: i, text: t, status: 'pending'
+      }))});
+    }
+
+    // Done?
+    if (action.done) {
+      dispatch({ type: 'AGENT_DONE', payload: action.summary });
+      return;
+    }
+
+    // Execute tool
+    if (action.tool) {
+      dispatch({ type: 'TOOL_START', payload: { name: action.tool, args: action.args } });
+      dispatch({ type: 'TODO_SET_RUNNING', payload: step - 1 });
+      
+      const toolStart = Date.now();
+      let result, status;
+      
+      try {
+        result = await executeTool(action.tool, action.args);
+        status = 'done';
+        dispatch({ type: 'TODO_SET_DONE', payload: step - 1 });
+      } catch (err) {
+        result = err.message;
+        status = 'error';
+        dispatch({ type: 'TODO_SET_FAIL', payload: step - 1 });
+      }
+
+      const toolMs = Date.now() - toolStart;
+      dispatch({ type: 'TOOL_DONE', payload: { result, status, elapsed: toolMs } });
+
+      // Feed back to model
+      history.push({ role: 'assistant', content: JSON.stringify(action) });
+      history.push({ role: 'user', content: `Tool ${action.tool} result (${toolMs}ms):\n${String(result).slice(0, 3000)}` });
+
+      // Emit agent step message
+      dispatch({ type: 'ADD_MESSAGE', payload: {
+        type: 'tool',
+        tool: action.tool,
+        args: action.args,
+        result,
+        status,
+        elapsed: toolMs,
+      }});
+
+      // Think again
+      dispatch({ type: 'THOUGHT_START' });
+    }
+  }
+
+  dispatch({ type: 'AGENT_DONE', payload: `Completed ${step} steps.` });
+}

package/src/agent/subagent.js

@@ -0,0 +1,55 @@
+import { runAgent } from './runner.js';
+
+// Detect if task warrants parallel agents
+export function shouldParallelize(task) {
+  const BIG_TASK = [
+    /rewrite (the )?(whole|entire|all|full)/i,
+    /create (a )?full/i,
+    /build (a )?(complete|entire)/i,
+    /rebuild/i,
+  ];
+  return BIG_TASK.some(p => p.test(task));
+}
+
+// Split a large task into parallel sub-tasks
+export async function planSubagents(task, callModel) {
+  const plan = await callModel({
+    system: `Split this task into 3-5 parallel independent subtasks.
+Respond ONLY with JSON array: [{"name": "short name", "task": "full task description"}, ...]
+Each subtask must be fully independent — no subtask depends on another's output.`,
+    messages: [{ role: 'user', content: task }]
+  });
+  
+  try {
+    return JSON.parse(plan.replace(/```json|```/g, '').trim());
+  } catch {
+    return null; // fall back to single agent
+  }
+}
+
+// Run multiple agents in parallel
+export async function runSubagents(subtasks, config, dispatch) {
+  // Register all agents
+  const agentIds = subtasks.map((t, i) => {
+    const id = `agent_${i}`;
+    dispatch({ type: 'AGENT_REGISTER', payload: {
+      id, name: `General Task — ${t.name}`,
+      status: 'running', toolcalls: 0, startTime: Date.now()
+    }});
+    return id;
+  });
+
+  // Run all in parallel via Promise.all
+  await Promise.all(subtasks.map((subtask, i) => 
+    runAgent(subtask.task, config, (action) => {
+      // Intercept tool dispatches to update agent's toolcall count
+      if (action.type === 'TOOL_START') {
+        dispatch({ type: 'AGENT_TOOLCALL', payload: { id: agentIds[i] } });
+        dispatch({ type: 'AGENT_SET_TASK', payload: { id: agentIds[i], task: action.payload.name } });
+      }
+      dispatch(action);
+    })
+    .then(() => dispatch({ type: 'AGENT_DONE_ID', payload: agentIds[i] }))
+    .catch(e => dispatch({ type: 'AGENT_FAIL_ID', payload: { id: agentIds[i], error: e.message } }))
+  ));
+}

package/src/agent/tools.js

@@ -0,0 +1,132 @@
+import fs from 'fs/promises';
+import { execSync } from 'child_process';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const run = promisify(exec);
+
+// ── File Tools ─────────────────────────────────────────────────
+export async function file_read({ path }) {
+  return (await fs.readFile(path, 'utf8')).slice(0, 8000);
+}
+
+export async function file_write({ path, content }) {
+  const dir = path.includes('/') ? path.split('/').slice(0,-1).join('/') : null;
+  if (dir) await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(path, content, 'utf8');
+  return `Written ${path} (${content.length} bytes)`;
+}
+
+export async function file_append({ path, content }) {
+  await fs.appendFile(path, content, 'utf8');
+  return `Appended to ${path}`;
+}
+
+export async function file_delete({ path }) {
+  await fs.unlink(path);
+  return `Deleted ${path}`;
+}
+
+export async function file_list({ dir = '.' }) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  return entries.map(e => `${e.isDirectory() ? '📁' : '📄'} ${e.name}`).join('\n');
+}
+
+export async function file_exists({ path }) {
+  try { await fs.access(path); return 'exists'; } 
+  catch { return 'not found'; }
+}
+
+// ── Shell Tools ─────────────────────────────────────────────────
+export async function shell_run({ command, cwd, timeout = 30000 }) {
+  try {
+    const { stdout, stderr } = await run(command, { 
+      cwd: cwd || process.cwd(), 
+      timeout,
+      maxBuffer: 2 * 1024 * 1024
+    });
+    return ((stdout || '') + (stderr || '')).trim().slice(0, 5000);
+  } catch (e) {
+    return `EXIT ${e.code || 1}: ${e.message}`.slice(0, 2000);
+  }
+}
+
+export async function code_run({ language, code }) {
+  const exts = { python: 'py', javascript: 'js', node: 'js', bash: 'sh', python3: 'py' };
+  const cmds = { python: 'python3', javascript: 'node', node: 'node', bash: 'bash', python3: 'python3' };
+  const ext = exts[language] || 'sh';
+  const cmd = cmds[language] || 'bash';
+  const tmp = `/tmp/clarity_${Date.now()}.${ext}`;
+  await fs.writeFile(tmp, code);
+  const result = await shell_run({ command: `${cmd} ${tmp}`, timeout: 15000 });
+  try { await fs.unlink(tmp); } catch {}
+  return result;
+}
+
+export async function npm_install({ packages, cwd, flags = '' }) {
+  const pkgStr = Array.isArray(packages) ? packages.join(' ') : packages;
+  // Termux-safe: always use --no-bin-links
+  return await shell_run({ 
+    command: `npm install --no-bin-links ${flags} ${pkgStr}`,
+    cwd: cwd || process.cwd()
+  });
+}
+
+export async function pkg_install({ packages }) {
+  const pkgStr = Array.isArray(packages) ? packages.join(' ') : packages;
+  return await shell_run({ command: `pkg install -y ${pkgStr}` });
+}
+
+// ── Web Tools ─────────────────────────────────────────────────
+export async function web_search({ query }) {
+  const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`;
+  const r = await fetch(url, { headers: { 'User-Agent': 'clarity-ai/3.0' } });
+  const d = await r.json();
+  const results = [
+    d.AbstractText && `Summary: ${d.AbstractText}`,
+    ...(d.RelatedTopics||[]).slice(0,6).map(t => t.Text).filter(Boolean),
+  ].filter(Boolean).join('\n\n');
+  return results || `No results for: ${query}`;
+}
+
+export async function web_fetch({ url, selector }) {
+  const r = await fetch(url, { headers: { 'User-Agent': 'clarity-ai/3.0' } });
+  const html = await r.text();
+  // Strip tags + collapse whitespace
+  const text = html
+    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 6000);
+  return text;
+}
+
+// ── System Tools ─────────────────────────────────────────────
+export async function sys_info() {
+  return await shell_run({ command: 'uname -a && node -v && free -h 2>/dev/null | head -3 || true' });
+}
+
+export async function git_status() {
+  return await shell_run({ command: 'git status --short && git log --oneline -5' });
+}
+
+export async function git_commit({ message, add = '.' }) {
+  const r1 = await shell_run({ command: `git add ${add}` });
+  const r2 = await shell_run({ command: `git commit -m "${message.replace(/"/g, '\\"')}"` });
+  return r1 + '\n' + r2;
+}
+
+// ── Registry ─────────────────────────────────────────────────
+export const TOOLS = {
+  file_read, file_write, file_append, file_delete, file_list, file_exists,
+  shell_run, code_run, npm_install, pkg_install,
+  web_search, web_fetch,
+  sys_info, git_status, git_commit,
+};
+
+export async function executeTool(name, args) {
+  if (!TOOLS[name]) throw new Error(`Unknown tool: ${name}. Available: ${Object.keys(TOOLS).join(', ')}`);
+  return await TOOLS[name](args);
+}

package/src/agents/BaseAgent.js

@@ -0,0 +1,54 @@
+import logger from '../utils/logger.js';
+
+class BaseAgent {
+  constructor(config = {}) {
+    this.id = config.id || `agent_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    this.name = config.name || 'Agent';
+    this.type = config.type || 'base';
+    this.status = 'stopped';
+    this.logs = [];
+    this.config = config;
+    this._interval = null;
+  }
+
+  async start() {
+    this.status = 'running';
+    this.log('info', 'Agent started');
+  }
+
+  async stop() {
+    this.status = 'stopped';
+    if (this._interval) {
+      clearInterval(this._interval);
+      this._interval = null;
+    }
+    this.log('info', 'Agent stopped');
+  }
+
+  async pause() {
+    this.status = 'paused';
+    this.log('info', 'Agent paused');
+  }
+
+  async resume() {
+    this.status = 'running';
+    this.log('info', 'Agent resumed');
+  }
+
+  log(level, msg) {
+    const entry = { level, msg, time: new Date().toISOString() };
+    this.logs.push(entry);
+    if (this.logs.length > 1000) this.logs.shift();
+    logger[level](`[${this.id}] ${msg}`);
+  }
+
+  emit(event, data) {
+    this.log('info', `Event: ${event} ${data ? JSON.stringify(data) : ''}`);
+  }
+
+  getStatus() {
+    return { id: this.id, name: this.name, type: this.type, status: this.status, logCount: this.logs.length };
+  }
+}
+
+export default BaseAgent;