bare-agent 0.1.0 → 0.1.1

package/src/planner.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const PLAN_PROMPT = `You are a planning agent. Break the user's goal into concrete steps.
+
+Rules:
+- Each step must be a single, actionable task an agent can execute with tools.
+- Use dependsOn to express ordering. Steps with no dependencies can run in parallel.
+- Keep it minimal: 2-7 steps. Don't over-decompose simple goals.
+- Output ONLY a JSON array, no markdown, no explanation.
+
+Output format:
+[
+  { "id": "s1", "action": "description of step", "dependsOn": [] },
+  { "id": "s2", "action": "description of step", "dependsOn": ["s1"] }
+]`;
+
+class Planner {
+  /**
+   * @param {object} options
+   * @param {object} options.provider - LLM provider (must implement generate()).
+   * @param {string} [options.prompt] - Custom planning prompt override.
+   * @throws {Error} `[Planner] requires a provider` — when options.provider is missing.
+   */
+  constructor(options = {}) {
+    if (!options.provider) throw new Error('[Planner] requires a provider');
+    this.provider = options.provider;
+    this.prompt = options.prompt || PLAN_PROMPT;
+  }
+
+  /**
+   * Generate a step DAG from a goal.
+   * @param {string} goal - The user's goal to decompose.
+   * @param {object} [context={}] - Optional context with info field.
+   * @returns {Promise<Array<{id: string, action: string, dependsOn: string[], status: string}>>}
+   * @throws {Error} `[Planner] could not parse plan` — when LLM output is not parseable JSON.
+   * @throws {Error} `[Planner] expected JSON array` — when parsed result is not an array.
+   * @throws {Error} `[Planner] step missing id or action` — when a step lacks required fields.
+   */
+  async plan(goal, context = {}) {
+    const messages = [
+      { role: 'system', content: this.prompt },
+    ];
+    if (context.info) {
+      messages.push({ role: 'user', content: `Context: ${context.info}` });
+      messages.push({ role: 'assistant', content: 'Understood. I will factor this context into the plan.' });
+    }
+    messages.push({ role: 'user', content: goal });
+
+    const result = await this.provider.generate(messages, [], {
+      temperature: 0,
+    });
+
+    return this._parse(result.text);
+  }
+
+  _parse(text) {
+    // Extract JSON array from response (handle markdown code blocks)
+    const cleaned = text.replace(/^```(?:json)?\s*\n?/m, '').replace(/\n?```\s*$/m, '').trim();
+    let steps;
+    try {
+      steps = JSON.parse(cleaned);
+    } catch (e) {
+      // Try to find array in the text
+      const match = cleaned.match(/\[[\s\S]*\]/);
+      if (!match) throw new Error(`[Planner] could not parse plan from LLM output: ${text.slice(0, 200)}`);
+      steps = JSON.parse(match[0]);
+    }
+
+    if (!Array.isArray(steps)) throw new Error('[Planner] expected JSON array');
+
+    // Validate and normalize
+    const ids = new Set(steps.map(s => s.id));
+    return steps.map(s => {
+      if (!s.id || !s.action) throw new Error(`[Planner] step missing id or action: ${JSON.stringify(s)}`);
+      const deps = (s.dependsOn || []).filter(d => ids.has(d));
+      return { id: s.id, action: s.action, dependsOn: deps, status: 'pending' };
+    });
+  }
+}
+
+module.exports = { Planner };

package/src/provider-anthropic.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const https = require('https');
+
+class AnthropicProvider {
+  /**
+   * @param {object} options
+   * @param {string} options.apiKey - Anthropic API key (required).
+   * @param {string} [options.model='claude-haiku-4-5-20251001'] - Model ID.
+   * @throws {Error} `[AnthropicProvider] requires apiKey` — when apiKey is missing.
+   */
+  constructor(options = {}) {
+    if (!options.apiKey) throw new Error('[AnthropicProvider] requires apiKey');
+    this.apiKey = options.apiKey.trim();
+    this.model = options.model || 'claude-haiku-4-5-20251001';
+  }
+
+  /**
+   * Generate a response from the Anthropic API.
+   * @param {Array<object>} messages - Conversation messages (OpenAI format, auto-converted).
+   * @param {Array<object>} [tools=[]] - Tool definitions.
+   * @param {object} [options={}] - Options (temperature, maxTokens, system).
+   * @returns {Promise<{text: string, toolCalls: Array, usage: object}>}
+   * @throws {Error} `[AnthropicProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
+   */
+  async generate(messages, tools = [], options = {}) {
+    // Separate system message from conversation messages
+    let system;
+    const msgs = [];
+    for (const m of messages) {
+      if (m.role === 'system') {
+        system = m.content;
+      } else {
+        msgs.push(this._toAnthropicMessage(m));
+      }
+    }
+
+    // Override with options.system if provided
+    if (options.system) system = options.system;
+
+    const body = {
+      model: this.model,
+      max_tokens: options.maxTokens || 4096,
+      messages: msgs,
+      ...(system && { system }),
+      ...(options.temperature != null && { temperature: options.temperature }),
+    };
+    if (tools.length > 0) {
+      body.tools = tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+      }));
+    }
+
+    const data = await this._request(body);
+
+    let text = '';
+    const toolCalls = [];
+    for (const block of data.content) {
+      if (block.type === 'text') text += block.text;
+      if (block.type === 'tool_use') {
+        toolCalls.push({ id: block.id, name: block.name, arguments: block.input });
+      }
+    }
+
+    return {
+      text,
+      toolCalls,
+      usage: {
+        inputTokens: data.usage?.input_tokens || 0,
+        outputTokens: data.usage?.output_tokens || 0,
+      },
+    };
+  }
+
+  _toAnthropicMessage(msg) {
+    // Convert OpenAI-format tool results → Anthropic tool_result blocks
+    if (msg.role === 'tool') {
+      return {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: msg.tool_call_id,
+          content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        }],
+      };
+    }
+    // Convert OpenAI-format assistant tool_calls → Anthropic tool_use content blocks
+    if (msg.role === 'assistant' && msg.tool_calls?.length > 0) {
+      const content = [];
+      if (msg.content) content.push({ type: 'text', text: msg.content });
+      for (const tc of msg.tool_calls) {
+        content.push({
+          type: 'tool_use',
+          id: tc.id,
+          name: tc.function.name,
+          input: typeof tc.function.arguments === 'string'
+            ? JSON.parse(tc.function.arguments)
+            : tc.function.arguments,
+        });
+      }
+      return { role: 'assistant', content };
+    }
+    return { role: msg.role, content: msg.content };
+  }
+
+  _request(body) {
+    return new Promise((resolve, reject) => {
+      const payload = JSON.stringify(body);
+      const req = https.request('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+          'x-api-key': this.apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+      }, (res) => {
+        let chunks = '';
+        res.on('data', d => chunks += d);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(chunks);
+            if (res.statusCode >= 400) {
+              const err = new Error(`[AnthropicProvider] ${parsed.error?.message || `HTTP ${res.statusCode}`}`);
+              err.status = res.statusCode;
+              err.body = parsed;
+              return reject(err);
+            }
+            resolve(parsed);
+          } catch (e) {
+            reject(new Error(`[AnthropicProvider] Invalid JSON response: ${chunks.slice(0, 200)}`));
+          }
+        });
+      });
+      req.on('error', reject);
+      req.write(payload);
+      req.end();
+    });
+  }
+}
+
+module.exports = { AnthropicProvider };

package/src/provider-ollama.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const http = require('http');
+
+class OllamaProvider {
+  constructor(options = {}) {
+    this.model = options.model || 'llama3.2';
+    this.url = options.url || 'http://localhost:11434';
+  }
+
+  /**
+   * Generate a response from a local Ollama instance.
+   * @param {Array<object>} messages - Conversation messages.
+   * @param {Array<object>} [tools=[]] - Tool definitions.
+   * @param {object} [options={}] - Options (temperature).
+   * @returns {Promise<{text: string, toolCalls: Array, usage: object}>}
+   * @throws {Error} `[OllamaProvider] ...` — on HTTP errors or invalid JSON response.
+   */
+  async generate(messages, tools = [], options = {}) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: false,
+      ...(options.temperature != null && { options: { temperature: options.temperature } }),
+    };
+    if (tools.length > 0) {
+      body.tools = tools.map(t => ({
+        type: 'function',
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+      }));
+    }
+
+    const data = await this._request('/api/chat', body);
+    const msg = data.message || {};
+
+    return {
+      text: msg.content || '',
+      toolCalls: (msg.tool_calls || []).map(tc => ({
+        id: tc.id || `call_${Date.now()}`,
+        name: tc.function.name,
+        arguments: typeof tc.function.arguments === 'string'
+          ? JSON.parse(tc.function.arguments)
+          : tc.function.arguments,
+      })),
+      usage: {
+        inputTokens: data.prompt_eval_count || 0,
+        outputTokens: data.eval_count || 0,
+      },
+    };
+  }
+
+  _request(path, body) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.url + path);
+      const payload = JSON.stringify(body);
+
+      const req = http.request(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+        },
+      }, (res) => {
+        let chunks = '';
+        res.on('data', d => chunks += d);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(chunks);
+            if (res.statusCode >= 400) {
+              const err = new Error(`[OllamaProvider] ${parsed.error || `HTTP ${res.statusCode}`}`);
+              err.status = res.statusCode;
+              return reject(err);
+            }
+            resolve(parsed);
+          } catch (e) {
+            reject(new Error(`[OllamaProvider] Invalid JSON response: ${chunks.slice(0, 200)}`));
+          }
+        });
+      });
+      req.on('error', reject);
+      req.write(payload);
+      req.end();
+    });
+  }
+}
+
+module.exports = { OllamaProvider };

package/src/provider-openai.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const https = require('https');
+const http = require('http');
+
+class OpenAIProvider {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey?.trim();
+    this.model = options.model || 'gpt-4o-mini';
+    this.baseUrl = options.baseUrl || 'https://api.openai.com/v1';
+  }
+
+  /**
+   * Generate a response from the OpenAI API.
+   * @param {Array<object>} messages - Conversation messages.
+   * @param {Array<object>} [tools=[]] - Tool definitions.
+   * @param {object} [options={}] - Options (temperature, maxTokens).
+   * @returns {Promise<{text: string, toolCalls: Array, usage: object}>}
+   * @throws {Error} `[OpenAIProvider] ...` — on HTTP errors (4xx/5xx) or invalid JSON response.
+   */
+  async generate(messages, tools = [], options = {}) {
+    const body = {
+      model: this.model,
+      messages,
+      ...(options.temperature != null && { temperature: options.temperature }),
+      ...(options.maxTokens && { max_tokens: options.maxTokens }),
+    };
+    if (tools.length > 0) {
+      body.tools = tools.map(t => ({
+        type: 'function',
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+      }));
+    }
+
+    const data = await this._request('/chat/completions', body);
+    const choice = data.choices[0];
+    const msg = choice.message;
+
+    return {
+      text: msg.content || '',
+      toolCalls: (msg.tool_calls || []).map(tc => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments),
+      })),
+      usage: {
+        inputTokens: data.usage?.prompt_tokens || 0,
+        outputTokens: data.usage?.completion_tokens || 0,
+      },
+    };
+  }
+
+  _request(path, body) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.baseUrl + path);
+      const transport = url.protocol === 'https:' ? https : http;
+      const payload = JSON.stringify(body);
+
+      const req = transport.request(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload),
+          ...(this.apiKey && { 'Authorization': `Bearer ${this.apiKey}` }),
+        },
+      }, (res) => {
+        let chunks = '';
+        res.on('data', d => chunks += d);
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(chunks);
+            if (res.statusCode >= 400) {
+              const err = new Error(`[OpenAIProvider] ${parsed.error?.message || `HTTP ${res.statusCode}`}`);
+              err.status = res.statusCode;
+              err.body = parsed;
+              return reject(err);
+            }
+            resolve(parsed);
+          } catch (e) {
+            reject(new Error(`[OpenAIProvider] Invalid JSON response: ${chunks.slice(0, 200)}`));
+          }
+        });
+      });
+      req.on('error', reject);
+      req.write(payload);
+      req.end();
+    });
+  }
+}
+
+module.exports = { OpenAIProvider };

package/src/providers.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const { OpenAIProvider } = require('./provider-openai');
+const { AnthropicProvider } = require('./provider-anthropic');
+const { OllamaProvider } = require('./provider-ollama');
+
+module.exports = {
+  OpenAI: OpenAIProvider,
+  Anthropic: AnthropicProvider,
+  Ollama: OllamaProvider,
+};

package/src/retry.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const DEFAULT_RETRY_ON = (err) => {
+  const status = err.status || err.statusCode;
+  if (status === 429 || (status >= 500 && status <= 504)) return true;
+  const code = err.code;
+  if (code === 'ECONNRESET' || code === 'ETIMEDOUT' || code === 'ENOTFOUND') return true;
+  return false;
+};
+
+class Retry {
+  constructor(options = {}) {
+    this.maxAttempts = options.maxAttempts || 3;
+    this.backoff = options.backoff || 'exponential';
+    this.timeout = options.timeout || 60000;
+    this.retryOn = options.retryOn || DEFAULT_RETRY_ON;
+  }
+
+  /**
+   * Call a function with retry logic.
+   * @param {() => Promise<*>} fn - Async function to execute.
+   * @param {object} [options={}] - Per-call overrides for maxAttempts, retryOn, timeout.
+   * @returns {Promise<*>} The result of fn().
+   * @throws {Error} `[Retry] Timeout` — when an individual attempt exceeds the timeout.
+   * @throws {Error} Rethrows the last error when maxAttempts is exhausted or error is not retryable.
+   */
+  async call(fn, options = {}) {
+    const max = options.maxAttempts || this.maxAttempts;
+    const retryOn = options.retryOn || this.retryOn;
+    const timeout = options.timeout || this.timeout;
+
+    for (let attempt = 1; attempt <= max; attempt++) {
+      try {
+        const result = await (timeout
+          ? Promise.race([fn(), new Promise((_, rej) => setTimeout(() => rej(Object.assign(new Error('[Retry] Timeout'), { code: 'ETIMEDOUT' })), timeout))])
+          : fn());
+        return result;
+      } catch (err) {
+        if (attempt === max || !retryOn(err)) throw err;
+        const delay = this._delay(attempt);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+
+  _delay(attempt) {
+    if (typeof this.backoff === 'number') return this.backoff;
+    if (this.backoff === 'linear') return attempt * 1000;
+    return Math.min(2 ** (attempt - 1) * 1000, 30000); // exponential, cap 30s
+  }
+}
+
+module.exports = { Retry };

package/src/scheduler.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { readFileSync, writeFileSync, existsSync } = require('node:fs');
+
+/**
+ * Time-triggered agent turns. The only way the agent acts without being messaged.
+ *
+ * Interface:
+ *   add(job)        → jobId
+ *   remove(jobId)   → void
+ *   list()          → [jobs]
+ *   start(handler)  → begin tick loop (handler receives due jobs)
+ *   stop()          → stop tick loop
+ */
+class Scheduler {
+  constructor(options = {}) {
+    this._file = options.file || null;
+    this._interval = options.interval || 60000;
+    this.onError = options.onError || null;
+    this._jobs = this._file && existsSync(this._file)
+      ? JSON.parse(readFileSync(this._file, 'utf8'))
+      : [];
+    this._timer = null;
+    this._nextId = this._jobs.length
+      ? Math.max(...this._jobs.map(j => j.id)) + 1
+      : 1;
+  }
+
+  _save() {
+    if (this._file) writeFileSync(this._file, JSON.stringify(this._jobs, null, 2));
+  }
+
+  add(job) {
+    const id = this._nextId++;
+    const nextRun = this._parseSchedule(job.schedule);
+    this._jobs.push({
+      id,
+      type: job.type || 'once',
+      schedule: job.schedule,
+      action: job.action,
+      status: 'active',
+      nextRun: nextRun.toISOString(),
+      createdAt: new Date().toISOString(),
+    });
+    this._save();
+    return id;
+  }
+
+  remove(jobId) {
+    this._jobs = this._jobs.filter(j => j.id !== jobId);
+    this._save();
+  }
+
+  list() {
+    return this._jobs.map(j => ({ ...j }));
+  }
+
+  /**
+   * Begin the tick loop. Calls `handler(job)` for each due job every tick interval.
+   *
+   * - `handler` is called with the full job object: `{ id, type, schedule, action, status, nextRun }`.
+   * - Jobs that are still running (handler hasn't resolved) are skipped on subsequent ticks
+   *   via the internal `_running` Set — this prevents overlapping executions of the same job.
+   * - Within a single tick, due jobs are executed sequentially (awaited one at a time).
+   * - If a handler throws, the error is passed to `onError(err, job)` if configured.
+   *   The tick loop continues to the next job — handler errors never crash the scheduler.
+   *
+   * @param {(job: object) => Promise<void>} handler - Async function called for each due job.
+   */
+  start(handler) {
+    if (this._timer) return;
+    this._running = new Set();
+    const tick = async () => {
+      const now = new Date();
+      for (const job of this._jobs) {
+        if (job.status !== 'active') continue;
+        if (this._running.has(job.id)) continue;
+        if (new Date(job.nextRun) > now) continue;
+        this._running.add(job.id);
+        try {
+          await handler(job);
+        } catch (err) {
+          this.onError?.(err, job);
+        }
+        this._running.delete(job.id);
+        if (job.type === 'once') {
+          job.status = 'done';
+        } else {
+          job.nextRun = this._parseSchedule(job.schedule).toISOString();
+        }
+        this._save();
+      }
+    };
+    tick();
+    this._timer = setInterval(tick, this._interval);
+  }
+
+  stop() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+  }
+
+  /**
+   * @param {string} schedule - Relative ('5s','30m','2h','1d') or cron expression.
+   * @returns {Date} The next run time.
+   * @throws {Error} `[Scheduler] Cannot parse schedule` — when format is not recognized.
+   * @private
+   */
+  _parseSchedule(schedule) {
+    // Relative: '5s', '30m', '2h', '1d'
+    const rel = schedule.match(/^(\d+)(s|m|h|d)$/);
+    if (rel) {
+      const [, n, unit] = rel;
+      const ms = { s: 1000, m: 60000, h: 3600000, d: 86400000 }[unit];
+      return new Date(Date.now() + Number(n) * ms);
+    }
+    // Cron: try cron-parser
+    try {
+      const { parseExpression } = require('cron-parser');
+      return parseExpression(schedule).next().toDate();
+    } catch {
+      throw new Error(`[Scheduler] Cannot parse schedule: "${schedule}". Use relative (5s/30m/2h/1d) or cron expression.`);
+    }
+  }
+}
+
+module.exports = { Scheduler };

package/src/state.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const { readFileSync, writeFileSync } = require('fs');
+const { EventEmitter } = require('events');
+
+const TRANSITIONS = {
+  pending:            { start: 'running', cancel: 'cancelled' },
+  running:            { complete: 'done', fail: 'failed', pause: 'waiting_for_input', cancel: 'cancelled' },
+  failed:             { retry: 'running', cancel: 'cancelled' },
+  waiting_for_input:  { resume: 'running', cancel: 'cancelled' },
+  // done and cancelled are terminal
+};
+
+class StateMachine extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.file = options.file || null;
+    this.tasks = new Map();
+    if (this.file) this._load();
+  }
+
+  /**
+   * Transition a task to a new state.
+   * @param {string} taskId - Task identifier.
+   * @param {string} event - Transition event (start, complete, fail, pause, resume, cancel, retry).
+   * @param {*} [data] - Optional data to attach to the task.
+   * @returns {string} The new status.
+   * @throws {Error} `[StateMachine] Invalid transition` — when the event is not valid for the current state.
+   */
+  transition(taskId, event, data) {
+    let task = this.tasks.get(taskId);
+    if (!task) {
+      task = { status: 'pending', data: null, error: null, updatedAt: new Date().toISOString() };
+      this.tasks.set(taskId, task);
+    }
+
+    const allowed = TRANSITIONS[task.status];
+    if (!allowed || !allowed[event]) {
+      throw new Error(`[StateMachine] Invalid transition: ${task.status} + ${event} (task: ${taskId})`);
+    }
+
+    const prev = task.status;
+    task.status = allowed[event];
+    task.updatedAt = new Date().toISOString();
+    if (data !== undefined) task.data = data;
+    if (event === 'fail') task.error = data || null;
+    if (event === 'complete') task.error = null;
+
+    this.emit('transition', { taskId, from: prev, to: task.status, event, data });
+    if (this.file) this._save();
+    return task.status;
+  }
+
+  getStatus(taskId) {
+    return this.tasks.get(taskId) || null;
+  }
+
+  onTransition(callback) {
+    this.on('transition', callback);
+    return () => this.off('transition', callback);
+  }
+
+  getAll() {
+    const result = {};
+    for (const [id, task] of this.tasks) result[id] = { ...task };
+    return result;
+  }
+
+  _load() {
+    try {
+      const raw = readFileSync(this.file, 'utf8');
+      const data = JSON.parse(raw);
+      for (const [id, task] of Object.entries(data)) this.tasks.set(id, task);
+    } catch (e) {
+      if (e.code !== 'ENOENT') throw e;
+    }
+  }
+
+  _save() {
+    const obj = {};
+    for (const [id, task] of this.tasks) obj[id] = task;
+    writeFileSync(this.file, JSON.stringify(obj, null, 2) + '\n');
+  }
+}
+
+module.exports = { StateMachine };