alvin-bot 4.20.2 → 4.22.0

package/dist/services/memory-layers.js

@@ -17,6 +17,7 @@
 import fs from "fs";
 import path from "path";
 import { IDENTITY_FILE, PREFERENCES_FILE, PROJECTS_MEMORY_DIR, MEMORY_FILE, } from "../paths.js";
+import { getEffectiveInjectMode } from "./memory-inject-mode.js";
 const MAX_L0_L1_CHARS = 5000;
 const MAX_L2_PROJECT_CHARS = 1500;
 const MAX_L2_TOTAL_CHARS = 3000;
@@ -96,6 +97,9 @@ export function buildLayeredContext(query) {
     const layers = loadMemoryLayers();
     const parts = [];
     let l0l1Chars = 0;
+    // identity.md (L0) and preferences.md (L1) are ALWAYS plain-text injected,
+    // regardless of inject mode. They're tiny, manually curated, and contain
+    // always-on rules that semantic search may miss for short / generic queries.
     if (layers.identity) {
         const truncated = layers.identity.length > MAX_L0_L1_CHARS
             ? layers.identity.slice(0, MAX_L0_L1_CHARS) + "\n[...truncated]"
@@ -111,21 +115,26 @@ export function buildLayeredContext(query) {
         parts.push("## Preferences (L1)\n" + truncated);
         l0l1Chars += truncated.length;
     }
-    // Backwards-compat: if no identity AND no preferences, use the monolithic
-    // MEMORY.md as L1 fully (existing user setups). If split files exist,
-    // include MEMORY.md as a secondary L1 with tighter truncation.
-    if (!layers.identity && !layers.preferences && layers.longTerm) {
-        const truncated = layers.longTerm.length > MAX_L0_L1_CHARS
-            ? layers.longTerm.slice(0, MAX_L0_L1_CHARS) + "\n[...truncated]"
-            : layers.longTerm;
-        parts.push("## Long-term Memory (L1, monolithic)\n" + truncated);
-    }
-    else if (layers.longTerm) {
-        const SECONDARY_CAP = 1500;
-        const truncated = layers.longTerm.length > SECONDARY_CAP
-            ? layers.longTerm.slice(0, SECONDARY_CAP) + "\n[...truncated]"
-            : layers.longTerm;
-        parts.push("## Long-term Memory (L1, legacy MEMORY.md)\n" + truncated);
+    // The monolithic MEMORY.md plain-text inject is gated by the effective
+    // inject mode (v4.22):
+    //   legacy → inject as before (full or secondary, depending on split-file presence)
+    //   sqlite → skip; the same content lives in the SQLite store and is
+    //            surfaced on-demand via searchMemory() in personality.ts
+    const mode = getEffectiveInjectMode();
+    if (mode === "legacy" && layers.longTerm) {
+        if (!layers.identity && !layers.preferences) {
+            const truncated = layers.longTerm.length > MAX_L0_L1_CHARS
+                ? layers.longTerm.slice(0, MAX_L0_L1_CHARS) + "\n[...truncated]"
+                : layers.longTerm;
+            parts.push("## Long-term Memory (L1, monolithic)\n" + truncated);
+        }
+        else {
+            const SECONDARY_CAP = 1500;
+            const truncated = layers.longTerm.length > SECONDARY_CAP
+                ? layers.longTerm.slice(0, SECONDARY_CAP) + "\n[...truncated]"
+                : layers.longTerm;
+            parts.push("## Long-term Memory (L1, legacy MEMORY.md)\n" + truncated);
+        }
     }
     // L2: project-specific, only when a query is provided
     if (query && layers.projects.length > 0) {

package/dist/services/memory.js

@@ -12,6 +12,7 @@ import { resolve } from "path";
 import { MEMORY_DIR, MEMORY_FILE } from "../paths.js";
 import { reindexMemory } from "./embeddings.js";
 import { buildLayeredContext } from "./memory-layers.js";
+import { getEffectiveInjectMode } from "./memory-inject-mode.js";
 // Ensure dirs exist
 if (!fs.existsSync(MEMORY_DIR))
     fs.mkdirSync(MEMORY_DIR, { recursive: true });
@@ -78,23 +79,28 @@ export function appendDailyLog(entry) {
  */
 export function buildMemoryContext(query) {
     const parts = [];
-    // L0+L1 (+ matched L2 if query) via layered loader
+    const mode = getEffectiveInjectMode();
+    // L0+L1 (+ matched L2 if query) via layered loader. The loader itself
+    // respects MEMORY_INJECT_MODE for the monolithic MEMORY.md slice.
     const layered = buildLayeredContext(query);
     if (layered) {
         parts.push(layered);
     }
-    // Today's log
-    const todayLog = loadDailyLog();
-    if (todayLog) {
-        const truncated = todayLog.length > 1500 ? todayLog.slice(-1500) : todayLog;
-        parts.push(`## Today's Log\n${truncated}`);
-    }
-    // Yesterday's log (for continuity)
-    const yesterday = new Date(Date.now() - 86_400_000).toISOString().slice(0, 10);
-    const yesterdayLog = loadDailyLog(yesterday);
-    if (yesterdayLog) {
-        const truncated = yesterdayLog.length > 500 ? yesterdayLog.slice(-500) : yesterdayLog;
-        parts.push(`## Yesterday's Log (summary)\n${truncated}`);
+    // Daily logs are bulk-injected only in legacy mode. In sqlite mode they're
+    // discoverable via searchMemory() — every log file is indexed individually
+    // and surfaced when relevant to the user's query.
+    if (mode === "legacy") {
+        const todayLog = loadDailyLog();
+        if (todayLog) {
+            const truncated = todayLog.length > 1500 ? todayLog.slice(-1500) : todayLog;
+            parts.push(`## Today's Log\n${truncated}`);
+        }
+        const yesterday = new Date(Date.now() - 86_400_000).toISOString().slice(0, 10);
+        const yesterdayLog = loadDailyLog(yesterday);
+        if (yesterdayLog) {
+            const truncated = yesterdayLog.length > 500 ? yesterdayLog.slice(-500) : yesterdayLog;
+            parts.push(`## Yesterday's Log (summary)\n${truncated}`);
+        }
     }
     if (parts.length === 0)
         return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alvin-bot",
-  "version": "4.20.2",
+  "version": "4.22.0",
   "description": "Alvin Bot — Your personal AI agent on Telegram, WhatsApp, Discord, Signal, and Web.",
   "type": "module",
   "main": "dist/index.js",

package/skills/agent-browser/SKILL.md

@@ -0,0 +1,183 @@
+---
+name: Agent Browser (Snapshot+Ref)
+description: Token-efficient browser automation via the `agent-browser` CLI (Vercel Labs). Uses accessibility-tree snapshots with @eN refs (~200–400 tokens per page) instead of raw HTML parsing — typically 90%+ cheaper than Playwright/Puppeteer. Use for click-fill-extract on public pages, single-page test flows, structured form submission, and screenshots-with-refs. Optional dependency — only active if `agent-browser` is on the PATH; otherwise the regular Browser Automation skill takes over.
+triggers: snapshot the page, get refs, list interactive elements, click @e, fill @e, agent-browser, click button on, click the button, fill in the field, extract from page, find on page, scrape page interactively, visit and click, open page and click, navigate and fill, semantic locator, accessibility tree, snapshot+ref, schau auf der Seite nach, klicke auf den Button, fülle das Feld, formular ausfüllen
+priority: 9
+category: automation
+---
+
+# Agent Browser — Token-Efficient Snapshot+Ref Workflow
+
+Use this skill when interactive browser automation is needed (click, fill,
+extract, screenshot) AND `agent-browser` is installed. The accessibility-tree
+snapshot makes per-page interaction roughly an order of magnitude cheaper in
+tokens than parsing rendered HTML with Playwright.
+
+## Pre-flight: is the CLI installed?
+
+```bash
+command -v agent-browser >/dev/null 2>&1 \
+  && echo "agent-browser ok" \
+  || echo "fall back to the Browser Automation skill"
+```
+
+If absent: **stop and use the regular Browser Automation skill** (Tier 1
+Stealth / Tier 2 CDP). Don't suggest installing it unless the user asks —
+it's an opt-in tool, see `alvin-bot doctor` for installation hints.
+
+## Core loop
+
+```bash
+agent-browser open <url>
+agent-browser snapshot -i               # interactive elements, with @e1..@eN refs
+agent-browser click @e3                 # act on a ref
+agent-browser snapshot -i               # CRITICAL — re-snapshot after every page change
+agent-browser close
+```
+
+Refs (`@e1`, `@e2`, …) are **assigned fresh every snapshot**. They go stale
+the moment the page changes (click that navigates, form submit, dynamic
+re-render, modal open). Always re-snapshot before the next ref interaction.
+This single rule is the most common pitfall.
+
+A snapshot looks like:
+
+```
+Page: Example - Log in
+URL: https://example.com/login
+
+@e1 [heading] "Log in"
+@e2 [form]
+  @e3 [input type="email"] placeholder="Email"
+  @e4 [input type="password"] placeholder="Password"
+  @e5 [button type="submit"] "Continue"
+  @e6 [link] "Forgot password?"
+```
+
+## Common patterns
+
+### Read a page
+
+```bash
+agent-browser snapshot -i               # interactive only (preferred)
+agent-browser snapshot -i -u            # include href URLs on links
+agent-browser snapshot -i --json        # machine-readable
+agent-browser get text @e1              # visible text of an element
+agent-browser get attr @e10 href        # any attribute
+agent-browser get url                   # current URL
+```
+
+### Interact
+
+```bash
+agent-browser click @e1
+agent-browser fill @e2 "user@example.com"  # clear + type
+agent-browser type @e2 " more text"        # type without clearing
+agent-browser press Enter
+agent-browser select @e4 "option-value"
+agent-browser upload @e5 file.pdf
+agent-browser scroll down 500
+agent-browser screenshot result.png
+```
+
+### Wait for the right thing (most failures come from bad waits)
+
+```bash
+agent-browser wait @e1                     # until an element appears
+agent-browser wait --text "Success"        # until specific text on the page
+agent-browser wait --url "**/dashboard"    # until URL matches glob
+agent-browser wait --load networkidle      # post-navigation catch-all
+```
+
+Avoid bare `wait 2000` except in throwaway debugging. Default timeout: 25 s.
+
+### Find by semantics when refs aren't ergonomic
+
+```bash
+agent-browser find role button click --name "Submit"
+agent-browser find text "Sign In" click --exact
+agent-browser find label "Email" fill "user@example.com"
+agent-browser find placeholder "Search" type "query"
+agent-browser find testid "submit-btn" click
+```
+
+### Multiple isolated browser sessions (parallel users)
+
+```bash
+agent-browser --session a open https://app.example.com
+agent-browser --session b open https://app.example.com
+agent-browser --session a fill @e1 "alice@test.com"
+agent-browser --session b fill @e1 "bob@test.com"
+```
+
+### Persist login across runs
+
+```bash
+# Save once after a successful login:
+agent-browser state save ./auth.json
+
+# Resume already-logged-in:
+agent-browser --state ./auth.json open https://app.example.com
+```
+
+### Auth vault (don't put passwords in shell history)
+
+```bash
+agent-browser auth save my-app --url https://app.example.com/login \
+  --username user@example.com --password-stdin
+# (paste password, Ctrl+D)
+
+agent-browser auth login my-app
+```
+
+### Iframes
+
+Iframes are inlined in the snapshot — refs work transparently. To scope a
+snapshot to one iframe:
+
+```bash
+agent-browser frame @e3
+agent-browser snapshot -i
+agent-browser frame main
+```
+
+### Mock network (testing)
+
+```bash
+agent-browser network route "**/api/users" --body '{"users":[]}'
+agent-browser network route "**/analytics" --abort
+agent-browser network har start /tmp/trace.har
+# ... do stuff ...
+agent-browser network har stop
+```
+
+## When NOT to use this skill
+
+| Situation | Skill |
+|---|---|
+| Bot-protected site (Cloudflare, DataDome) | regular **Browser Automation** skill, Tier 1 Stealth |
+| Logged-in personal account on LinkedIn / Gmail | **Browser Automation**, Tier 2 CDP (`alvin-bot browser …`) |
+| User wants to watch a complex flow live | **Browser Automation**, Tier 3 Extension |
+| Static HTML / public JSON / RSS / API | `curl` / WebFetch — no browser engine needed |
+
+agent-browser is great for **task automation on cooperative pages** (your
+own apps, public data sites, form submissions). It is *not* a stealth tool.
+
+## Diagnostics
+
+```bash
+agent-browser doctor                # full env check
+agent-browser doctor --quick        # local-only
+agent-browser dashboard start       # observability UI on :4848
+agent-browser skills get core       # the upstream tool's own usage guide
+```
+
+## One-liner sanity test
+
+```bash
+agent-browser open https://example.com \
+  && agent-browser snapshot -i \
+  && agent-browser close
+```
+
+Expect two `@e` refs (heading + link). If that works, the tool is healthy.

package/skills/browse/SKILL.md

@@ -15,12 +15,20 @@ Du hast drei Browser-Strategien plus WebFetch. **Wähle die billigste passende S
 | Task | Tool | Warum |
 |------|------|-------|
 | Einzelne öffentliche Seite, nur Text | `curl` oder WebFetch | Am schnellsten, keine Browser-Engine |
+| Interaktiv (klicken/füllen/extrahieren) auf kooperativer Seite | **Tier 1.5 agent-browser** *(falls installiert)* | Snapshot+Ref-Workflow ist ~90 % token-günstiger als rohes Playwright. Siehe Skill „Agent Browser". |
 | Öffentliche Seite mit JS / Cloudflare | **Tier 1 Stealth** | Headless + Fingerprint-Masking |
 | Login-pflichtige Seite (LinkedIn, Gmail, …) | **Tier 2 CDP** | Echtes Chromium, persistente Cookies |
 | Komplexer Multi-Step-Flow, User soll zusehen | **Tier 3 Extension** | Nur in interaktiven CLI-Sessions |
 
 **NIEMALS** nacktes `node -e "const {chromium}…"` für externe Seiten — wird sofort geblockt.
 
+**Vorab prüfen ob agent-browser verfügbar ist:**
+```bash
+command -v agent-browser >/dev/null 2>&1 && echo "Tier 1.5 verfügbar"
+```
+Falls ja und der Task ist „klick X, lies Y, fülle Z aus" → den `agent-browser`-Skill nehmen.
+Falls nein → mit Tier 1/2/3 weitermachen wie unten. Installation auf Wunsch des Users: `npm i -g agent-browser && agent-browser install`.
+
 ---
 
 ## Tier 0 — curl / WebFetch (schnellster Pfad)