agentsmesh 0.8.0 → 0.9.0

package/dist/engine.d.ts

@@ -1,5 +1,5 @@
 import { V as ValidatedConfig, b as CanonicalFiles } from './schema-BeGiBqbB.js';
-import { G as GenerateResult, h as TargetLayoutScope, L as LintDiagnostic, d as ImportResult } from './target-descriptor-Cb9PXaxr.js';
+import { G as GenerateResult, h as TargetLayoutScope, L as LintDiagnostic, d as ImportResult } from './target-descriptor-CkH4Z43u.js';
 import 'zod';
 
 /**

package/dist/engine.js

@@ -1,17 +1,17 @@
 import { z } from 'zod';
-import { readFile, rm, mkdir, readdir, stat, lstat, writeFile, rename, access, realpath } from 'fs/promises';
+import { readFile, rm, mkdir, readdir, stat, lstat, unlink, writeFile, rename, access, realpath } from 'fs/promises';
 import { join, basename, dirname, relative, win32, posix, resolve, normalize, extname, isAbsolute } from 'path';
 import { constants, existsSync, realpathSync, statSync } from 'fs';
 import { stringify, parse } from 'yaml';
 import { parse as parse$1 } from 'smol-toml';
 import { Buffer } from 'buffer';
 import { homedir } from 'os';
+import { createHash } from 'crypto';
 import { execFile } from 'child_process';
 import { fileURLToPath, pathToFileURL, URL } from 'url';
 import { promisify } from 'util';
 import * as tar from 'tar';
 import { createTwoFilesPatch } from 'diff';
-import { createHash } from 'crypto';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -452,6 +452,11 @@ async function writeFileAtomic(path, content) {
         { errnoCode: "EISDIR" }
       );
     }
+    if (info.isSymbolicLink()) {
+      await unlink(path).catch((e) => {
+        if (e.code !== "ENOENT") throw e;
+      });
+    }
   } catch (err) {
     if (err instanceof FileSystemError) throw err;
     const e = err;
@@ -460,7 +465,15 @@ async function writeFileAtomic(path, content) {
   const tmpPath = `${path}.tmp`;
   const payload = shouldNormalizeLineEndings(path) ? normalizeLineEndings(content) : content;
   try {
-    await writeFile(tmpPath, payload, "utf-8");
+    try {
+      const tmpInfo = await lstat(tmpPath);
+      if (tmpInfo.isSymbolicLink()) {
+        await unlink(tmpPath);
+      }
+    } catch (tmpErr) {
+      if (tmpErr.code !== "ENOENT") throw tmpErr;
+    }
+    await writeFile(tmpPath, payload, { encoding: "utf-8", flag: "w" });
     await rename(tmpPath, path);
   } catch (err) {
     await rm(tmpPath, { force: true }).catch(() => {
@@ -2134,18 +2147,24 @@ async function runDirectory(spec, sources, projectRoot, fromTool, normalize) {
   }
   return results;
 }
+function resolveCanonicalFilePath(spec) {
+  const filename = spec.canonicalFilename;
+  if (filename.includes("/") || filename.includes("\\")) return filename;
+  return posix.join(spec.canonicalDir, filename);
+}
 async function runFlatFile(spec, sources, projectRoot, fromTool) {
   if (!spec.canonicalFilename) {
     throw new Error(`flatFile spec for ${spec.feature} must set canonicalFilename`);
   }
+  const canonicalPath = resolveCanonicalFilePath(spec);
   for (const rel2 of sources) {
     const srcPath = join(projectRoot, rel2);
     const content = await readFileSafe(srcPath);
     if (content === null) continue;
-    const destPath = join(projectRoot, spec.canonicalFilename);
+    const destPath = join(projectRoot, canonicalPath);
     await mkdirp(dirname(destPath));
     await writeFileAtomic(destPath, content.trimEnd());
-    return [{ fromTool, fromPath: srcPath, toPath: spec.canonicalFilename, feature: spec.feature }];
+    return [{ fromTool, fromPath: srcPath, toPath: canonicalPath, feature: spec.feature }];
   }
   return [];
 }
@@ -2190,24 +2209,21 @@ async function runMcpJson(spec, sources, projectRoot, fromTool) {
   if (!spec.canonicalFilename) {
     throw new Error(`mcpJson spec for ${spec.feature} must set canonicalFilename`);
   }
+  const canonicalPath = resolveCanonicalFilePath(spec);
   for (const rel2 of sources) {
     const srcPath = join(projectRoot, rel2);
     const content = await readFileSafe(srcPath);
     if (content === null) continue;
     const servers = parseMcpJson(content);
     if (Object.keys(servers).length === 0) return [];
-    const destPath = join(projectRoot, spec.canonicalFilename);
+    const destPath = join(projectRoot, canonicalPath);
     await mkdirp(dirname(destPath));
     await writeFileAtomic(destPath, JSON.stringify({ mcpServers: servers }, null, 2));
-    return [{ fromTool, fromPath: srcPath, toPath: spec.canonicalFilename, feature: spec.feature }];
+    return [{ fromTool, fromPath: srcPath, toPath: canonicalPath, feature: spec.feature }];
   }
   return [];
 }
-async function runSpec(spec, scope, projectRoot, fromTool, normalize) {
-  const primary = resolveScopedSources(spec.source, scope);
-  const fallback = resolveScopedSources(spec.fallbacks, scope);
-  const sources = primary.length > 0 ? primary : fallback;
-  if (sources.length === 0) return [];
+function dispatchSpec(spec, sources, projectRoot, fromTool, normalize) {
   switch (spec.mode) {
     case "singleFile":
       return runSingleFile(spec, sources, projectRoot, fromTool, normalize);
@@ -2219,6 +2235,19 @@ async function runSpec(spec, scope, projectRoot, fromTool, normalize) {
       return runMcpJson(spec, sources, projectRoot, fromTool);
   }
 }
+async function runSpec(spec, scope, projectRoot, fromTool, normalize) {
+  const primary = resolveScopedSources(spec.source, scope);
+  const fallback = resolveScopedSources(spec.fallbacks, scope);
+  if (primary.length === 0 && fallback.length === 0) return [];
+  if (primary.length > 0) {
+    const results = await dispatchSpec(spec, primary, projectRoot, fromTool, normalize);
+    if (results.length > 0) return results;
+  }
+  if (fallback.length > 0) {
+    return dispatchSpec(spec, fallback, projectRoot, fromTool, normalize);
+  }
+  return [];
+}
 function specsForFeature(importer, feature) {
   const value = importer[feature];
   if (!value) return [];
@@ -11944,7 +11973,7 @@ function ruleTargetPath(target13, rule, scope = "project") {
     return layout.rootInstructionPath ?? null;
   }
   if (rule.targets.length > 0 && !rule.targets.includes(target13)) return null;
-  const slug = basename(rule.source, ".md");
+  const slug = posix.basename(rule.source.replace(/\\/g, "/"), ".md");
   return layout.paths.rulePath(slug, rule);
 }
 function commandTargetPath(target13, name, config, scope = "project") {
@@ -12206,8 +12235,7 @@ function extraRuleOutputPaths(target13, rule, refs, scope) {
 
 // src/core/reference/output-source-map.ts
 init_builtin_targets();
-function addGlobalSkillMirrorSourceEntry(target13, scope, primaryOutputPath, source, sourceMap, activeTargets) {
-  if (scope !== "global") return;
+function addSkillMirrorSourceEntry(target13, scope, primaryOutputPath, source, sourceMap, activeTargets) {
   const layout = getTargetLayout(target13, scope);
   if (!layout?.mirrorGlobalPath) return;
   const raw = layout.mirrorGlobalPath(primaryOutputPath, activeTargets ?? []);
@@ -12260,7 +12288,7 @@ function buildOutputSourceMap(target13, canonical, config, scope = "project", ac
     const skillTargetPath = refs.get(canonicalSkillPath(skill));
     if (skillTargetPath) {
       sourceMap.set(skillTargetPath, skill.source);
-      addGlobalSkillMirrorSourceEntry(
+      addSkillMirrorSourceEntry(
         target13,
         scope,
         skillTargetPath,
@@ -12274,7 +12302,7 @@ function buildOutputSourceMap(target13, canonical, config, scope = "project", ac
       const targetPath = refs.get(canonicalPath);
       if (targetPath) {
         sourceMap.set(targetPath, file.absolutePath);
-        addGlobalSkillMirrorSourceEntry(
+        addSkillMirrorSourceEntry(
           target13,
           scope,
           targetPath,
@@ -12290,11 +12318,12 @@ function buildOutputSourceMap(target13, canonical, config, scope = "project", ac
 
 // src/core/reference/rewriter.ts
 init_builtin_targets();
+init_registry();
 init_shared_artifact_owner();
 function findSharedArtifactOwner(path, activeTargets) {
   if (!activeTargets) return null;
   for (const targetId of activeTargets) {
-    const descriptor13 = getBuiltinTargetDefinition(targetId);
+    const descriptor13 = getDescriptor(targetId);
     if (!descriptor13?.sharedArtifacts) continue;
     for (const [pathPrefix, role] of Object.entries(descriptor13.sharedArtifacts)) {
       if (role === "owner" && path.startsWith(pathPrefix)) {
@@ -13426,13 +13455,25 @@ async function sweepStaleCache(cacheDir, maxAgeMs) {
 }
 
 // src/config/remote/remote-fetcher.ts
+var MAX_CACHE_KEY_LENGTH = 80;
 function buildCacheKey(provider, identifier, ref) {
-  const safe = (value) => value.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const safe = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_").replace(/^\.+/, "_");
+  let key;
   if (provider === "github") {
     const [org, repo] = identifier.split("/", 2);
-    if (org && repo) return `${safe(org)}-${safe(repo)}-${safe(ref)}`;
+    if (org && repo) {
+      key = `${safe(org)}--${safe(repo)}--${safe(ref)}`;
+    } else {
+      key = `${safe(provider)}__${safe(identifier)}__${safe(ref)}`;
+    }
+  } else {
+    key = `${safe(provider)}__${safe(identifier)}__${safe(ref)}`;
   }
-  return `${safe(provider)}_${safe(identifier)}_${safe(ref)}`;
+  if (key.length > MAX_CACHE_KEY_LENGTH) {
+    const hash = createHash("sha256").update(key).digest("hex").slice(0, 16);
+    key = `${key.slice(0, MAX_CACHE_KEY_LENGTH - 18)}--${hash}`;
+  }
+  return key;
 }
 function getCacheDir() {
   const env = process.env.AGENTSMESH_CACHE;
@@ -14525,7 +14566,8 @@ async function importPluginModule(entry, projectRoot) {
   const { source } = entry;
   let importTarget;
   if (source.startsWith("file:") || source.startsWith("./") || source.startsWith("../") || source.startsWith("/")) {
-    const resolved = source.startsWith("file:") ? fileURLToPath(source) : resolve(projectRoot, source);
+    const raw = source.startsWith("file:") ? fileURLToPath(source) : source;
+    const resolved = resolve(projectRoot, raw);
     importTarget = pathToFileURL(resolved).href;
   } else {
     importTarget = source;
@@ -14782,7 +14824,8 @@ async function runLint(config, canonical, projectRoot, targetFilter, options = {
   const diagnostics = [];
   const projectFiles = scope === "global" ? [] : await getProjectFiles(projectRoot);
   for (const target13 of targets) {
-    const descriptor13 = isBuiltinTargetId(target13) ? getTargetCatalogEntry(target13) : getDescriptor(target13);
+    const fullDesc = getDescriptor(target13);
+    const descriptor13 = isBuiltinTargetId(target13) ? getTargetCatalogEntry(target13) : fullDesc;
     if (descriptor13?.capabilities) {
       diagnostics.push(
         ...lintSilentFeatureDrops({
@@ -14794,29 +14837,26 @@ async function runLint(config, canonical, projectRoot, targetFilter, options = {
       );
     }
     if (hasHooks) {
-      const fullDescForHooks = getDescriptor(target13);
       diagnostics.push(
         ...lintHookScriptReferences({
           target: target13,
           canonical,
-          hasScriptProjection: fullDescForHooks?.postProcessHookOutputs !== void 0
+          hasScriptProjection: fullDesc?.postProcessHookOutputs !== void 0
         })
       );
     }
     if (hasRules) {
-      const fullDescForRules = getDescriptor(target13);
       diagnostics.push(
         ...lintRuleScopeInversion({
           target: target13,
           canonical,
-          preservesManualActivation: fullDescForRules?.preservesManualActivation === true
+          preservesManualActivation: fullDesc?.preservesManualActivation === true
         })
       );
     }
     if (hasRules && descriptor13?.lintRules) {
       diagnostics.push(...descriptor13.lintRules(canonical, projectRoot, projectFiles, { scope }));
     }
-    const fullDesc = getDescriptor(target13);
     if (fullDesc?.generators.lint) {
       diagnostics.push(...fullDesc.generators.lint(canonical));
     }