agentsmesh 0.8.0 → 0.9.0

package/dist/{target-descriptor-Cb9PXaxr.d.ts → target-descriptor-CkH4Z43u.d.ts}

@@ -122,6 +122,7 @@ type ImportFeatureKind = 'rules' | 'commands' | 'agents' | 'skills' | 'mcp' | 'h
  *                    `mcp.json`.
  */
 type ImportFeatureMode = 'singleFile' | 'directory' | 'flatFile' | 'mcpJson';
+type ContentNormalizer = (content: string, sourceFile: string, destinationFile: string) => string;
 interface ImportEntryContext {
     readonly absolutePath: string;
     readonly relativePath: string;
@@ -344,4 +345,4 @@ interface TargetDescriptor {
     readonly preservesManualActivation?: boolean;
 }
 
-export type { ExtraRuleOutputContext as E, FeatureLinter as F, GenerateResult as G, ImportPathBuilder as I, LintDiagnostic as L, RuleLinter as R, ScopeExtrasFn as S, TargetCapabilities as T, ExtraRuleOutputResolver as a, GeneratedOutputMerger as b, GlobalTargetSupport as c, ImportResult as d, TargetDescriptor as e, TargetGenerators as f, TargetLayout as g, TargetLayoutScope as h, TargetLintHooks as i, TargetManagedOutputs as j, TargetOutputFamily as k, TargetPathResolvers as l };
+export type { ContentNormalizer as C, ExtraRuleOutputContext as E, FeatureLinter as F, GenerateResult as G, ImportPathBuilder as I, LintDiagnostic as L, RuleLinter as R, ScopeExtrasFn as S, TargetCapabilities as T, ExtraRuleOutputResolver as a, GeneratedOutputMerger as b, GlobalTargetSupport as c, ImportResult as d, TargetDescriptor as e, TargetGenerators as f, TargetLayout as g, TargetLayoutScope as h, TargetLintHooks as i, TargetManagedOutputs as j, TargetOutputFamily as k, TargetPathResolvers as l };

package/dist/targets.d.ts

@@ -1,5 +1,5 @@
-import { e as TargetDescriptor } from './target-descriptor-Cb9PXaxr.js';
-export { E as ExtraRuleOutputContext, a as ExtraRuleOutputResolver, F as FeatureLinter, b as GeneratedOutputMerger, c as GlobalTargetSupport, I as ImportPathBuilder, R as RuleLinter, S as ScopeExtrasFn, T as TargetCapabilities, f as TargetGenerators, g as TargetLayout, h as TargetLayoutScope, i as TargetLintHooks, j as TargetManagedOutputs, k as TargetOutputFamily, l as TargetPathResolvers } from './target-descriptor-Cb9PXaxr.js';
+import { e as TargetDescriptor, h as TargetLayoutScope, C as ContentNormalizer, d as ImportResult } from './target-descriptor-CkH4Z43u.js';
+export { E as ExtraRuleOutputContext, a as ExtraRuleOutputResolver, F as FeatureLinter, b as GeneratedOutputMerger, c as GlobalTargetSupport, I as ImportPathBuilder, R as RuleLinter, S as ScopeExtrasFn, T as TargetCapabilities, f as TargetGenerators, g as TargetLayout, i as TargetLintHooks, j as TargetManagedOutputs, k as TargetOutputFamily, l as TargetPathResolvers } from './target-descriptor-CkH4Z43u.js';
 import './schema-BeGiBqbB.js';
 import 'zod';
 
@@ -9,10 +9,28 @@ declare function registerTargetDescriptor(descriptor: TargetDescriptor): void;
 declare function getDescriptor(name: string): TargetDescriptor | undefined;
 declare function getAllDescriptors(): TargetDescriptor[];
 
+/**
+ * Descriptor-driven importer runner.
+ *
+ * Walks `descriptor.importer` for each feature in canonical order, resolves
+ * scope-specific source paths, and dispatches to the existing helpers
+ * (`importFileDirectory`, MCP / ignore writers). Scope variance lives entirely
+ * in the spec — features with no source for the current scope are skipped
+ * silently, eliminating per-importer `if (scope === 'global')` branches.
+ *
+ * Targets with bespoke parsing (codex-cli rule splitter, windsurf workflows,
+ * gemini-cli policies) keep `generators.importFrom`. They may still call this
+ * runner for the declarable parts of their flow.
+ */
+
+declare function runDescriptorImport(descriptor: TargetDescriptor, projectRoot: string, scope: TargetLayoutScope, options?: {
+    readonly normalize?: ContentNormalizer;
+}): Promise<ImportResult[]>;
+
 /**
  * Public API — built-in target catalog and plugin registration (package.json "exports"."./targets").
  */
 
 declare function getTargetCatalog(): readonly TargetDescriptor[];
 
-export { TargetDescriptor, getAllDescriptors, getDescriptor, getTargetCatalog, registerTargetDescriptor };
+export { TargetDescriptor, TargetLayoutScope, getAllDescriptors, getDescriptor, getTargetCatalog, registerTargetDescriptor, runDescriptorImport };

package/dist/targets.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { readFile, readdir, stat, mkdir, lstat, writeFile, rename, rm, realpath, access } from 'fs/promises';
-import { basename, join, relative, normalize, dirname, extname, win32, isAbsolute, posix } from 'path';
+import { readFile, readdir, stat, mkdir, lstat, unlink, writeFile, rename, rm, realpath, access } from 'fs/promises';
+import { normalize, join, basename, relative, dirname, extname, win32, isAbsolute, posix } from 'path';
 import { existsSync, realpathSync, constants, statSync } from 'fs';
 import { stringify, parse } from 'yaml';
 import { parse as parse$1 } from 'smol-toml';
@@ -364,6 +364,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;
@@ -372,7 +377,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(() => {
@@ -2010,18 +2023,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 [];
 }
@@ -2066,24 +2085,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);
@@ -2095,6 +2111,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 [];
@@ -11784,6 +11813,7 @@ var init_builtin_targets = __esm({
 // src/public/targets.ts
 init_builtin_targets();
 init_registry();
+init_descriptor_import_runner();
 function copyCapabilities(capabilities) {
   return Object.freeze({ ...capabilities });
 }
@@ -11835,6 +11865,6 @@ function getTargetCatalog() {
   return Object.freeze(BUILTIN_TARGETS.map(copyTargetDescriptor));
 }
 
-export { getAllDescriptors, getDescriptor, getTargetCatalog, registerTargetDescriptor };
+export { getAllDescriptors, getDescriptor, getTargetCatalog, registerTargetDescriptor, runDescriptorImport };
 //# sourceMappingURL=targets.js.map
 //# sourceMappingURL=targets.js.map