@yeaft/webchat-agent 0.1.410 → 0.1.411

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.410",
+  "version": "0.1.411",
   "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/index.js

@@ -5,7 +5,7 @@
  */
 
 export { initYeaftDir, DEFAULT_YEAFT_DIR } from './init.js';
-export { loadConfig, parseFrontmatter } from './config.js';
+export { loadConfig, parseFrontmatter, loadMCPConfig } from './config.js';
 export { DebugTrace, NullTrace, createTrace } from './debug-trace.js';
 export {
   LLMAdapter,
@@ -36,4 +36,5 @@ export { MCPManager, createMCPManager } from './mcp.js';
 export { SkillManager, createSkillManager, parseSkill, serializeSkill } from './skills.js';
 export { defineTool } from './tools/types.js';
 export { ToolRegistry, createEmptyRegistry } from './tools/registry.js';
+export { loadSession } from './session.js';
 

package/unify/prompts.js

@@ -61,6 +61,7 @@ export function buildSystemPrompt({
   toolNames = [],
   memory,
   compactSummary,
+  skillContent,
 } = {}) {
   // Fallback to English for unknown languages
   const lang = PROMPTS[language] || PROMPTS.en;
@@ -81,6 +82,11 @@ export function buildSystemPrompt({
     parts.push(lang.tools(toolNames.join(', ')));
   }
 
+  // ─── Skills Section ─────────────────────────────────────
+  if (skillContent) {
+    parts.push(skillContent);
+  }
+
   // ─── Memory Section ─────────────────────────────────────
   if (memory && (memory.profile || (memory.entries && memory.entries.length > 0))) {
     const memoryParts = [lang.memoryHeader];

package/unify/session.js

@@ -0,0 +1,191 @@
+/**
+ * session.js — Session orchestrator for Yeaft Unify
+ *
+ * Single entry point: loadSession(options?) → Session
+ *
+ * Wires all subsystems together:
+ *   initYeaftDir → loadConfig → createTrace → createLLMAdapter →
+ *   ConversationStore → MemoryStore → SkillManager → MCPManager →
+ *   ToolRegistry → Engine → Session
+ *
+ * The ~/.yeaft/ directory is the agent's persistent workspace.
+ * loadSession() loads (or initializes) this workspace and returns
+ * a fully wired Session ready for queries.
+ */
+
+import { initYeaftDir } from './init.js';
+import { loadConfig, loadMCPConfig } from './config.js';
+import { createTrace } from './debug-trace.js';
+import { createLLMAdapter } from './llm/adapter.js';
+import { ConversationStore } from './conversation/persist.js';
+import { MemoryStore } from './memory/store.js';
+import { SkillManager, createSkillManager } from './skills.js';
+import { MCPManager } from './mcp.js';
+import { createEmptyRegistry } from './tools/registry.js';
+import { Engine } from './engine.js';
+import { join } from 'path';
+
+// Built-in tools
+import mcpTools from './tools/mcp-tools.js';
+import skillTool from './tools/skill.js';
+import enterWorktree from './tools/enter-worktree.js';
+import exitWorktree from './tools/exit-worktree.js';
+
+/**
+ * @typedef {Object} SessionOptions
+ * @property {string} [dir] — Yeaft data directory override (default: ~/.yeaft)
+ * @property {string} [model] — Model override
+ * @property {string} [language] — Language override ('en' | 'zh')
+ * @property {boolean} [debug] — Debug mode override
+ * @property {boolean} [skipMCP] — Skip MCP server connections (faster startup)
+ * @property {boolean} [skipSkills] — Skip skill loading
+ * @property {object[]} [extraTools] — Additional ToolDef objects to register
+ * @property {object} [configOverrides] — Additional config overrides
+ */
+
+/**
+ * @typedef {Object} Session
+ * @property {Engine} engine — The wired engine, ready for .query()
+ * @property {object} config — Resolved configuration
+ * @property {ConversationStore} conversationStore — Conversation persistence
+ * @property {MemoryStore} memoryStore — Memory persistence
+ * @property {SkillManager} skillManager — Skill manager
+ * @property {MCPManager} mcpManager — MCP manager
+ * @property {import('./tools/registry.js').ToolRegistry} toolRegistry — Tool registry
+ * @property {import('./debug-trace.js').DebugTrace|import('./debug-trace.js').NullTrace} trace
+ * @property {string} yeaftDir — Resolved data directory path
+ * @property {{ skills: number, mcpServers: string[], mcpFailed: object[], tools: number }} status
+ * @property {() => Promise<void>} shutdown — Graceful shutdown
+ */
+
+/**
+ * Load (or initialize) a Yeaft session.
+ *
+ * This is the main entry point for using Yeaft programmatically.
+ * It creates the directory structure if needed, loads config, connects
+ * to services, registers tools, and returns a ready-to-use Session.
+ *
+ * @param {SessionOptions} [options={}]
+ * @returns {Promise<Session>}
+ */
+export async function loadSession(options = {}) {
+  const {
+    dir,
+    model,
+    language,
+    debug,
+    skipMCP = false,
+    skipSkills = false,
+    extraTools = [],
+    configOverrides = {},
+  } = options;
+
+  // ─── 1. Load config (determines yeaftDir) ──────────────
+  const overrides = { ...configOverrides };
+  if (dir) overrides.dir = dir;
+  if (model) overrides.model = model;
+  if (language) overrides.language = language;
+  if (debug !== undefined) overrides.debug = debug;
+
+  const config = loadConfig(overrides);
+  const yeaftDir = config.dir;
+
+  // ─── 2. Ensure directory structure ─────────────────────
+  initYeaftDir(yeaftDir);
+
+  // ─── 3. Create debug trace ─────────────────────────────
+  const trace = createTrace({
+    enabled: config.debug,
+    dbPath: join(yeaftDir, 'debug.db'),
+  });
+
+  // ─── 4. Create LLM adapter ────────────────────────────
+  const adapter = await createLLMAdapter(config);
+
+  // ─── 5. Create stores ──────────────────────────────────
+  const conversationStore = new ConversationStore(yeaftDir);
+  const memoryStore = new MemoryStore(yeaftDir);
+
+  // ─── 6. Load skills ────────────────────────────────────
+  let skillManager;
+  if (skipSkills) {
+    skillManager = new SkillManager(yeaftDir);
+    // Don't call .load() — empty skill manager
+  } else {
+    skillManager = createSkillManager(yeaftDir);
+  }
+
+  // ─── 7. Connect MCP servers ────────────────────────────
+  const mcpConfig = loadMCPConfig(yeaftDir);
+  const mcpManager = new MCPManager();
+  let mcpStatus = { connected: [], failed: [] };
+
+  if (!skipMCP && mcpConfig.servers.length > 0) {
+    mcpStatus = await mcpManager.connectAll(mcpConfig.servers);
+  }
+
+  // ─── 8. Build tool registry ────────────────────────────
+  const toolRegistry = createEmptyRegistry();
+
+  // Register built-in tools
+  for (const tool of mcpTools) {
+    toolRegistry.register(tool);
+  }
+  toolRegistry.register(skillTool);
+  toolRegistry.register(enterWorktree);
+  toolRegistry.register(exitWorktree);
+
+  // Register any extra tools from caller
+  for (const tool of extraTools) {
+    toolRegistry.register(tool);
+  }
+
+  // ─── 9. Create engine (wires everything) ───────────────
+  const engine = new Engine({
+    adapter,
+    trace,
+    config,
+    conversationStore,
+    memoryStore,
+    toolRegistry,
+    skillManager,
+    mcpManager,
+    yeaftDir,
+  });
+
+  // ─── 10. Build session ─────────────────────────────────
+  const status = {
+    skills: skillManager.size,
+    mcpServers: mcpStatus.connected,
+    mcpFailed: mcpStatus.failed,
+    tools: toolRegistry.size,
+  };
+
+  /** Graceful shutdown: disconnect MCP, close trace DB. */
+  async function shutdown() {
+    try {
+      await mcpManager.disconnectAll();
+    } catch {
+      // Best-effort cleanup
+    }
+    try {
+      trace.close();
+    } catch {
+      // Trace might not have close() (NullTrace)
+    }
+  }
+
+  return {
+    engine,
+    config,
+    conversationStore,
+    memoryStore,
+    skillManager,
+    mcpManager,
+    toolRegistry,
+    trace,
+    yeaftDir,
+    status,
+    shutdown,
+  };
+}