bare-agent 0.1.0 → 0.1.1

package/src/store-jsonfile.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const { readFileSync, writeFileSync, existsSync } = require('node:fs');
+
+/**
+ * JSON file memory store. Zero deps, case-insensitive substring search.
+ *
+ * Interface (implements Memory store contract):
+ *   store(content, metadata)   → id
+ *   search(query, options)     → [{ id, content, metadata, score }]
+ *   get(id)                    → { content, metadata }
+ *   delete(id)                 → void
+ */
+class JsonFileStore {
+  /**
+   * @param {object} options
+   * @param {string} options.path - Path to JSON file (required).
+   * @throws {Error} `[JsonFileStore] requires options.path` — when path is missing.
+   */
+  constructor(options = {}) {
+    if (!options.path) throw new Error('[JsonFileStore] requires options.path');
+    this._path = options.path;
+    this._data = existsSync(this._path)
+      ? JSON.parse(readFileSync(this._path, 'utf8'))
+      : [];
+    this._nextId = this._data.length
+      ? Math.max(...this._data.map(d => d.id)) + 1
+      : 1;
+  }
+
+  _save() {
+    writeFileSync(this._path, JSON.stringify(this._data, null, 2));
+  }
+
+  store(content, metadata = {}) {
+    const id = this._nextId++;
+    this._data.push({ id, content, metadata, createdAt: new Date().toISOString() });
+    this._save();
+    return id;
+  }
+
+  search(query, options = {}) {
+    const limit = options.limit || 10;
+    const q = (query || '').toLowerCase();
+    if (!q) return this._data.slice(0, limit).map(d => ({ ...d, score: 1 }));
+    return this._data
+      .filter(d => d.content.toLowerCase().includes(q))
+      .slice(0, limit)
+      .map(d => ({ ...d, score: 1 }));
+  }
+
+  get(id) {
+    const item = this._data.find(d => d.id === id);
+    return item ? { id: item.id, content: item.content, metadata: item.metadata } : null;
+  }
+
+  delete(id) {
+    this._data = this._data.filter(d => d.id !== id);
+    this._save();
+  }
+}
+
+module.exports = { JsonFileStore };

package/src/store-sqlite.js

@@ -0,0 +1,133 @@
+'use strict';
+
+/**
+ * SQLite FTS5 memory store. Full-text search with BM25 ranking.
+ *
+ * Interface (implements Memory store contract):
+ *   store(content, metadata)   → id
+ *   search(query, options)     → [{ id, content, metadata, score }]
+ *   get(id)                    → { content, metadata }
+ *   delete(id)                 → void
+ *
+ * Requires peer dep: better-sqlite3
+ */
+class SQLiteStore {
+  /**
+   * @param {object} options
+   * @param {string} options.path - Path to SQLite database file (required).
+   * @throws {Error} `[SQLiteStore] requires options.path` — when path is missing.
+   * @throws {Error} `[SQLiteStore] requires better-sqlite3` — when peer dep is not installed.
+   */
+  constructor(options = {}) {
+    if (!options.path) throw new Error('[SQLiteStore] requires options.path');
+
+    let Database;
+    try {
+      Database = require('better-sqlite3');
+    } catch {
+      throw new Error(
+        '[SQLiteStore] requires better-sqlite3. Install it: npm install better-sqlite3'
+      );
+    }
+
+    this._db = new Database(options.path);
+    this._db.pragma('journal_mode = WAL');
+    this._db.exec(`
+      CREATE TABLE IF NOT EXISTS chunks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        content TEXT NOT NULL,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        content,
+        content='chunks',
+        content_rowid='id',
+        tokenize='porter'
+      );
+      CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+      CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES('delete', old.id, old.content);
+      END;
+      CREATE TRIGGER IF NOT EXISTS chunks_au AFTER UPDATE ON chunks BEGIN
+        INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES('delete', old.id, old.content);
+        INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+    `);
+
+    this._insertStmt = this._db.prepare(
+      'INSERT INTO chunks (content, metadata, created_at) VALUES (?, ?, ?)'
+    );
+    this._getStmt = this._db.prepare(
+      'SELECT id, content, metadata FROM chunks WHERE id = ?'
+    );
+    this._deleteStmt = this._db.prepare('DELETE FROM chunks WHERE id = ?');
+    this._searchStmt = this._db.prepare(`
+      SELECT chunks.id, chunks.content, chunks.metadata, rank
+      FROM chunks_fts
+      JOIN chunks ON chunks.id = chunks_fts.rowid
+      WHERE chunks_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `);
+    this._allStmt = this._db.prepare(
+      'SELECT id, content, metadata FROM chunks ORDER BY id DESC LIMIT ?'
+    );
+  }
+
+  store(content, metadata = {}) {
+    const result = this._insertStmt.run(
+      content,
+      JSON.stringify(metadata),
+      new Date().toISOString()
+    );
+    return Number(result.lastInsertRowid);
+  }
+
+  search(query, options = {}) {
+    const limit = options.limit || 10;
+    if (!query) {
+      return this._allStmt.all(limit).map(row => ({
+        id: row.id,
+        content: row.content,
+        metadata: JSON.parse(row.metadata),
+        score: 1,
+      }));
+    }
+    // FTS5 query: wrap each word in quotes for phrase-safe matching
+    const ftsQuery = query
+      .split(/\s+/)
+      .filter(Boolean)
+      .map(w => `"${w.replace(/"/g, '""')}"`)
+      .join(' OR ');
+    try {
+      return this._searchStmt.all(ftsQuery, limit).map(row => ({
+        id: row.id,
+        content: row.content,
+        metadata: JSON.parse(row.metadata),
+        score: -row.rank, // FTS5 rank is negative (closer to 0 = better)
+      }));
+    } catch {
+      // If FTS query fails (e.g. special characters), return empty
+      return [];
+    }
+  }
+
+  get(id) {
+    const row = this._getStmt.get(id);
+    if (!row) return null;
+    return { id: row.id, content: row.content, metadata: JSON.parse(row.metadata) };
+  }
+
+  delete(id) {
+    this._deleteStmt.run(id);
+  }
+
+  close() {
+    this._db.close();
+  }
+}
+
+module.exports = { SQLiteStore };

package/src/stores.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { SQLiteStore } = require('./store-sqlite');
+const { JsonFileStore } = require('./store-jsonfile');
+
+module.exports = {
+  SQLite: SQLiteStore,
+  JsonFile: JsonFileStore,
+};

package/src/stream.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Structured event streaming for observability and cross-process communication.
+ *
+ * Interface:
+ *   emit(event)            → void
+ *   subscribe(callback)    → unsubscribe function
+ *
+ * Event shape:
+ *   { type, taskId, data, ts }
+ *
+ * Transport:
+ *   Object with write(event) method — e.g. JsonlTransport
+ *   null — disabled (subscribers only)
+ */
+class Stream {
+  constructor(options = {}) {
+    this._transport = options.transport || null;
+    this._subscribers = [];
+  }
+
+  emit(event) {
+    const full = { ...event, ts: event.ts || new Date().toISOString() };
+    for (const fn of this._subscribers) {
+      try { fn(full); } catch {}
+    }
+    if (this._transport) {
+      this._transport.write(full);
+    }
+  }
+
+  subscribe(callback) {
+    this._subscribers.push(callback);
+    return () => {
+      this._subscribers = this._subscribers.filter(fn => fn !== callback);
+    };
+  }
+}
+
+module.exports = { Stream };

package/src/transport-jsonl.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * JSONL transport: one JSON object per line to a writable stream.
+ * Default: process.stdout. Pipe-friendly, parseable by any language.
+ *
+ * Debug output goes to stderr (never pollutes stdout).
+ */
+class JsonlTransport {
+  constructor(options = {}) {
+    this._output = options.output || process.stdout;
+  }
+
+  write(event) {
+    this._output.write(JSON.stringify(event) + '\n');
+  }
+}
+
+module.exports = { JsonlTransport };