@yeaft/webchat-agent 0.1.665 → 0.1.667

package/unify/tools/memory-search.js

@@ -1,140 +0,0 @@
-/**
- * memory-search.js → memory_load (task-333b rename).
- *
- * This tool loads memory classification files by path (it is NOT a search).
- * task-333b renamed it from `memory_search` → `memory_load` so the name
- * actually reflects behaviour; `memory_query` remains the fuzzy search tool.
- *
- * Backwards compatibility: a thin alias tool named `memory_search` is also
- * exported (see bottom of file) so older transcripts/prompts still resolve.
- *
- * The system prompt injects `index.md` every turn, which lists all available
- * classification files under `~/.yeaft/memory/` (single files + by-project /
- * by-topic / timeline categories). When the LLM sees a path it wants,
- * it calls this tool with `paths: [...]` to load one or more of those files
- * in full.
- *
- * Only paths under `memory/` are accepted. `..` segments are rejected.
- */
-
-import { defineTool } from './types.js';
-import { readMemoryFile, listClassificationFiles } from '../memory/layout.js';
-
-const MAX_FILES_PER_CALL = 5;
-const MAX_BYTES_PER_FILE = 32000;
-
-const DESCRIPTION = `Load one or more memory classification files in full.
-
-Paths are relative to ~/.yeaft/memory/. Allowed targets:
-  - user-preferences.md           — merged user preferences
-  - by-project/<slug>.md          — per-project narrative summary
-  - by-topic/<slug>.md            — per-topic narrative summary
-  - timeline/<YYYY-MM>.md         — monthly narrative digest
-
-See the "Memory Index" section of the system prompt for the current list
-of available files. Use this tool when the index suggests a file is relevant
-to the user's current request. For fuzzy search over atomic memory entries
-(facts, lessons, preferences), use the memory_query tool instead.
-
-Up to ${MAX_FILES_PER_CALL} files per call. Each file is capped at ${MAX_BYTES_PER_FILE} bytes.`;
-
-const PARAMETERS = {
-  type: 'object',
-  properties: {
-    paths: {
-      type: 'array',
-      items: { type: 'string' },
-      description: 'Relative paths under memory/. Example: ["by-project/claude-web-chat.md", "user-preferences.md"]',
-    },
-  },
-  required: ['paths'],
-};
-
-async function executeLoad(input, ctx) {
-  const yeaftDir = ctx?.yeaftDir;
-  if (!yeaftDir) {
-    return JSON.stringify({ error: 'Memory system not initialized (no yeaftDir in context)' });
-  }
-
-  const paths = Array.isArray(input?.paths) ? input.paths : [];
-  if (paths.length === 0) {
-    return JSON.stringify({
-      error: 'paths is required and must be a non-empty string array',
-      availablePaths: listClassificationFiles(yeaftDir).map(f => f.path),
-    });
-  }
-
-  const results = [];
-  const errors = [];
-
-  for (const rel of paths.slice(0, MAX_FILES_PER_CALL)) {
-    if (typeof rel !== 'string' || !rel.trim()) {
-      errors.push({ path: rel, error: 'not a non-empty string' });
-      continue;
-    }
-    if (rel.includes('..') || rel.startsWith('/')) {
-      errors.push({ path: rel, error: 'path must be relative and must not contain ..' });
-      continue;
-    }
-    if (!rel.endsWith('.md')) {
-      errors.push({ path: rel, error: 'only .md files are supported' });
-      continue;
-    }
-
-    const text = readMemoryFile(yeaftDir, rel);
-    if (!text) {
-      errors.push({ path: rel, error: 'file not found or empty' });
-      continue;
-    }
-
-    const truncated = text.length > MAX_BYTES_PER_FILE;
-    results.push({
-      path: rel,
-      content: truncated ? text.slice(0, MAX_BYTES_PER_FILE) : text,
-      truncated,
-      size: text.length,
-    });
-  }
-
-  return JSON.stringify({ results, errors }, null, 2);
-}
-
-/**
- * Canonical tool — `memory_load`. This is the default export so existing
- * import sites (`import memorySearch from './memory-search.js'`) keep
- * working; the renamed identity is expressed via the tool's `name`.
- */
-const memoryLoad = defineTool({
-  name: 'memory_load',
-  description: DESCRIPTION,
-  parameters: PARAMETERS,
-  isConcurrencySafe: () => true,
-  isReadOnly: () => true,
-  execute: executeLoad,
-});
-
-/**
- * Deprecated alias — `memory_search`. Kept so older prompts / saved tool
- * calls still resolve. Delegates to the same executor. Do not use for new
- * call sites. Emits a one-time console.warn on first invocation.
- */
-const _memSearchWarned = { v: false };
-async function executeLoadWithWarn(input, ctx) {
-  if (!_memSearchWarned.v) {
-    _memSearchWarned.v = true;
-    // eslint-disable-next-line no-console
-    console.warn('[deprecated] memory_search → memory_load. Use memory_load for path-based file loading; use memory_query for fuzzy keyword search.');
-  }
-  return executeLoad(input, ctx);
-}
-
-export const memorySearchAlias = defineTool({
-  name: 'memory_search',
-  description: 'DEPRECATED — use memory_load. Same params. Removal target: v0.2.0.',
-  parameters: PARAMETERS,
-  isConcurrencySafe: () => true,
-  isReadOnly: () => true,
-  execute: executeLoadWithWarn,
-});
-
-export default memoryLoad;

package/unify/tools/memory-trace.js

@@ -1,135 +0,0 @@
-/**
- * memory-trace.js — task-334f R6 §Δ24.3.
- *
- * Given a memory id, return the full entry (including sourceRef) plus the
- * original source messages referenced by sourceRef.msgIds / timeWindow.
- *
- * Hard guardrails (task-334f):
- *   - Results are returned to the current turn ONLY. Nothing is written back
- *     to memory; the extraction lane sees its own copy.
- *   - Does not do cross-group fan-out. A trace is anchored to one groupId.
- */
-
-import { defineTool } from './types.js';
-
-const MAX_BYTES = 64 * 1024;
-
-export default defineTool({
-  name: 'memory_trace',
-  description: `Trace a memory entry back to its original source messages.
-
-Use this when a recalled memory body is insufficient and you need the raw
-discussion. Returns the full memory entry (with sourceRef) plus the source
-messages from the group jsonl log.
-
-Parameters:
-  - memId (required): the memory id (from recall)
-  - expand: "full" (default, exact msgIds) | "window" (expand around timeWindow)
-
-Returns JSON: { memory, messages[], truncated? }.
-The result is NOT written back to memory — it is context for the current turn
-only.`,
-  parameters: {
-    type: 'object',
-    properties: {
-      memId:  { type: 'string', description: 'Memory entry id' },
-      expand: { type: 'string', enum: ['full', 'window'], default: 'full' },
-    },
-    required: ['memId'],
-  },
-  isConcurrencySafe: () => true,
-  isReadOnly: () => true,
-  async execute(input, ctx) {
-    const memId = input?.memId;
-    if (!memId || typeof memId !== 'string') {
-      return JSON.stringify({ error: 'memId required (string)' });
-    }
-    const expand = input?.expand === 'window' ? 'window' : 'full';
-
-    const store = ctx?.memoryShardStore;
-    if (!store) {
-      return JSON.stringify({ error: 'R6 memory shard store not initialised' });
-    }
-    const entry = store.get(memId);
-    if (!entry) {
-      return JSON.stringify({ error: `memory entry not found: ${memId}` });
-    }
-
-    const sourceRef = entry.sourceRef || null;
-    if (!sourceRef) {
-      return JSON.stringify({
-        memory: entry,
-        messages: [],
-        note: 'entry has no sourceRef (pure declaration)',
-      });
-    }
-
-    const coordinator = ctx?.coordinator;
-    const groupId = sourceRef.groupId;
-    if (!coordinator || !groupId) {
-      return JSON.stringify({
-        memory: entry,
-        messages: [],
-        note: 'no group coordinator available',
-      });
-    }
-
-    const group = typeof coordinator.openGroup === 'function'
-      ? coordinator.openGroup(groupId)
-      : null;
-    if (!group) {
-      return JSON.stringify({
-        memory: entry,
-        messages: [],
-        note: `group ${groupId} not resolvable`,
-      });
-    }
-
-    const messages = [];
-    let bytes = 0;
-    let truncated = false;
-
-    if (expand === 'full' && Array.isArray(sourceRef.msgIds) && sourceRef.msgIds.length) {
-      const targetSet = new Set(sourceRef.msgIds);
-      // Walk only the smallest overlapping range instead of streaming all.
-      const first = sourceRef.msgIds[0];
-      const last  = sourceRef.msgIds[sourceRef.msgIds.length - 1];
-      const iter = typeof group.readMessageRange === 'function'
-        ? group.readMessageRange(first, last)
-        : group.streamMessages();
-      for (const msg of iter) {
-        if (!targetSet.has(msg.id)) continue;
-        const chunk = estimateBytes(msg);
-        if (bytes + chunk > MAX_BYTES) { truncated = true; break; }
-        messages.push(msg);
-        bytes += chunk;
-      }
-    } else if (expand === 'window' && sourceRef.timeWindow) {
-      // timeWindow is "ISO..ISO"; best-effort textual compare works for ULIDs/ISO.
-      const [t0, t1] = String(sourceRef.timeWindow).split('..');
-      for (const msg of group.streamMessages()) {
-        const ts = msg.ts || '';
-        if (t0 && ts < t0) continue;
-        if (t1 && ts > t1) break;
-        const chunk = estimateBytes(msg);
-        if (bytes + chunk > MAX_BYTES) { truncated = true; break; }
-        messages.push(msg);
-        bytes += chunk;
-      }
-    }
-
-    return JSON.stringify({
-      memory: entry,
-      messages,
-      ...(truncated ? { truncated: true } : {}),
-    });
-  },
-});
-
-function estimateBytes(msg) {
-  try {
-    return Buffer.byteLength(JSON.stringify(msg), 'utf8');
-  } catch {
-    return 512;
-  }
-}

package/unify/tools/memory-write.js

@@ -1,113 +0,0 @@
-/**
- * memory-write.js — Write memory entries to the Yeaft memory store.
- *
- * Creates, updates, or deletes memory entries. Also supports
- * appending lines to MEMORY.md sections and overwriting the profile.
- */
-
-import { defineTool } from './types.js';
-
-export default defineTool({
-  name: 'MemoryWrite',
-  description: `Write to Yeaft's persistent memory system.
-
-Actions:
-- "write_entry" — create or update a memory entry (entries/*.md)
-- "delete_entry" — delete a memory entry by name
-- "write_profile" — overwrite the full MEMORY.md profile
-- "add_to_section" — append a line to a section in MEMORY.md
-
-Memory kinds: fact, preference, skill, lesson, context, relation
-Importance levels: low, normal, high, critical`,
-  parameters: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ['write_entry', 'delete_entry', 'write_profile', 'add_to_section'],
-        description: 'What memory operation to perform',
-      },
-      entry: {
-        type: 'object',
-        description: 'Memory entry data (for "write_entry")',
-        properties: {
-          name: { type: 'string', description: 'Entry name (will be slugified for filename)' },
-          kind: { type: 'string', enum: ['fact', 'preference', 'skill', 'lesson', 'context', 'relation'] },
-          scope: { type: 'string', description: 'Scope path, e.g. "global", "work/my-project"' },
-          tags: { type: 'array', items: { type: 'string' } },
-          importance: { type: 'string', enum: ['low', 'normal', 'high', 'critical'] },
-          content: { type: 'string', description: 'The memory content (markdown body)' },
-        },
-        required: ['name', 'content'],
-      },
-      name: {
-        type: 'string',
-        description: 'Entry name slug (for "delete_entry") or section name (for "add_to_section")',
-      },
-      content: {
-        type: 'string',
-        description: 'Content for "write_profile" or line to add for "add_to_section"',
-      },
-    },
-    required: ['action'],
-  },
-  isConcurrencySafe: () => false,
-  isReadOnly: () => false,
-  async execute(input, ctx) {
-    const memoryStore = ctx?.memoryStore;
-    if (!memoryStore) {
-      return JSON.stringify({ error: 'Memory system not initialized' });
-    }
-
-    try {
-      switch (input.action) {
-        case 'write_entry': {
-          if (!input.entry) return JSON.stringify({ error: 'entry is required for "write_entry"' });
-          if (!input.entry.name) return JSON.stringify({ error: 'entry.name is required' });
-          if (!input.entry.content) return JSON.stringify({ error: 'entry.content is required' });
-
-          const slug = memoryStore.writeEntry(input.entry);
-          return JSON.stringify({
-            success: true,
-            slug,
-            message: `Memory entry "${input.entry.name}" saved as ${slug}.md`,
-          });
-        }
-
-        case 'delete_entry': {
-          if (!input.name) return JSON.stringify({ error: 'name is required for "delete_entry"' });
-          const deleted = memoryStore.deleteEntry(input.name);
-          return JSON.stringify({
-            success: deleted,
-            message: deleted
-              ? `Deleted memory entry "${input.name}"`
-              : `Entry "${input.name}" not found`,
-          });
-        }
-
-        case 'write_profile': {
-          if (!input.content && input.content !== '') {
-            return JSON.stringify({ error: 'content is required for "write_profile"' });
-          }
-          memoryStore.writeProfile(input.content);
-          return JSON.stringify({ success: true, message: 'MEMORY.md updated' });
-        }
-
-        case 'add_to_section': {
-          if (!input.name) return JSON.stringify({ error: 'name (section) is required for "add_to_section"' });
-          if (!input.content) return JSON.stringify({ error: 'content (line) is required for "add_to_section"' });
-          memoryStore.addToSection(input.name, input.content);
-          return JSON.stringify({
-            success: true,
-            message: `Added to section "${input.name}" in MEMORY.md`,
-          });
-        }
-
-        default:
-          return JSON.stringify({ error: `Unknown action: ${input.action}` });
-      }
-    } catch (err) {
-      return JSON.stringify({ error: `Memory write failed: ${err.message}` });
-    }
-  },
-});

package/unify/user-memory.js

@@ -1,107 +0,0 @@
-/**
- * user-memory.js — R6 §Δ29 user-memory WS event handlers.
- *
- * Replaces the stub (task-334h) with real ingestion backed by the R6
- * shard-store. Writes land immediately in `~/.yeaft/user/memory/` with
- * a real entryId; the ack carries `reason: 'accepted'`.
- *
- * Wire shapes (frozen by R6 §Δ31.6 table; additive fields only):
- *
- *   inbound  (web → agent):  `unify_user_memory_write`
- *     { type, text, tags?, sourceRef?, requestId? }
- *
- *   outbound (agent → web):  `user_memory_updated`
- *     { type, entryId?, reason: 'accepted'|'noop',
- *       requestId?, pending?: boolean }
- *
- *   outbound (agent → web):  `user_memory_removed`
- *     { type, entryId, requestId? }
- */
-
-import {
-  getUserMemoryStore,
-  writeUserMemory,
-  removeUserMemory,
-} from './memory/user-memory-store.js';
-
-/** @type {(event:object)=>void | null} */
-let _sendUnifyEvent = null;
-
-/**
- * Install a send fn. Called once during session init from web-bridge.js.
- * Exposed so tests can swap in a collector without spinning up a session.
- */
-export function setUserMemorySender(fn) {
-  _sendUnifyEvent = (typeof fn === 'function') ? fn : null;
-}
-
-/**
- * WS handler: `unify_user_memory_write`.
- *
- * Validates the minimum shape (non-empty string `text`), writes to the
- * user-memory shard store, and replies with a `user_memory_updated` ack
- * carrying the real entryId. Never throws.
- *
- * @param {any} msg
- * @param {(event:object)=>void} [sendUnifyEvent] — optional override
- */
-export function handleUnifyUserMemoryWrite(msg, sendUnifyEvent) {
-  const send = sendUnifyEvent || _sendUnifyEvent;
-  if (!send) return;
-
-  const requestId = msg && typeof msg.requestId === 'string' ? msg.requestId : undefined;
-  const text = msg && typeof msg.text === 'string' ? msg.text : '';
-
-  if (!text || text.length === 0) {
-    try {
-      send({
-        type: 'user_memory_updated',
-        reason: 'noop',
-        pending: false,
-        ...(requestId ? { requestId } : {}),
-      });
-    } catch { /* best-effort */ }
-    return;
-  }
-
-  // Real ingestion via shard store.
-  const store = getUserMemoryStore();
-  const tags = Array.isArray(msg.tags) ? msg.tags : [];
-  const sourceRef = msg.sourceRef && typeof msg.sourceRef === 'object' ? msg.sourceRef : undefined;
-  const entryId = store ? writeUserMemory(store, { text, tags, sourceRef }) : null;
-
-  try {
-    send({
-      type: 'user_memory_updated',
-      reason: entryId ? 'accepted' : 'deferred',
-      pending: !entryId,
-      entryId: entryId || undefined,
-      ...(requestId ? { requestId } : {}),
-    });
-  } catch { /* best-effort */ }
-}
-
-/**
- * WS handler: `unify_user_memory_remove`.
- *
- * Removes the entry from the user-memory shard store and acks.
- */
-export function handleUnifyUserMemoryRemove(msg, sendUnifyEvent) {
-  const send = sendUnifyEvent || _sendUnifyEvent;
-  if (!send) return;
-
-  const requestId = msg && typeof msg.requestId === 'string' ? msg.requestId : undefined;
-  const entryId = msg && typeof msg.entryId === 'string' ? msg.entryId : null;
-
-  const store = getUserMemoryStore();
-  const removed = entryId && store ? removeUserMemory(store, entryId) : false;
-
-  try {
-    send({
-      type: 'user_memory_removed',
-      entryId,
-      pending: !removed,
-      ...(requestId ? { requestId } : {}),
-    });
-  } catch { /* best-effort */ }
-}