@yeaft/webchat-agent 1.0.419 → 1.0.421

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.419",
+  "version": "1.0.421",
   "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/workbench/file-reference-resolver.js

@@ -0,0 +1,115 @@
+import { readdir, stat } from 'node:fs/promises';
+import { basename, join, relative, resolve } from 'node:path';
+import { platform } from 'node:os';
+import ctx from '../context.js';
+import { resolveAndValidatePath } from './utils.js';
+import { sendWorkbenchResult } from './request-routing.js';
+
+const MAX_REFERENCES = 32;
+const MAX_SCANNED_ENTRIES = 5000;
+const MAX_DEPTH = 10;
+const SKIP_DIRS = new Set(['.git', 'node_modules', '__pycache__', '.next', '.nuxt', 'dist', 'build', '.cache', 'bin', 'obj']);
+
+async function isFile(path) {
+  try { return (await stat(path)).isFile(); } catch { return false; }
+}
+
+function comparable(value) {
+  const normalized = String(value || '').replaceAll('\\', '/');
+  return platform() === 'win32' ? normalized.toLowerCase() : normalized;
+}
+
+async function findUniqueBasenames(workDir, requestedPaths, {
+  maxScannedEntries = MAX_SCANNED_ENTRIES,
+  maxDepth = MAX_DEPTH,
+  readDirectory = readdir,
+} = {}) {
+  const targets = new Set(requestedPaths.map(path => comparable(basename(path))).filter(Boolean));
+  const matches = new Map([...targets].map(target => [target, []]));
+  if (targets.size === 0) return { matches, complete: true };
+  let scanned = 0;
+  let complete = true;
+
+  async function walk(dir, depth) {
+    if (depth > maxDepth) {
+      complete = false;
+      return;
+    }
+    let entries;
+    try {
+      entries = await readDirectory(dir, { withFileTypes: true });
+    } catch {
+      complete = false;
+      return;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (scanned >= maxScannedEntries) {
+        complete = false;
+        return;
+      }
+      scanned += 1;
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) await walk(join(dir, entry.name), depth + 1);
+      } else if (entry.isFile()) {
+        const target = comparable(entry.name);
+        const found = matches.get(target);
+        if (found && found.length < 2) found.push(join(dir, entry.name));
+      }
+    }
+  }
+
+  await walk(resolve(workDir), 0);
+  return { matches, complete };
+}
+
+export async function resolveFileReferences(references, workDir, scanOptions) {
+  const unique = [...new Set((Array.isArray(references) ? references : [])
+    .map(value => typeof value === 'string' ? value.trim() : '')
+    .filter(Boolean))].slice(0, MAX_REFERENCES);
+  const exactMatches = await Promise.all(unique.map(async requestedPath => {
+    const exactPath = resolveAndValidatePath(requestedPath, workDir);
+    return await isFile(exactPath) ? exactPath : null;
+  }));
+  const unresolved = unique.filter((_path, index) => !exactMatches[index]);
+  const basenameScan = await findUniqueBasenames(workDir, unresolved, scanOptions);
+  const root = resolve(workDir);
+
+  return unique.flatMap((requestedPath, index) => {
+    const matches = basenameScan.matches.get(comparable(basename(requestedPath))) || [];
+    const fallbackPath = basenameScan.complete && matches.length === 1 ? matches[0] : null;
+    const matchedPath = exactMatches[index] || fallbackPath;
+    if (!matchedPath) return [];
+    return [{
+      requestedPath,
+      resolvedPath: relative(root, matchedPath).replaceAll('\\', '/') || basename(matchedPath),
+    }];
+  });
+}
+
+export async function handleResolveFileReferences(msg) {
+  const { conversationId, requestId, _requestUserId, _requestClientId } = msg;
+  const conv = ctx.conversations.get(conversationId);
+  const workDir = msg.workDir || conv?.workDir || ctx.CONFIG.workDir;
+  try {
+    const references = await resolveFileReferences(msg.references, workDir);
+    sendWorkbenchResult(ctx, msg, {
+      type: 'file_references_resolved',
+      conversationId,
+      requestId,
+      _requestUserId,
+      _requestClientId,
+      references,
+    });
+  } catch (error) {
+    sendWorkbenchResult(ctx, msg, {
+      type: 'file_references_resolved',
+      conversationId,
+      requestId,
+      _requestUserId,
+      _requestClientId,
+      references: [],
+      error: error.message,
+    });
+  }
+}

package/workbench.js

@@ -16,5 +16,6 @@ export {
 } from './workbench/git-ops.js';
 
 export { handleFileSearch } from './workbench/file-search.js';
+export { handleResolveFileReferences } from './workbench/file-reference-resolver.js';
 
 export { handleTransferFiles } from './workbench/transfer.js';

package/yeaft/skills.js

@@ -110,13 +110,35 @@ export function matchesPlatform(platforms) {
  * @param {string} [filename] — source filename (for name fallback)
  * @returns {Skill|null}
  */
+function skillFrontmatterStart(raw) {
+  if (!raw) return -1;
+
+  let cursor = raw.charCodeAt(0) === 0xFEFF ? 1 : 0;
+  if (raw.startsWith('---', cursor)) return cursor;
+
+  let sawComment = false;
+  while (cursor < raw.length) {
+    while (cursor < raw.length && /\s/.test(raw[cursor])) cursor++;
+    if (!raw.startsWith('<!--', cursor)) break;
+    const commentEnd = raw.indexOf('-->', cursor + 4);
+    if (commentEnd === -1) return -1;
+    sawComment = true;
+    cursor = commentEnd + 3;
+  }
+
+  if (!sawComment) return -1;
+  while (cursor < raw.length && /\s/.test(raw[cursor])) cursor++;
+  return raw.startsWith('---', cursor) ? cursor : -1;
+}
+
 export function parseSkill(raw, filename = '') {
-  if (!raw || !raw.startsWith('---')) return null;
+  const startIdx = skillFrontmatterStart(raw);
+  if (startIdx === -1) return null;
 
-  const endIdx = raw.indexOf('\n---', 3);
+  const endIdx = raw.indexOf('\n---', startIdx + 3);
   if (endIdx === -1) return null;
 
-  const frontmatter = raw.slice(4, endIdx).trim();
+  const frontmatter = raw.slice(startIdx + 4, endIdx).trim();
   const body = raw.slice(endIdx + 4).trim();
 
   const skill = {
@@ -229,6 +251,10 @@ function shouldIgnorePath(candidatePath, ignorePaths) {
   return ignorePaths.some(ignorePath => pathIsInside(candidatePath, ignorePath));
 }
 
+function displaySkillPath(relativePath) {
+  return String(relativePath || '').replaceAll('\\', '/');
+}
+
 function discoverSkills(rootDir, subPath = '', opts = {}) {
   const dir = subPath ? join(rootDir, subPath) : rootDir;
   const ignorePaths = Array.isArray(opts.ignorePaths) ? opts.ignorePaths : [];
@@ -264,11 +290,11 @@ function discoverSkills(rootDir, subPath = '', opts = {}) {
             skill.category = skill.category || subPath.split(sep).join('/');
           }
           skills.push(skill);
-        } else {
-          errors.push(`Failed to parse skill: ${relPath}`);
+        } else if (skillFrontmatterStart(raw) !== -1) {
+          errors.push(`Failed to parse skill: ${displaySkillPath(relPath)}`);
         }
       } catch (err) {
-        errors.push(`Error loading ${relPath}: ${err.message}`);
+        errors.push(`Error loading ${displaySkillPath(relPath)}: ${err.message}`);
       }
     } else if (entry.isDirectory()) {
       // Check for SKILL.md inside this directory
@@ -290,10 +316,10 @@ function discoverSkills(rootDir, subPath = '', opts = {}) {
             skill._templates = listSubdirFiles(join(entryPath, 'templates'));
             skills.push(skill);
           } else {
-            errors.push(`Failed to parse skill: ${relPath}/SKILL.md`);
+            errors.push(`Failed to parse skill: ${displaySkillPath(relPath)}/SKILL.md`);
           }
         } catch (err) {
-          errors.push(`Error loading ${relPath}/SKILL.md: ${err.message}`);
+          errors.push(`Error loading ${displaySkillPath(relPath)}/SKILL.md: ${err.message}`);
         }
       } else {
         // No SKILL.md — treat as category directory, recurse
@@ -329,7 +355,9 @@ function discoverWorkspaceSkills(workspaceRoot, skillsRelativeRoot, subPath = ''
       if (!read || read.truncated) continue;
       const skill = parseSkill(read.buffer.toString('utf8'), entry.name);
       if (!skill?.name) {
-        errors.push(`Failed to parse skill: ${relPath}`);
+        if (skillFrontmatterStart(read.buffer.toString('utf8')) !== -1) {
+          errors.push(`Failed to parse skill: ${displaySkillPath(relPath)}`);
+        }
         continue;
       }
       skill._source = 'file';
@@ -352,7 +380,7 @@ function discoverWorkspaceSkills(workspaceRoot, skillsRelativeRoot, subPath = ''
       if (!read || read.truncated) continue;
       const skill = parseSkill(read.buffer.toString('utf8'), entry.name);
       if (!skill?.name) {
-        errors.push(`Failed to parse skill: ${relPath}/SKILL.md`);
+        errors.push(`Failed to parse skill: ${displaySkillPath(relPath)}/SKILL.md`);
         continue;
       }
       skill._source = 'directory';