npm - @yeaft/webchat-agent - Versions diffs - 1.0.196 → 1.0.197 - Mend

@yeaft/webchat-agent 1.0.196 → 1.0.197

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/local-runtime/server/handlers/agent-output.js +27 -11
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +77 -77
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +1 -1
package/package.json +1 -1
package/yeaft/skills.js +36 -3
package/yeaft/web-bridge.js +89 -16

package/local-runtime/web/app.bundle.js.gz CHANGED Viewed

Binary file

package/local-runtime/web/index.html CHANGED Viewed

@@ -16,6 +16,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=898fc34b"></script>
+  <script type="module" src="app.bundle.js?v=aa7816be"></script>
 </body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.196",
+  "version": "1.0.197",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",

package/yeaft/skills.js CHANGED Viewed

@@ -458,6 +458,9 @@ export class SkillManager {
   /** @type {Map<string, { workspaceRoot: string, relativeRoot: string }>} */
   #secureWorkspaceByDir;
+  /** Hash of the effective loaded skill set, including prompt content. */
+  #snapshotHash = '';
   /**
    * @param {string | string[]} dirs — single directory (back-compat) or array of
    *   directories in priority order (lowest → highest). Falsy entries are
@@ -526,14 +529,16 @@ export class SkillManager {
    * tagged with `_tier` (from the constructor's `tierByDir` map, or the dir
    * basename as fallback) so consumers can show provenance.
    *
-   * @returns {{ loaded: number, errors: string[] }}
+   * @returns {{ loaded: number, errors: string[], changed: boolean }}
    */
   load() {
+    const previousHash = this.#snapshotHash;
     this.#skills.clear();
     const allErrors = [];
     if (this.#skillsDirs.length === 0) {
-      return { loaded: 0, errors: [] };
+      this.#snapshotHash = this.#computeSnapshotHash();
+      return { loaded: 0, errors: [], changed: this.#snapshotHash !== previousHash };
     }
     for (const dir of this.#skillsDirs) {
@@ -554,7 +559,33 @@ export class SkillManager {
       allErrors.push(...errors);
     }
-    return { loaded: this.#skills.size, errors: allErrors };
+    this.#snapshotHash = this.#computeSnapshotHash();
+    return {
+      loaded: this.#skills.size,
+      errors: allErrors,
+      changed: this.#snapshotHash !== previousHash,
+    };
+  }
+  #computeSnapshotHash() {
+    const records = [...this.#skills.values()]
+      .sort((a, b) => String(a.name).localeCompare(String(b.name)))
+      .map(skill => ({
+        name: skill.name || '',
+        description: skill.description || '',
+        trigger: skill.trigger || '',
+        mode: skill.mode || 'both',
+        category: skill.category || '',
+        platforms: skill.platforms || [],
+        keywords: skill.keywords || [],
+        content: skill.content || '',
+        source: skill._source || '',
+        path: skill._path || '',
+        tier: skill._tier || '',
+        references: skill._references || [],
+        templates: skill._templates || [],
+      }));
+    return JSON.stringify(records);
   }
   /**
@@ -746,6 +777,7 @@ export class SkillManager {
       _path: filePath,
       _tier: userTier,
     });
+    this.#snapshotHash = this.#computeSnapshotHash();
     return filename;
   }
@@ -783,6 +815,7 @@ export class SkillManager {
     }
     this.#skills.delete(name);
+    this.#snapshotHash = this.#computeSnapshotHash();
     return true;
   }

package/yeaft/web-bridge.js CHANGED Viewed

@@ -80,6 +80,7 @@ const LEGACY_SKILL_COMMAND_PREFIX = 'skill:';
 const YEAFT_SKILL_COMMAND_PREFIX = 'yeaft-skills:';
 const PROJECT_SKILL_TIERS = new Set(['project', 'project-claude', 'project-codex']);
 const BASE_RUNTIME_KEY = '__base__';
+const SKILL_RELOAD_INTERVAL_MS = 2_000;
 /**
  * Live AskUser requests. They are Session-scoped runtime state rather than a
@@ -591,6 +592,8 @@ const projectRuntimes = new Map();
 /** @type {Map<string, Promise<any>>} */
 const baseRuntimeLoadPromises = new Map();
 let activeRuntimeKey = BASE_RUNTIME_KEY;
+let skillReloadTimer = null;
+let skillReloadRunning = false;
 function replaceSessionMcpTools(mcpManager) {
   if (!session?.toolRegistry || typeof session.toolRegistry.replaceMcpTools !== 'function') {
@@ -651,6 +654,7 @@ function activateProjectRuntime(runtime) {
 }
 async function shutdownProjectRuntimes() {
+  stopSkillHotReload();
   const runtimes = Array.from(projectRuntimes.values());
   projectRuntimes.clear();
   projectRuntimeLoadPromises.clear();
@@ -936,7 +940,6 @@ let yeaftConversationId = null;
  *  creates/replaces the virtual Yeaft conversation id so `/` autocomplete never
  *  falls back to built-ins while full Session metadata is still loading. */
 let lastYeaftSlashCommandSnapshot = null;
-let lastYeaftGeneratedSlashCommands = new Set();
 /** @type {Map<string, Promise<any>>} */
 const projectRuntimeLoadPromises = new Map();
@@ -2181,6 +2184,7 @@ export function buildMergedSkillSlashCommands(skillManagers = []) {
 function sendSkillSlashCommandsUpdate({ conversationId, slashCommands, slashCommandDescriptions }) {
   sendToServer({
     type: 'slash_commands_update',
+    commandSet: 'yeaft',
     agentId: ctx.AGENT_ID || ctx.agentId || null,
     conversationId,
     slashCommands,
@@ -2221,21 +2225,10 @@ export function preloadYeaftSkillSlashCommands() {
 function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   const managers = [sessionLike?.skillManager, ...extraSkillManagers].filter(Boolean);
-  const { commands, descriptions } = buildMergedSkillSlashCommands(managers);
-  const isYeaftSkillCommand = (cmd) => typeof cmd === 'string'
-    && (lastYeaftGeneratedSlashCommands.has(cmd)
-      || cmd.startsWith(LEGACY_SKILL_COMMAND_PREFIX)
-      || cmd.startsWith(YEAFT_SKILL_COMMAND_PREFIX));
-  const nonSkillCommands = (ctx.slashCommands || []).filter(cmd => !isYeaftSkillCommand(cmd));
-  const slashCommands = [...new Set([...nonSkillCommands, ...commands])];
-  const slashCommandDescriptions = Object.fromEntries(
-    Object.entries(ctx.slashCommandDescriptions || {})
-      .filter(([cmd]) => !isYeaftSkillCommand(cmd))
-  );
-  Object.assign(slashCommandDescriptions, descriptions);
-  ctx.slashCommands = slashCommands;
-  ctx.slashCommandDescriptions = slashCommandDescriptions;
-  lastYeaftGeneratedSlashCommands = new Set(commands);
+  const { commands: slashCommands, descriptions: slashCommandDescriptions } = buildMergedSkillSlashCommands(managers);
+  // Yeaft owns an isolated command catalogue. Reusing ctx's Claude Chat
+  // commands made unsupported entries such as /compact and /mcp appear in a
+  // Session even though the Yeaft engine only parses effort and Skill prefixes.
   lastYeaftSlashCommandSnapshot = { slashCommands, slashCommandDescriptions };
   sendSkillSlashCommandsUpdate({
     conversationId: yeaftConversationId || '__preload__',
@@ -2244,6 +2237,81 @@ function broadcastSkillSlashCommands(sessionLike, extraSkillManagers = []) {
   });
 }
+function skillManagersForHotReload() {
+  const managers = new Set();
+  if (session?.skillManager) managers.add(session.skillManager);
+  for (const runtime of projectRuntimes.values()) {
+    if (runtime?.skillManager) managers.add(runtime.skillManager);
+  }
+  return [...managers];
+}
+function reloadActiveSkills() {
+  if (skillReloadRunning) return { changed: false, loaded: 0, errors: [] };
+  skillReloadRunning = true;
+  try {
+    let changed = false;
+    let loaded = 0;
+    const errors = [];
+    const changedManagers = new Set();
+    const managers = skillManagersForHotReload();
+    for (const manager of managers) {
+      if (typeof manager?.load !== 'function') continue;
+      const result = manager.load();
+      if (result?.changed) {
+        changed = true;
+        changedManagers.add(manager);
+      }
+      loaded += Number(result?.loaded) || 0;
+      errors.push(...(result?.errors || []));
+    }
+    if (changed) {
+      if (session?.status && changedManagers.has(session.skillManager)) {
+        session.status.skills = session.skillManager?.size || 0;
+      }
+      for (const runtime of projectRuntimes.values()) {
+        if (runtime?.status && changedManagers.has(runtime.skillManager)) {
+          runtime.status.skills = runtime.skillManager?.size || 0;
+        }
+      }
+      if (activeRuntimeKey === BASE_RUNTIME_KEY) {
+        broadcastSkillSlashCommands(session);
+      } else {
+        const runtime = projectRuntimes.get(activeRuntimeKey);
+        broadcastSkillSlashCommands(session, runtime?.skillManager ? [runtime.skillManager] : []);
+      }
+      const activeRuntime = activeRuntimeKey === BASE_RUNTIME_KEY ? null : projectRuntimes.get(activeRuntimeKey);
+      const activeStatus = activeRuntime ? mergedStatusForProjectRuntime(activeRuntime) : session?.status;
+      hydrateYeaftStatusFromSession(
+        activeStatus && session ? { ...session, status: activeStatus } : session,
+        { reason: 'skills_hot_reload', emitEvent: true },
+      );
+    }
+    if (errors.length > 0) {
+      console.warn(`[Yeaft] skill hot reload completed with ${errors.length} error(s):`, errors.join('; '));
+    }
+    return { changed, loaded, errors };
+  } finally {
+    skillReloadRunning = false;
+  }
+}
+function startSkillHotReload() {
+  if (skillReloadTimer) return;
+  skillReloadTimer = setInterval(() => {
+    try { reloadActiveSkills(); }
+    catch (err) { console.warn('[Yeaft] skill hot reload failed:', err?.message || err); }
+  }, SKILL_RELOAD_INTERVAL_MS);
+  skillReloadTimer.unref?.();
+}
+function stopSkillHotReload() {
+  if (!skillReloadTimer) return;
+  clearInterval(skillReloadTimer);
+  skillReloadTimer = null;
+  skillReloadRunning = false;
+}
 async function loadBaseRuntime() {
   if (!session) return null;
   const yeaftDir = ctx.CONFIG?.yeaftDir || session.yeaftDir || DEFAULT_YEAFT_DIR;
@@ -2267,6 +2335,7 @@ async function loadBaseRuntime() {
   } else {
     broadcastSkillSlashCommands(session);
   }
+  startSkillHotReload();
   hydrateYeaftStatusFromSession(session, { reason: 'base_runtime_skills', emitEvent: true });
   if (mcpConfig.servers.length > 0) {
@@ -2341,6 +2410,7 @@ async function loadProjectRuntime(workDir) {
   // Skill metadata is available after the filesystem scan; publish it before
   // any MCP server startup so autocomplete does not wait on external processes.
   activateProjectRuntime(runtime);
+  startSkillHotReload();
   if (mcpConfig.servers.length > 0) {
     mcpStatus = await mcpManager.connectAll(mcpConfig.servers);
     runtime.mcpStatus = mcpStatus;
@@ -6716,6 +6786,9 @@ export const __testHooks = {
   preloadYeaftSkillSlashCommandsForTest() {
     return broadcastSkillSlashCommands(session);
   },
+  reloadActiveSkillsForTest() {
+    return reloadActiveSkills();
+  },
   loadAndBroadcastYeaftSkillSlashCommandsForTest() {
     return loadAndBroadcastYeaftSkillSlashCommands();
   },