amalgm 0.1.112 → 0.1.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.112",
+  "version": "0.1.113",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/fs/rest.js

@@ -9,6 +9,7 @@ const path = require('path');
 const { notifyProjectContextPathChanged } = require('../project-context/store');
 const { AMALGM_DIR } = require('../config');
 const { appendStateEvent } = require('../state/events');
+const { createFsSearchHandler } = require('./search');
 
 const TEXT_EXTENSIONS = new Set([
   'txt', 'md', 'json', 'js', 'ts', 'tsx', 'jsx', 'py', 'html', 'css',
@@ -299,6 +300,8 @@ function statusForError(error, fallbackStatus = 500) {
   return fallbackStatus;
 }
 
+const handleSearch = createFsSearchHandler({ resolveSafePath });
+
 function classifyFile(targetPath) {
   const ext = path.extname(targetPath).slice(1).toLowerCase();
   return {
@@ -765,6 +768,7 @@ module.exports = {
   handleMkdir,
   handleRead,
   handleRename,
+  handleSearch,
   handleWrite,
   _private: {
     buildFilesResource,

package/runtime/scripts/amalgm-mcp/fs/search.js

@@ -0,0 +1,387 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { performance } = require('perf_hooks');
+
+const DEFAULT_SEARCH_BUDGET_MS = 800;
+const DEFAULT_SEARCH_LIMIT = 40;
+const DEFAULT_SEARCH_MAX_ENTRIES = 120000;
+const SKILL_DESCRIPTION_PREVIEW_BYTES = 4096;
+
+const SEARCH_IGNORE_DIRS = new Set([
+  '.git',
+  '.next',
+  '.next-electron-dev',
+  '.turbo',
+  '.cache',
+  '.agents',
+  '.vercel',
+  '.pnpm-store',
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  '.parcel-cache',
+  '.vite',
+  'out',
+]);
+
+function toPosix(value) {
+  return String(value || '').replace(/\\/g, '/');
+}
+
+function pathBasename(filePath) {
+  const normalized = toPosix(filePath);
+  return normalized.split('/').filter(Boolean).pop() || normalized;
+}
+
+function normalizeForFuzzy(value) {
+  return String(value || '').toLowerCase().replace(/[-_./\s]+/g, '');
+}
+
+function subsequenceScore(haystack, needle) {
+  if (!needle) return 0;
+  let needleIndex = 0;
+  let lastMatch = -1;
+  let gapPenalty = 0;
+
+  for (let i = 0; i < haystack.length && needleIndex < needle.length; i += 1) {
+    if (haystack[i] === needle[needleIndex]) {
+      if (lastMatch >= 0) gapPenalty += i - lastMatch - 1;
+      lastMatch = i;
+      needleIndex += 1;
+    }
+  }
+
+  if (needleIndex < needle.length) return 0;
+  return Math.max(20, 40 - gapPenalty);
+}
+
+function fuzzyScore(query, candidate) {
+  const normalizedQuery = normalizeForFuzzy(query);
+  if (!normalizedQuery) return 0;
+  const normalizedCandidate = normalizeForFuzzy(candidate);
+  if (!normalizedCandidate) return 0;
+
+  if (normalizedCandidate === normalizedQuery) return 100;
+  if (normalizedCandidate.startsWith(normalizedQuery)) return 90;
+  if (normalizedCandidate.includes(normalizedQuery)) return 70;
+
+  return subsequenceScore(normalizedCandidate, normalizedQuery);
+}
+
+function fuzzyScorePath(query, candidatePath) {
+  const overall = fuzzyScore(query, candidatePath);
+  const leaf = fuzzyScore(query, pathBasename(candidatePath));
+  return Math.max(overall, leaf + 5);
+}
+
+function isSkillFile(relativePath) {
+  return /(^|\/)\.agents\/skills\/[^/]+\/SKILL\.md$/i.test(toPosix(relativePath));
+}
+
+function statusForError(error, fallbackStatus = 500) {
+  if (typeof error?.statusCode === 'number') return error.statusCode;
+  if (error?.code === 'ENOENT') return 404;
+  if (error?.code === 'EACCES' || error?.code === 'EPERM') return 403;
+  return fallbackStatus;
+}
+
+async function collectSearchEntries(root, deadline, maxEntries) {
+  const queue = [''];
+  const entries = [];
+  const metrics = {
+    visitedDirs: 0,
+    visitedFiles: 0,
+    skippedDirs: 0,
+    errors: 0,
+    timedOut: false,
+    truncated: false,
+  };
+
+  while (queue.length > 0) {
+    if (performance.now() > deadline) {
+      metrics.timedOut = true;
+      break;
+    }
+    if (entries.length >= maxEntries) {
+      metrics.truncated = true;
+      break;
+    }
+
+    const relativeDir = queue.shift();
+    const absDir = path.join(root, relativeDir);
+    let dirents;
+    try {
+      dirents = await fs.promises.readdir(absDir, { withFileTypes: true });
+      metrics.visitedDirs += 1;
+    } catch {
+      metrics.errors += 1;
+      continue;
+    }
+
+    dirents.sort((left, right) => {
+      if (left.isDirectory() !== right.isDirectory()) return left.isDirectory() ? -1 : 1;
+      return left.name.localeCompare(right.name);
+    });
+
+    for (const dirent of dirents) {
+      const childRelative = toPosix(path.join(relativeDir, dirent.name));
+
+      if (dirent.isDirectory()) {
+        if (SEARCH_IGNORE_DIRS.has(dirent.name)) {
+          metrics.skippedDirs += 1;
+          continue;
+        }
+        entries.push({ relativePath: childRelative, isDirectory: true });
+        queue.push(childRelative);
+        continue;
+      }
+
+      if (dirent.isFile()) {
+        entries.push({ relativePath: childRelative, isDirectory: false });
+        metrics.visitedFiles += 1;
+      }
+    }
+  }
+
+  metrics.collectedEntries = entries.length;
+  return { entries, metrics };
+}
+
+function parseSkillDescription(content) {
+  const frontmatterMatch = String(content || '').match(/^---\s*\n([\s\S]*?)\n---/);
+  const block = frontmatterMatch ? frontmatterMatch[1] : String(content || '').slice(0, SKILL_DESCRIPTION_PREVIEW_BYTES);
+  const descriptionMatch = block.match(/^description:\s*(.+?)\s*$/im);
+  if (!descriptionMatch) return null;
+
+  let description = descriptionMatch[1].trim();
+  if (
+    (description.startsWith('"') && description.endsWith('"')) ||
+    (description.startsWith("'") && description.endsWith("'"))
+  ) {
+    description = description.slice(1, -1);
+  }
+  return description.trim() || null;
+}
+
+async function collectSkillEntries(root) {
+  const skillsRoot = path.join(root, '.agents', 'skills');
+  let dirents;
+  try {
+    dirents = await fs.promises.readdir(skillsRoot, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const skills = [];
+  for (const dirent of dirents) {
+    if (!dirent.isDirectory()) continue;
+    const skillFile = path.join(skillsRoot, dirent.name, 'SKILL.md');
+    try {
+      const stat = await fs.promises.stat(skillFile);
+      if (!stat.isFile()) continue;
+    } catch {
+      continue;
+    }
+
+    let description;
+    try {
+      const content = await fs.promises.readFile(skillFile, 'utf8');
+      description = parseSkillDescription(content) || undefined;
+    } catch {
+      description = undefined;
+    }
+
+    skills.push({
+      relativePath: toPosix(path.relative(root, skillFile)),
+      isDirectory: false,
+      description,
+    });
+  }
+  return skills;
+}
+
+function searchKindForEntry(entry) {
+  if (isSkillFile(entry.relativePath)) return 'skill';
+  return entry.isDirectory ? 'folder' : 'file';
+}
+
+function rankedSearchItem(root, query, entry) {
+  const kind = searchKindForEntry(entry);
+  const absolute = path.join(root, entry.relativePath);
+  const title = kind === 'skill'
+    ? pathBasename(entry.relativePath.replace(/\/SKILL\.md$/i, ''))
+    : pathBasename(entry.relativePath);
+  const score = fuzzyScorePath(query, entry.relativePath);
+  if (score <= 0) return null;
+
+  return {
+    id: `${kind}:${absolute}`,
+    kind,
+    title,
+    subtitle: absolute,
+    path: absolute,
+    isDirectory: kind === 'folder',
+    isSkill: kind === 'skill',
+    description: entry.description,
+    score,
+  };
+}
+
+function uniqueSearchEntries(entries) {
+  const seen = new Set();
+  const unique = [];
+  for (const entry of entries) {
+    const key = `${entry.isDirectory ? 'folder' : 'file'}:${entry.relativePath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(entry);
+  }
+  return unique;
+}
+
+async function searchRoot(resolveSafePath, root, query, deadline, maxEntries) {
+  const safeRoot = await resolveSafePath(root);
+  const stat = await fs.promises.stat(safeRoot);
+  if (!stat.isDirectory()) return null;
+
+  const realRoot = await fs.promises.realpath(safeRoot);
+  const collectStarted = performance.now();
+  const [collection, skills] = await Promise.all([
+    collectSearchEntries(realRoot, deadline, maxEntries),
+    collectSkillEntries(realRoot),
+  ]);
+  const entries = uniqueSearchEntries([...collection.entries, ...skills]);
+
+  return {
+    root: realRoot,
+    items: entries.map((entry) => rankedSearchItem(realRoot, query, entry)).filter(Boolean),
+    metrics: {
+      ...collection.metrics,
+      skillEntries: skills.length,
+      collectMs: performance.now() - collectStarted,
+    },
+  };
+}
+
+function normalizeSearchRoots(value) {
+  const roots = Array.isArray(value) ? value : [value];
+  return Array.from(new Set(
+    roots
+      .map((root) => (typeof root === 'string' ? root.trim() : ''))
+      .filter(Boolean),
+  ));
+}
+
+function createFsSearchHandler({ resolveSafePath }) {
+  return async function handleSearch(body, sendJson) {
+    const started = performance.now();
+    const query = typeof body?.query === 'string' ? body.query.trim() : '';
+    const roots = normalizeSearchRoots(body?.roots ?? body?.root);
+    const limit = Math.min(Math.max(Number.parseInt(String(body?.limit ?? DEFAULT_SEARCH_LIMIT), 10) || DEFAULT_SEARCH_LIMIT, 1), 50);
+    const budgetMs = Math.min(Math.max(Number.parseInt(String(body?.budgetMs ?? DEFAULT_SEARCH_BUDGET_MS), 10) || DEFAULT_SEARCH_BUDGET_MS, 100), 5000);
+    const maxEntries = Math.min(
+      Math.max(Number.parseInt(String(body?.maxEntries ?? DEFAULT_SEARCH_MAX_ENTRIES), 10) || DEFAULT_SEARCH_MAX_ENTRIES, 1000),
+      500000,
+    );
+
+    if (!query) {
+      return sendJson(200, {
+        query,
+        roots,
+        items: [],
+        metrics: { backend: 'node', totalMs: performance.now() - started, collectedEntries: 0 },
+      });
+    }
+
+    if (roots.length === 0) {
+      return sendJson(400, { error: 'roots is required' });
+    }
+
+    const deadline = started + budgetMs;
+    const rootResults = [];
+    const errors = [];
+
+    for (const requestedRoot of roots) {
+      if (performance.now() > deadline) break;
+
+      try {
+        const result = await searchRoot(resolveSafePath, requestedRoot, query, deadline, maxEntries);
+        if (result) rootResults.push(result);
+      } catch (error) {
+        errors.push({
+          root: requestedRoot,
+          error: error instanceof Error ? error.message : 'Failed to search root',
+          status: statusForError(error),
+        });
+      }
+    }
+
+    const kindOrder = { skill: 0, file: 1, folder: 2 };
+    const seenItems = new Set();
+    const items = [];
+
+    for (const rootResult of rootResults) {
+      for (const item of rootResult.items) {
+        const key = `${item.kind}:${item.path}`;
+        if (seenItems.has(key)) continue;
+        seenItems.add(key);
+        items.push(item);
+      }
+    }
+
+    items.sort((left, right) => {
+      if (right.score !== left.score) return right.score - left.score;
+      if (kindOrder[left.kind] !== kindOrder[right.kind]) return kindOrder[left.kind] - kindOrder[right.kind];
+      return left.path.localeCompare(right.path);
+    });
+
+    const metrics = rootResults.reduce((acc, result) => {
+      acc.visitedDirs += result.metrics.visitedDirs || 0;
+      acc.visitedFiles += result.metrics.visitedFiles || 0;
+      acc.skippedDirs += result.metrics.skippedDirs || 0;
+      acc.errors += result.metrics.errors || 0;
+      acc.collectedEntries += result.metrics.collectedEntries || 0;
+      acc.skillEntries += result.metrics.skillEntries || 0;
+      acc.timedOut = acc.timedOut || Boolean(result.metrics.timedOut);
+      acc.truncated = acc.truncated || Boolean(result.metrics.truncated);
+      return acc;
+    }, {
+      backend: 'node',
+      roots: rootResults.length,
+      visitedDirs: 0,
+      visitedFiles: 0,
+      skippedDirs: 0,
+      errors: errors.length,
+      collectedEntries: 0,
+      skillEntries: 0,
+      timedOut: performance.now() > deadline,
+      truncated: false,
+    });
+
+    metrics.resultCount = Math.min(items.length, limit);
+    metrics.totalMs = performance.now() - started;
+
+    return sendJson(200, {
+      query,
+      roots: rootResults.map((result) => result.root),
+      items: items.slice(0, limit),
+      metrics,
+      errors,
+    });
+  };
+}
+
+module.exports = {
+  createFsSearchHandler,
+  _private: {
+    collectSearchEntries,
+    collectSkillEntries,
+    fuzzyScore,
+    fuzzyScorePath,
+    normalizeSearchRoots,
+    rankedSearchItem,
+  },
+};

package/runtime/scripts/amalgm-mcp/server/routes/files.js

@@ -11,6 +11,10 @@ async function handleFileRoutes(ctx) {
     fsRest.handleRead(ctx.getQuery(), ctx.sendJson);
     return true;
   }
+  if (ctx.pathname === '/fs/search' && ctx.method === 'POST') {
+    fsRest.handleSearch(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
   if (ctx.pathname === '/fs/content' && (ctx.method === 'GET' || ctx.method === 'HEAD')) {
     await fsRest.handleContent(ctx.getQuery(), ctx.req, ctx.res);
     return true;