agentboss 0.1.0

package/server/etl/detect.js

@@ -0,0 +1,341 @@
+/**
+ * Data source auto-detection for Agent Boss
+ *
+ * Detects installed AI coding tools (OpenCode, Claude Code) by checking
+ * default paths and validating data source integrity, then writes results
+ * to the tool_config table.
+ *
+ * Design doc references: §4.1 (dual data sources), §4.4 (degradation), §11 (error handling)
+ *
+ * @author Felix
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const sqlite3 = require('sqlite3');
+
+// ---------------------------------------------------------------------------
+// Default path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Get the default path to opencode.db based on platform.
+ * All platforms: ~/.local/share/opencode/opencode.db
+ * @returns {string}
+ */
+function getDefaultOpenCodePath() {
+  return path.join(os.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+}
+
+/**
+ * Get the default path to the Claude Code data directory.
+ * All platforms: ~/.claude/
+ * @returns {string}
+ */
+function getDefaultClaudeCodePath() {
+  return path.join(os.homedir(), '.claude');
+}
+
+// ---------------------------------------------------------------------------
+// Path helpers (resolve from tool_config or fall back to default)
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the resolved path to opencode.db.
+ * If the user configured a custom data_path in tool_config, that is used;
+ * otherwise the platform default is returned.
+ *
+ * @param {object} db - boss.db database instance
+ * @returns {string} absolute path to opencode.db
+ */
+function getOpenCodeDbPath(db) {
+  try {
+    const { queryOne } = require('../db/queries');
+    const row = queryOne(db, 'SELECT data_path FROM tool_config WHERE tool = ?', ['opencode']);
+    if (row && row.data_path) {
+      return row.data_path;
+    }
+  } catch (_) {
+    // table may not exist yet; fall through to default
+  }
+  return getDefaultOpenCodePath();
+}
+
+/**
+ * Returns the resolved path to the Claude Code data directory (~/.claude/).
+ * If the user configured a custom data_path in tool_config, that is used;
+ * otherwise the platform default is returned.
+ *
+ * @param {object} db - boss.db database instance
+ * @returns {string} absolute path to ~/.claude/
+ */
+function getClaudeCodePath(db) {
+  try {
+    const { queryOne } = require('../db/queries');
+    const row = queryOne(db, 'SELECT data_path FROM tool_config WHERE tool = ?', ['claude-code']);
+    if (row && row.data_path) {
+      return row.data_path;
+    }
+  } catch (_) {
+    // table may not exist yet; fall through to default
+  }
+  return getDefaultClaudeCodePath();
+}
+
+// ---------------------------------------------------------------------------
+// Validation helpers
+// ---------------------------------------------------------------------------
+
+/** The magic bytes that every SQLite file starts with */
+const SQLITE_MAGIC = 'SQLite format 3\0';
+
+/**
+ * Validate an OpenCode data source.
+ *
+ * Checks:
+ *  1. File exists
+ *  2. First 16 bytes match the SQLite magic header
+ *  3. The database contains the required tables: session, message, part
+ *
+ * @param {string} dbPath - absolute path to opencode.db
+ * @returns {Promise<{status: string, detail?: string}>}
+ */
+async function validateOpenCode(dbPath) {
+  // 1. File existence
+  if (!fs.existsSync(dbPath)) {
+    return { status: 'not_found', detail: `File does not exist: ${dbPath}` };
+  }
+
+  // 2. SQLite magic header
+  let fd;
+  try {
+    fd = fs.openSync(dbPath, 'r');
+    const buf = Buffer.alloc(16);
+    fs.readSync(fd, buf, 0, 16, 0);
+    if (buf.toString('utf8') !== SQLITE_MAGIC) {
+      return { status: 'invalid', detail: 'File is not a valid SQLite database (bad magic header)' };
+    }
+  } catch (err) {
+    return { status: 'invalid', detail: `Cannot read file: ${err.message}` };
+  } finally {
+    if (fd !== undefined) {
+      fs.closeSync(fd);
+    }
+  }
+
+  // 3. Open with sqlite3 (native, read-only) and verify required tables
+  try {
+    const result = await new Promise((resolve, reject) => {
+      const sourceDb = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+        if (err) return reject(err);
+        sourceDb.all(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name IN ('session','message','part')",
+          (err2, rows) => {
+            sourceDb.close();
+            if (err2) return reject(err2);
+            resolve(rows);
+          }
+        );
+      });
+    });
+
+    const foundTables = result.map((row) => row.name);
+    const required = ['session', 'message', 'part'];
+    const missing = required.filter((t) => !foundTables.includes(t));
+
+    if (missing.length > 0) {
+      return { status: 'invalid', detail: `Missing required tables: ${missing.join(', ')}` };
+    }
+
+    return { status: 'available' };
+  } catch (err) {
+    return { status: 'invalid', detail: `Failed to open SQLite database: ${err.message}` };
+  }
+}
+
+/**
+ * Validate a Claude Code data source.
+ *
+ * Checks:
+ *  1. Directory exists
+ *  2. Contains a projects/ subdirectory
+ *  3. At least one JSONL session file exists under projects/
+ *  4. First line of the first JSONL has required fields (type, timestamp, sessionId)
+ *
+ * @param {string} dirPath - absolute path to ~/.claude/
+ * @returns {{status: string, detail?: string}}
+ */
+function validateClaudeCode(dirPath) {
+  // 1. Directory existence
+  if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
+    return { status: 'not_found', detail: `Directory does not exist: ${dirPath}` };
+  }
+
+  // 2. projects/ subdirectory
+  const projectsDir = path.join(dirPath, 'projects');
+  if (!fs.existsSync(projectsDir) || !fs.statSync(projectsDir).isDirectory()) {
+    return { status: 'invalid', detail: 'Missing projects/ subdirectory' };
+  }
+
+  // 3. Collect candidate JSONL files (one per project folder is enough)
+  const candidateFiles = [];
+  try {
+    const projectFolders = fs.readdirSync(projectsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory());
+
+    for (const folder of projectFolders) {
+      const folderPath = path.join(projectsDir, folder.name);
+      let files;
+      try {
+        files = fs.readdirSync(folderPath);
+      } catch (_) {
+        continue;
+      }
+      for (const f of files) {
+        if (f.endsWith('.jsonl')) {
+          candidateFiles.push(path.join(folderPath, f));
+        }
+      }
+      // Cap to avoid scanning huge installs — a handful is enough to validate
+      if (candidateFiles.length >= 8) break;
+    }
+  } catch (err) {
+    return { status: 'invalid', detail: `Cannot read projects directory: ${err.message}` };
+  }
+
+  if (candidateFiles.length === 0) {
+    return { status: 'invalid', detail: 'No JSONL session files found under projects/' };
+  }
+
+  // 4. Validate: across the candidate files, find at least one event row that
+  //    looks like an actual user/assistant message. JSONL files can start
+  //    with metadata rows (`type: "mode"`, `type: "summary"`) that lack
+  //    `timestamp` — those are skipped by the ETL, so they must not fail
+  //    validation either.
+  const REQUIRED = ['type', 'timestamp', 'sessionId'];
+  let lastDetail = 'No valid event rows found in any JSONL';
+
+  for (const filePath of candidateFiles) {
+    let fd;
+    try {
+      fd = fs.openSync(filePath, 'r');
+      const buf = Buffer.alloc(65536);
+      const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+      const content = buf.toString('utf8', 0, bytesRead);
+      const lines = content.split('\n');
+
+      for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch (_) {
+          // Truncated last line in the buffer — skip
+          continue;
+        }
+        const missing = REQUIRED.filter((f) => !(f in parsed));
+        if (missing.length === 0) {
+          return { status: 'available' };
+        }
+        lastDetail = `JSONL missing required fields: ${missing.join(', ')}`;
+      }
+    } catch (err) {
+      lastDetail = `Cannot read JSONL file: ${err.message}`;
+    } finally {
+      if (fd !== undefined) {
+        try { fs.closeSync(fd); } catch (_) { /* ignore */ }
+      }
+    }
+  }
+
+  return { status: 'invalid', detail: lastDetail };
+}
+
+// ---------------------------------------------------------------------------
+// Main detection function
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect installed data sources and update the tool_config table.
+ *
+ * For each tool (OpenCode, Claude Code):
+ *  1. Resolve path (custom data_path from tool_config, or platform default)
+ *  2. Validate the data source
+ *  3. Upsert the result into tool_config
+ *
+ * A detection failure for one source never affects the other.
+ *
+ * @param {object} db - boss.db database instance (better-sqlite3 compatible)
+ * @returns {Promise<{opencode: {status: string, path: string}, claudeCode: {status: string, path: string}}>}
+ */
+async function detectSources(db) {
+  const results = {
+    opencode: { status: 'not_found', path: '' },
+    claudeCode: { status: 'not_found', path: '' },
+  };
+
+  /**
+   * Upsert a tool_config row using sql.js API.
+   * Preserves any existing custom data_path.
+   */
+  function upsertTool(tool, label, status, dataPath) {
+    db.run(
+      `INSERT INTO tool_config (tool, label, status, data_path, enabled)
+       VALUES (?, ?, ?, ?, 1)
+       ON CONFLICT(tool) DO UPDATE SET
+         status    = excluded.status,
+         data_path = COALESCE(tool_config.data_path, excluded.data_path)`,
+      [tool, label, status, dataPath]
+    );
+  }
+
+  // --- OpenCode ---
+  try {
+    const ocPath = getOpenCodeDbPath(db);
+    results.opencode.path = ocPath;
+
+    const ocResult = await validateOpenCode(ocPath);
+    results.opencode.status = ocResult.status;
+
+    upsertTool('opencode', 'OpenCode', ocResult.status, ocPath);
+  } catch (err) {
+    results.opencode.status = 'invalid';
+    try {
+      upsertTool('opencode', 'OpenCode', 'invalid', results.opencode.path || getDefaultOpenCodePath());
+    } catch (_) {
+      // best-effort
+    }
+  }
+
+  // --- Claude Code ---
+  try {
+    const ccPath = getClaudeCodePath(db);
+    results.claudeCode.path = ccPath;
+
+    const ccResult = validateClaudeCode(ccPath);
+    results.claudeCode.status = ccResult.status;
+
+    upsertTool('claude-code', 'Claude Code', ccResult.status, ccPath);
+  } catch (err) {
+    results.claudeCode.status = 'invalid';
+    try {
+      upsertTool('claude-code', 'Claude Code', 'invalid', results.claudeCode.path || getDefaultClaudeCodePath());
+    } catch (_) {
+      // best-effort
+    }
+  }
+
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  detectSources,
+  getOpenCodeDbPath,
+  getClaudeCodePath,
+};

package/server/etl/judge-filter.js

@@ -0,0 +1,117 @@
+/**
+ * Shared ETL helper — recognise sessions created by our own LLM calls.
+ *
+ * Every aboss-originated LLM invocation (judge E1/O1, per-session advice,
+ * anything we add later) goes through a local CLI like `opencode run` or
+ * `claude -p`, which logs the call as a session in its own data store.
+ * Importing those back would create a feedback loop: each pass spawns
+ * sessions, the next ETL imports them as the user's work, they get
+ * analyzed and spawn more, and so on.
+ *
+ * Detection covers, in order:
+ *   • JUDGE_SENTINEL  — first-line marker on judge (E1/O1) prompts
+ *   • ADVICE_SENTINEL — first-line marker on per-session advice prompts
+ *   • legacy signatures — prompts sent before sentinels existed
+ *
+ * New prompt families MUST register their sentinel here.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const { JUDGE_SENTINEL } = require('../llm/judge-prompts');
+const { ADVICE_SENTINEL } = require('../llm/advice-prompt');
+const { ANALYSIS_SENTINEL } = require('../llm/analysis-prompt');
+const { EXECUTION_SENTINEL } = require('../execution/prompt');
+
+// Every internal sentinel — extend when adding new prompt families.
+const SENTINELS = [JUDGE_SENTINEL, ADVICE_SENTINEL, ANALYSIS_SENTINEL, EXECUTION_SENTINEL];
+
+// Legacy signatures from older prompt versions (pre-JUDGE_SENTINEL).
+// Order matters only for readability — we just OR them together.
+const LEGACY_SIGNATURES = [
+  // v2 — Chinese audit prompts
+  /^你是一名严格的\s*(AI\s*协作审计员|代码与产出审计员)/,
+  // v1 — English five-dimension reviewer prompt (used by initial release)
+  /^You are an expert reviewer of human-AI coding collaboration\./,
+];
+
+/**
+ * Some historical ETL paths stored the user text after JSON.stringify, so
+ * the payload arrives wrapped in `"..."`.  Strip a single layer of
+ * matching outer quotes before testing the signatures; otherwise the
+ * leading `"` defeats the `^You are…` anchor.
+ *
+ * Edge case: server/etl/opencode.js truncates message text at 4 KB before
+ * filtering runs, which can chop off the closing quote — leaving us with
+ * `"...<no-trailing-quote>`.  In that case the symmetric-quotes branch
+ * skips and the leading `"` defeats the anchored signatures.  So we also
+ * strip an unpaired leading quote as a best-effort fallback.
+ */
+function _unwrap(text) {
+  const s = text.trimStart();
+  if (s.length >= 2) {
+    const first = s.charAt(0);
+    const last = s.charAt(s.length - 1);
+    if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+      try { return JSON.parse(s); } catch (_) { return s.slice(1, -1); }
+    }
+    // Fallback: a leading quote but no matching trailer (e.g. truncated).
+    if (first === '"' || first === "'") return s.slice(1);
+  }
+  return s;
+}
+
+/**
+ * True if the given user-message text is one of our judge prompts.
+ *
+ * @param {string|null} text
+ * @returns {boolean}
+ */
+function isJudgePrompt(text) {
+  if (typeof text !== 'string' || !text) return false;
+  const t = _unwrap(text);
+  for (const s of SENTINELS) {
+    if (t.startsWith(s)) return true;
+  }
+  for (const re of LEGACY_SIGNATURES) {
+    if (re.test(t)) return true;
+  }
+  return false;
+}
+
+/**
+ * True if the given session title belongs to one of our own internal
+ * `opencode run` invocations (polish/analyze/etc).  These sessions always
+ * carry an `agent-boss-internal-` prefix as their auto-title, regardless
+ * of prompt content, so we can filter them out without inspecting parts.
+ */
+function isInternalAbossTitle(title) {
+  if (typeof title !== 'string' || !title) return false;
+  return title.startsWith('agent-boss-internal-');
+}
+
+/**
+ * True if the title is OpenCode's auto-generated placeholder for a
+ * session that was started programmatically without a meaningful first
+ * prompt — e.g. `New session - 2026-06-12T11:14:51.277Z`.
+ *
+ * These sessions carry no human intent and add only noise to reports,
+ * so the ETL drops them outright.  Pattern is anchored on a strict
+ * ISO-8601 timestamp suffix to avoid swallowing real session titles
+ * that happen to start with the words "New session".
+ */
+const PLACEHOLDER_TITLE_RE =
+  /^New session - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+
+function isPlaceholderOpencodeTitle(title) {
+  if (typeof title !== 'string' || !title) return false;
+  return PLACEHOLDER_TITLE_RE.test(title);
+}
+
+module.exports = {
+  isJudgePrompt,
+  isInternalAbossTitle,
+  isPlaceholderOpencodeTitle,
+};