@yeaft/webchat-agent 0.1.410 → 0.1.412

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.410",
+  "version": "0.1.412",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/config.js

@@ -267,3 +267,39 @@ export function loadConfig(overrides = {}) {
 
   return config;
 }
+
+/**
+ * Load MCP server configuration from ~/.yeaft/mcp.json.
+ *
+ * JSON format (frontmatter parser can't handle nested objects):
+ * {
+ *   "servers": [
+ *     {
+ *       "name": "github",
+ *       "command": "npx",
+ *       "args": ["@mcp/github"],
+ *       "env": { "GITHUB_TOKEN": "ghp_..." }
+ *     }
+ *   ]
+ * }
+ *
+ * @param {string} yeaftDir — e.g. ~/.yeaft
+ * @returns {{ servers: object[] }}
+ */
+export function loadMCPConfig(yeaftDir) {
+  const mcpPath = join(yeaftDir, 'mcp.json');
+  if (!existsSync(mcpPath)) return { servers: [] };
+
+  try {
+    const raw = readFileSync(mcpPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.servers || !Array.isArray(parsed.servers)) {
+      return { servers: [] };
+    }
+    // Each server must have at least name + command
+    const valid = parsed.servers.filter(s => s.name && s.command);
+    return { servers: valid };
+  } catch {
+    return { servers: [] };
+  }
+}

package/unify/engine.js

@@ -22,6 +22,7 @@ import { buildSystemPrompt } from './prompts.js';
 import { LLMContextError } from './llm/adapter.js';
 import { recall } from './memory/recall.js';
 import { shouldConsolidate, consolidate } from './memory/consolidate.js';
+import { runStopHooks } from './stop-hooks.js';
 
 /** Maximum number of turns before the engine stops to prevent infinite loops. */
 const MAX_TURNS = 25;
@@ -67,16 +68,32 @@ export class Engine {
   /** @type {import('./memory/store.js').MemoryStore|null} */
   #memoryStore;
 
+  /** @type {import('./tools/registry.js').ToolRegistry|null} */
+  #toolRegistry;
+
+  /** @type {import('./skills.js').SkillManager|null} */
+  #skillManager;
+
+  /** @type {import('./mcp.js').MCPManager|null} */
+  #mcpManager;
+
+  /** @type {string|null} */
+  #yeaftDir;
+
   /**
    * @param {{
    *   adapter: import('./llm/adapter.js').LLMAdapter,
    *   trace: object,
    *   config: object,
    *   conversationStore?: import('./conversation/persist.js').ConversationStore,
-   *   memoryStore?: import('./memory/store.js').MemoryStore
+   *   memoryStore?: import('./memory/store.js').MemoryStore,
+   *   toolRegistry?: import('./tools/registry.js').ToolRegistry,
+   *   skillManager?: import('./skills.js').SkillManager,
+   *   mcpManager?: import('./mcp.js').MCPManager,
+   *   yeaftDir?: string,
    * }} params
    */
-  constructor({ adapter, trace, config, conversationStore, memoryStore }) {
+  constructor({ adapter, trace, config, conversationStore, memoryStore, toolRegistry, skillManager, mcpManager, yeaftDir }) {
     this.#adapter = adapter;
     this.#trace = trace;
     this.#config = config;
@@ -84,6 +101,10 @@ export class Engine {
     this.#traceId = randomUUID();
     this.#conversationStore = conversationStore || null;
     this.#memoryStore = memoryStore || null;
+    this.#toolRegistry = toolRegistry || null;
+    this.#skillManager = skillManager || null;
+    this.#mcpManager = mcpManager || null;
+    this.#yeaftDir = yeaftDir || null;
   }
 
   /**
@@ -106,10 +127,16 @@ export class Engine {
 
   /**
    * Get the list of registered tool definitions (for passing to the adapter).
+   * Prefers ToolRegistry (mode-aware) when available, falls back to legacy #tools Map.
    *
+   * @param {string} [mode]
    * @returns {import('./llm/adapter.js').UnifiedToolDef[]}
    */
-  #getToolDefs() {
+  #getToolDefs(mode) {
+    if (this.#toolRegistry) {
+      return this.#toolRegistry.getToolDefs(mode || 'chat');
+    }
+    // Legacy path: no mode filtering
     const defs = [];
     for (const [, tool] of this.#tools) {
       defs.push({
@@ -122,23 +149,58 @@ export class Engine {
   }
 
   /**
-   * Build the system prompt with memory and compact summary.
+   * Build the system prompt with memory, compact summary, and skill content.
    *
    * @param {string} mode
    * @param {{ profile?: string, entries?: object[] }} [memory]
    * @param {string} [compactSummary]
+   * @param {string} [prompt] — user prompt (for skill relevance matching)
    * @returns {string}
    */
-  #buildSystemPrompt(mode, memory, compactSummary) {
+  #buildSystemPrompt(mode, memory, compactSummary, prompt) {
+    // Get relevant skill content if SkillManager is wired
+    let skillContent = '';
+    if (this.#skillManager && prompt) {
+      skillContent = this.#skillManager.getRelevantPromptContent(prompt, mode);
+    }
+
+    // Get tool names from the appropriate source
+    const toolNames = this.#toolRegistry
+      ? this.#toolRegistry.getToolNames(mode || 'chat')
+      : Array.from(this.#tools.keys());
+
     return buildSystemPrompt({
       language: this.#config.language || 'en',
       mode,
-      toolNames: Array.from(this.#tools.keys()),
+      toolNames,
       memory,
       compactSummary,
+      skillContent,
     });
   }
 
+  /**
+   * Build the full tool context for Phase 5 tools.
+   *
+   * @param {AbortSignal} [signal]
+   * @param {string} [mode]
+   * @returns {object}
+   */
+  #buildToolContext(signal, mode) {
+    return {
+      signal,
+      yeaftDir: this.#yeaftDir,
+      cwd: process.cwd(),
+      mcpManager: this.#mcpManager,
+      skillManager: this.#skillManager,
+      memoryStore: this.#memoryStore,
+      conversationStore: this.#conversationStore,
+      adapter: this.#adapter,
+      config: this.#config,
+      mode,
+    };
+  }
+
   /**
    * Perform memory recall for a given prompt.
    *
@@ -262,7 +324,7 @@ export class Engine {
     }
 
     const compactSummary = this.#getCompactSummary();
-    const systemPrompt = this.#buildSystemPrompt(mode, memory, compactSummary);
+    const systemPrompt = this.#buildSystemPrompt(mode, memory, compactSummary, prompt);
 
     // Build conversation: existing messages + new user message
     const conversationMessages = [
@@ -270,7 +332,7 @@ export class Engine {
       { role: 'user', content: prompt },
     ];
 
-    const toolDefs = this.#getToolDefs();
+    const toolDefs = this.#getToolDefs(mode);
     let turnNumber = 0;
     let continueTurns = 0; // auto-continue counter
     let fullResponseText = '';
@@ -416,33 +478,66 @@ export class Engine {
       if (stopReason !== 'tool_use' || toolCalls.length === 0) {
         yield { type: 'turn_end', turnNumber, stopReason };
 
-        // ─── Post-query: Persist + Consolidate ────────────
-        this.#persistMessages(prompt, fullResponseText, mode, assistantMsg.toolCalls);
+        // ─── Post-query: StopHooks or Legacy ─────────────
+        if (this.#yeaftDir && this.#conversationStore) {
+          // Full pipeline: persist + consolidate + dream gate
+          const hookResult = await runStopHooks({
+            yeaftDir: this.#yeaftDir,
+            mode,
+            conversationStore: this.#conversationStore,
+            memoryStore: this.#memoryStore,
+            adapter: this.#adapter,
+            config: this.#config,
+            messages: conversationMessages,
+            trace: this.#trace,
+          });
+
+          if (hookResult.consolidated) {
+            yield { type: 'consolidate', archivedCount: 0, extractedCount: 0 };
+          }
+          if (hookResult.dreamTriggered) {
+            yield { type: 'dream_triggered' };
+          }
+        } else {
+          // Legacy path (no yeaftDir → use old behavior)
+          this.#persistMessages(prompt, fullResponseText, mode, assistantMsg.toolCalls);
 
-        const consolidated = await this.#maybeConsolidate();
-        if (consolidated && consolidated.archivedCount > 0) {
-          yield { type: 'consolidate', archivedCount: consolidated.archivedCount, extractedCount: consolidated.extractedCount };
+          const consolidated = await this.#maybeConsolidate();
+          if (consolidated && consolidated.archivedCount > 0) {
+            yield { type: 'consolidate', archivedCount: consolidated.archivedCount, extractedCount: consolidated.extractedCount };
+          }
         }
 
         break;
       }
 
       // Execute tool calls and feed results back
+      const toolCtx = this.#buildToolContext(signal, mode);
+
       for (const tc of toolCalls) {
-        const tool = this.#tools.get(tc.name);
         const toolStartTime = Date.now();
 
         let output;
         let isError = false;
 
-        if (!tool) {
+        // Resolve tool: prefer ToolRegistry, fallback to legacy #tools Map
+        const hasTool = this.#toolRegistry
+          ? this.#toolRegistry.has(tc.name)
+          : this.#tools.has(tc.name);
+
+        if (!hasTool) {
           output = `Error: unknown tool "${tc.name}"`;
           isError = true;
           yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: true };
         } else {
           try {
             yield { type: 'tool_start', id: tc.id, name: tc.name, input: tc.input };
-            output = await tool.execute(tc.input, { signal });
+            if (this.#toolRegistry) {
+              output = await this.#toolRegistry.execute(tc.name, tc.input, toolCtx);
+            } else {
+              const tool = this.#tools.get(tc.name);
+              output = await tool.execute(tc.input, { signal });
+            }
             yield { type: 'tool_end', id: tc.id, name: tc.name, output, isError: false };
           } catch (err) {
             output = `Error: ${err.message}`;
@@ -490,6 +585,7 @@ export class Engine {
    * @returns {string[]}
    */
   get toolNames() {
+    if (this.#toolRegistry) return this.#toolRegistry.names;
     return Array.from(this.#tools.keys());
   }
 
@@ -508,4 +604,16 @@ export class Engine {
   get memoryStore() {
     return this.#memoryStore;
   }
+
+  /** @returns {import('./tools/registry.js').ToolRegistry|null} */
+  get toolRegistry() { return this.#toolRegistry; }
+
+  /** @returns {import('./skills.js').SkillManager|null} */
+  get skillManager() { return this.#skillManager; }
+
+  /** @returns {import('./mcp.js').MCPManager|null} */
+  get mcpManager() { return this.#mcpManager; }
+
+  /** @returns {string|null} */
+  get yeaftDir() { return this.#yeaftDir; }
 }

package/unify/eval/cases/e2e.js

@@ -0,0 +1,154 @@
+/**
+ * eval/cases/e2e.js — End-to-end session eval cases
+ *
+ * Tests the full pipeline: prompt → recall → system prompt → LLM → tools → response.
+ * These cases verify that the integration holds together correctly.
+ */
+
+import { defineTool } from '../../tools/types.js';
+import {
+  noError,
+  containsText,
+  toolWasCalled,
+  toolNotCalled,
+  toolSucceeded,
+  turnCountInRange,
+  responseLengthInRange,
+  custom,
+} from '../runner.js';
+
+// ─── Mock Tools ──────────────────────────────────────────────
+
+const listProjectsTool = defineTool({
+  name: 'list_projects',
+  description: 'List all projects in the workspace.',
+  parameters: { type: 'object', properties: {} },
+  modes: ['chat', 'work'],
+  async execute() {
+    return JSON.stringify({
+      projects: ['my-app', 'shared-lib', 'docs-site'],
+    });
+  },
+});
+
+const getProjectInfoTool = defineTool({
+  name: 'get_project_info',
+  description: 'Get detailed information about a specific project.',
+  parameters: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Project name' },
+    },
+    required: ['name'],
+  },
+  modes: ['chat', 'work'],
+  async execute(input) {
+    const projects = {
+      'my-app': { name: 'my-app', language: 'TypeScript', framework: 'Express', tests: 142 },
+      'shared-lib': { name: 'shared-lib', language: 'TypeScript', framework: 'none', tests: 67 },
+      'docs-site': { name: 'docs-site', language: 'MDX', framework: 'Next.js', tests: 23 },
+    };
+    return JSON.stringify(projects[input.name] || { error: `Unknown project: ${input.name}` });
+  },
+});
+
+const e2eTools = [listProjectsTool, getProjectInfoTool];
+
+// ─── Eval Cases ──────────────────────────────────────────────
+
+export const e2eCases = [
+
+  // ─── Conversation Coherence ───────────────────────────
+
+  {
+    id: 'e2e-conversation-context',
+    suite: 'e2e',
+    description: 'Model should use conversation history for context',
+    prompt: 'What language is it written in?',
+    messages: [
+      { role: 'user', content: 'Tell me about the my-app project' },
+      { role: 'assistant', content: 'The my-app project is a TypeScript application built with Express. It has 142 tests.' },
+    ],
+    registryTools: e2eTools,
+    criteria: [
+      noError,
+      containsText('TypeScript', { weight: 8, id: 'remembers-language' }),
+      turnCountInRange(1, 2, { weight: 3 }),
+    ],
+  },
+
+  // ─── Tool Chain ───────────────────────────────────────
+
+  {
+    id: 'e2e-tool-chain-list-then-detail',
+    suite: 'e2e',
+    description: 'Model should list projects then get details about a specific one',
+    prompt: 'Show me all projects and tell me about the one with the most tests',
+    registryTools: e2eTools,
+    criteria: [
+      noError,
+      toolWasCalled('list_projects', { weight: 7 }),
+      toolWasCalled('get_project_info', { weight: 7 }),
+      containsText('my-app', { weight: 5, id: 'identifies-most-tested' }),
+      containsText('142', { weight: 5, id: 'mentions-test-count' }),
+    ],
+  },
+
+  // ─── Instruction Following ────────────────────────────
+
+  {
+    id: 'e2e-format-json',
+    suite: 'e2e',
+    description: 'Model should follow format instructions',
+    prompt: 'List three programming languages. Respond only with a JSON array of strings, nothing else.',
+    criteria: [
+      noError,
+      custom('valid-json-array', 'Response is a valid JSON array', 10, (result) => {
+        try {
+          // Try to extract JSON from the response
+          const text = result.fullText.trim();
+          const match = text.match(/\[[\s\S]*\]/);
+          if (!match) return { pass: false, score: 0, reason: 'No JSON array found' };
+          const arr = JSON.parse(match[0]);
+          const valid = Array.isArray(arr) && arr.length === 3 && arr.every(s => typeof s === 'string');
+          return { pass: valid, score: valid ? 1 : 0.5, reason: valid ? undefined : `Got: ${JSON.stringify(arr)}` };
+        } catch {
+          return { pass: false, score: 0, reason: 'Not valid JSON' };
+        }
+      }),
+    ],
+  },
+
+  // ─── Response Quality ─────────────────────────────────
+
+  {
+    id: 'e2e-concise-answer',
+    suite: 'e2e',
+    description: 'Model should give a concise answer for simple question',
+    prompt: 'What does the acronym HTTP stand for?',
+    criteria: [
+      noError,
+      containsText('Hypertext Transfer Protocol', { weight: 8 }),
+      responseLengthInRange(10, 500, { weight: 5, id: 'not-too-long' }),
+      toolNotCalled('search', { weight: 3 }),
+    ],
+  },
+
+  // ─── Language Handling ────────────────────────────────
+
+  {
+    id: 'e2e-chinese-response',
+    suite: 'e2e',
+    description: 'Model should respond in Chinese when prompted in Chinese',
+    prompt: '用中文简单解释什么是 API',
+    criteria: [
+      noError,
+      custom('has-chinese', 'Response contains Chinese characters', 8, (result) => {
+        const chinesePattern = /[\u4e00-\u9fff]/;
+        const hasChinese = chinesePattern.test(result.fullText);
+        return { pass: hasChinese, score: hasChinese ? 1 : 0 };
+      }),
+      containsText('API', { weight: 5 }),
+    ],
+  },
+];

package/unify/eval/cases/memory.js

@@ -0,0 +1,182 @@
+/**
+ * eval/cases/memory.js — Memory recall eval cases
+ *
+ * Tests the memory recall pipeline:
+ *   - Keyword extraction accuracy
+ *   - Scope + tag filtering
+ *   - LLM selection (when >7 candidates)
+ *   - Fingerprint caching
+ *   - Memory injection into system prompt
+ */
+
+import {
+  noError,
+  containsText,
+  custom,
+} from '../runner.js';
+
+// ─── Memory Recall Test Helpers ──────────────────────────────
+
+/**
+ * Create an engine with pre-loaded memory entries for eval.
+ * Uses a mock MemoryStore that returns predefined entries.
+ */
+function createMockMemoryStore(entries) {
+  return {
+    readProfile: () => 'User is a senior TypeScript developer who prefers functional programming.',
+    readEntry: (name) => entries.find(e => e.name === name) || null,
+    readSection: () => '',
+    listEntries: () => entries,
+    findByFilter: ({ scope, tags, limit = 15 }) => {
+      // Simple scoring: scope match + tag overlap
+      return entries
+        .map(e => {
+          let score = 0;
+          if (scope && e.scope === scope) score += 3;
+          if (scope && e.scope === 'global') score += 1;
+          if (tags) {
+            for (const t of tags) {
+              if (e.tags && e.tags.includes(t)) score += 1;
+            }
+          }
+          return { ...e, _score: score };
+        })
+        .filter(e => e._score > 0)
+        .sort((a, b) => b._score - a._score)
+        .slice(0, limit);
+    },
+    bumpFrequency: () => {},
+    search: (keyword) => entries.filter(e =>
+      e.content.toLowerCase().includes(keyword.toLowerCase()) ||
+      e.name.toLowerCase().includes(keyword.toLowerCase()),
+    ),
+    stats: () => ({ entryCount: entries.length, scopes: [], kinds: {} }),
+    writeEntry: () => 'test-entry',
+    writeEntries: () => [],
+    deleteEntry: () => true,
+    rebuildScopes: () => {},
+    addToSection: () => {},
+    writeProfile: () => {},
+    clear: () => {},
+  };
+}
+
+const sampleMemoryEntries = [
+  {
+    name: 'typescript-strict-mode',
+    kind: 'preference',
+    scope: 'global',
+    tags: ['typescript', 'config', 'strict'],
+    importance: 'high',
+    frequency: 5,
+    content: 'User always uses TypeScript strict mode with noImplicitAny enabled.',
+    created_at: '2026-03-01T00:00:00Z',
+    updated_at: '2026-04-01T00:00:00Z',
+  },
+  {
+    name: 'prefers-vitest',
+    kind: 'preference',
+    scope: 'work/claude-web-chat',
+    tags: ['testing', 'vitest', 'framework'],
+    importance: 'normal',
+    frequency: 3,
+    content: 'User prefers vitest over jest for testing. Uses vitest for all new projects.',
+    created_at: '2026-03-15T00:00:00Z',
+    updated_at: '2026-04-01T00:00:00Z',
+  },
+  {
+    name: 'error-handling-pattern',
+    kind: 'lesson',
+    scope: 'global',
+    tags: ['error-handling', 'typescript', 'patterns'],
+    importance: 'high',
+    frequency: 4,
+    content: 'Always use Result<T, E> pattern instead of throwing exceptions. Wrap external API calls in try-catch and return Result.',
+    created_at: '2026-02-01T00:00:00Z',
+    updated_at: '2026-04-01T00:00:00Z',
+  },
+  {
+    name: 'project-structure',
+    kind: 'context',
+    scope: 'work/claude-web-chat',
+    tags: ['architecture', 'project', 'monorepo'],
+    importance: 'normal',
+    frequency: 2,
+    content: 'Project uses monorepo with agent/, server/, web/ directories. Agent code is in agent/unify/.',
+    created_at: '2026-01-01T00:00:00Z',
+    updated_at: '2026-03-01T00:00:00Z',
+  },
+  {
+    name: 'functional-programming',
+    kind: 'preference',
+    scope: 'global',
+    tags: ['functional', 'programming', 'style'],
+    importance: 'normal',
+    frequency: 6,
+    content: 'User prefers functional programming: pure functions, immutable data, map/filter/reduce over loops.',
+    created_at: '2026-01-15T00:00:00Z',
+    updated_at: '2026-04-05T00:00:00Z',
+  },
+  {
+    name: 'api-design-rest',
+    kind: 'skill',
+    scope: 'global',
+    tags: ['api', 'rest', 'design'],
+    importance: 'normal',
+    frequency: 1,
+    content: 'REST API conventions: use plural nouns, HTTP methods for CRUD, 2xx success, 4xx client error, 5xx server error.',
+    created_at: '2026-02-15T00:00:00Z',
+    updated_at: '2026-02-15T00:00:00Z',
+  },
+];
+
+// ─── Eval Cases ──────────────────────────────────────────────
+
+export const memoryCases = [
+
+  // ─── Memory Injection Verification ────────────────────
+
+  {
+    id: 'memory-profile-injection',
+    suite: 'memory',
+    description: 'System prompt should include user profile from memory',
+    prompt: 'Help me with a coding task',
+    setupEngine: (engine) => {
+      // We can't directly inject memoryStore here since Engine uses private fields
+      // Instead, this eval verifies via the adapter call log that system prompt contains memory
+    },
+    criteria: [
+      noError,
+      custom('has-response', 'Model produces a response', 5, (result) => ({
+        pass: result.fullText.length > 0,
+        score: result.fullText.length > 0 ? 1 : 0,
+      })),
+    ],
+  },
+
+  // ─── Keyword Extraction (unit-level eval) ─────────────
+
+  {
+    id: 'memory-keyword-extraction',
+    suite: 'memory',
+    description: 'Keyword extraction produces relevant keywords',
+    prompt: 'How should I handle TypeScript errors in my Express API?',
+    criteria: [
+      noError,
+      // This is tested at unit level but verifiable here via recall event
+      custom('recall-event', 'Recall event emitted (if memory store provided)', 3, (result) => {
+        // Without a real memory store this won't emit recall, so we check gracefully
+        const recallEvent = result.events.find(e => e.type === 'recall');
+        return {
+          pass: true, // Always passes — it's informational
+          score: recallEvent ? 1 : 0.5,
+          reason: recallEvent ? `Recalled ${recallEvent.entryCount} entries` : 'No memory store configured',
+        };
+      }),
+    ],
+  },
+];
+
+// ─── Exported for direct import in unit tests ────────────────
+
+export { createMockMemoryStore, sampleMemoryEntries };

package/unify/eval/cases/skills.js

@@ -0,0 +1,51 @@
+/**
+ * eval/cases/skills.js — Skill matching eval cases
+ *
+ * Tests whether the engine correctly:
+ *   - Matches skills to relevant prompts
+ *   - Injects matched skill content into system prompt
+ *   - Does NOT inject irrelevant skills
+ *   - Handles mode filtering correctly
+ */
+
+import {
+  noError,
+  containsText,
+  doesNotContain,
+  custom,
+} from '../runner.js';
+
+// ─── Eval Cases ──────────────────────────────────────────────
+
+export const skillsCases = [
+
+  {
+    id: 'skill-match-basic',
+    suite: 'skills',
+    description: 'Engine should inject relevant skill into system prompt',
+    prompt: 'How do I set up testing for my project?',
+    criteria: [
+      noError,
+      // The actual skill injection happens via system prompt which we can check
+      // if the adapter captures it. For now, just verify no crash.
+      custom('produces-response', 'Model responds to the prompt', 5, (result) => ({
+        pass: result.fullText.length > 10,
+        score: result.fullText.length > 10 ? 1 : 0,
+      })),
+    ],
+  },
+
+  {
+    id: 'skill-no-false-positive',
+    suite: 'skills',
+    description: 'Engine should NOT inject unrelated skills',
+    prompt: 'What is the weather like?',
+    criteria: [
+      noError,
+      custom('produces-response', 'Model responds', 5, (result) => ({
+        pass: result.fullText.length > 0,
+        score: result.fullText.length > 0 ? 1 : 0,
+      })),
+    ],
+  },
+];