agentsmesh 0.6.0 → 0.8.0

package/dist/{canonical-types-CZwrJoBX.d.ts → schema-BeGiBqbB.d.ts}

@@ -1,3 +1,5 @@
+import { z } from 'zod';
+
 /** Hook definition */
 interface HookEntry {
     matcher: string;
@@ -143,4 +145,111 @@ interface CanonicalFiles {
     ignore: IgnorePatterns;
 }
 
-export type { CanonicalAgent as C, HookEntry as H, IgnorePatterns as I, McpConfig as M, Permissions as P, SkillSupportingFile as S, UrlMcpServer as U, CanonicalCommand as a, CanonicalFiles as b, CanonicalRule as c, CanonicalSkill as d, Hooks as e, McpServer as f, StdioMcpServer as g };
+/** Zod schema for agentsmesh.yaml config validation */
+declare const configSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        antigravity: "antigravity";
+        "claude-code": "claude-code";
+        cline: "cline";
+        "codex-cli": "codex-cli";
+        continue: "continue";
+        copilot: "copilot";
+        cursor: "cursor";
+        "gemini-cli": "gemini-cli";
+        junie: "junie";
+        kiro: "kiro";
+        "roo-code": "roo-code";
+        windsurf: "windsurf";
+    }>>>;
+    features: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        rules: "rules";
+        commands: "commands";
+        agents: "agents";
+        skills: "skills";
+        mcp: "mcp";
+        hooks: "hooks";
+        ignore: "ignore";
+        permissions: "permissions";
+    }>>>;
+    extends: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        target: z.ZodOptional<z.ZodEnum<{
+            antigravity: "antigravity";
+            "claude-code": "claude-code";
+            cline: "cline";
+            "codex-cli": "codex-cli";
+            continue: "continue";
+            copilot: "copilot";
+            cursor: "cursor";
+            "gemini-cli": "gemini-cli";
+            junie: "junie";
+            kiro: "kiro";
+            "roo-code": "roo-code";
+            windsurf: "windsurf";
+        }>>;
+        features: z.ZodArray<z.ZodEnum<{
+            rules: "rules";
+            commands: "commands";
+            agents: "agents";
+            skills: "skills";
+            mcp: "mcp";
+            hooks: "hooks";
+            ignore: "ignore";
+            permissions: "permissions";
+        }>>;
+        path: z.ZodOptional<z.ZodString>;
+        pick: z.ZodOptional<z.ZodObject<{
+            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strip>>>;
+    overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    collaboration: z.ZodDefault<z.ZodObject<{
+        strategy: z.ZodDefault<z.ZodEnum<{
+            merge: "merge";
+            lock: "lock";
+            "last-wins": "last-wins";
+        }>>;
+        lock_features: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    conversions: z.ZodOptional<z.ZodObject<{
+        commands_to_skills: z.ZodOptional<z.ZodObject<{
+            'codex-cli': z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                project: z.ZodOptional<z.ZodBoolean>;
+                global: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>]>>;
+        }, z.core.$loose>>;
+        agents_to_skills: z.ZodOptional<z.ZodObject<{
+            'gemini-cli': z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                project: z.ZodOptional<z.ZodBoolean>;
+                global: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>]>>;
+            cline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                project: z.ZodOptional<z.ZodBoolean>;
+                global: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>]>>;
+            'codex-cli': z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                project: z.ZodOptional<z.ZodBoolean>;
+                global: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>]>>;
+            windsurf: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                project: z.ZodOptional<z.ZodBoolean>;
+                global: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>]>>;
+        }, z.core.$loose>>;
+    }, z.core.$strict>>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    pluginTargets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ValidatedConfig = z.infer<typeof configSchema>;
+
+export type { CanonicalAgent as C, HookEntry as H, IgnorePatterns as I, McpConfig as M, Permissions as P, SkillSupportingFile as S, UrlMcpServer as U, ValidatedConfig as V, CanonicalCommand as a, CanonicalFiles as b, CanonicalRule as c, CanonicalSkill as d, Hooks as e, McpServer as f, StdioMcpServer as g };

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

@@ -1,5 +1,4 @@
-import { b as CanonicalFiles, c as CanonicalRule } from './canonical-types-CZwrJoBX.js';
-import { z } from 'zod';
+import { b as CanonicalFiles, c as CanonicalRule, V as ValidatedConfig } from './schema-BeGiBqbB.js';
 
 /** Result of generating files for a target */
 interface GenerateResult {
@@ -37,113 +36,6 @@ interface LintDiagnostic {
 /** Feature support level per target */
 type SupportLevel = 'native' | 'embedded' | 'partial' | 'none';
 
-/** Zod schema for agentsmesh.yaml config validation */
-declare const configSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    targets: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        "claude-code": "claude-code";
-        cursor: "cursor";
-        copilot: "copilot";
-        continue: "continue";
-        junie: "junie";
-        kiro: "kiro";
-        "gemini-cli": "gemini-cli";
-        cline: "cline";
-        "codex-cli": "codex-cli";
-        windsurf: "windsurf";
-        antigravity: "antigravity";
-        "roo-code": "roo-code";
-    }>>>;
-    features: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        rules: "rules";
-        commands: "commands";
-        agents: "agents";
-        skills: "skills";
-        mcp: "mcp";
-        hooks: "hooks";
-        ignore: "ignore";
-        permissions: "permissions";
-    }>>>;
-    extends: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        source: z.ZodString;
-        version: z.ZodOptional<z.ZodString>;
-        target: z.ZodOptional<z.ZodEnum<{
-            "claude-code": "claude-code";
-            cursor: "cursor";
-            copilot: "copilot";
-            continue: "continue";
-            junie: "junie";
-            kiro: "kiro";
-            "gemini-cli": "gemini-cli";
-            cline: "cline";
-            "codex-cli": "codex-cli";
-            windsurf: "windsurf";
-            antigravity: "antigravity";
-            "roo-code": "roo-code";
-        }>>;
-        features: z.ZodArray<z.ZodEnum<{
-            rules: "rules";
-            commands: "commands";
-            agents: "agents";
-            skills: "skills";
-            mcp: "mcp";
-            hooks: "hooks";
-            ignore: "ignore";
-            permissions: "permissions";
-        }>>;
-        path: z.ZodOptional<z.ZodString>;
-        pick: z.ZodOptional<z.ZodObject<{
-            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-    }, z.core.$strip>>>;
-    overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    collaboration: z.ZodDefault<z.ZodObject<{
-        strategy: z.ZodDefault<z.ZodEnum<{
-            merge: "merge";
-            lock: "lock";
-            "last-wins": "last-wins";
-        }>>;
-        lock_features: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    conversions: z.ZodOptional<z.ZodObject<{
-        commands_to_skills: z.ZodOptional<z.ZodObject<{
-            'codex-cli': z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-                project: z.ZodOptional<z.ZodBoolean>;
-                global: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>]>>;
-        }, z.core.$loose>>;
-        agents_to_skills: z.ZodOptional<z.ZodObject<{
-            'gemini-cli': z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-                project: z.ZodOptional<z.ZodBoolean>;
-                global: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>]>>;
-            cline: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-                project: z.ZodOptional<z.ZodBoolean>;
-                global: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>]>>;
-            'codex-cli': z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-                project: z.ZodOptional<z.ZodBoolean>;
-                global: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>]>>;
-            windsurf: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-                project: z.ZodOptional<z.ZodBoolean>;
-                global: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strict>]>>;
-        }, z.core.$loose>>;
-    }, z.core.$strict>>;
-    plugins: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        source: z.ZodString;
-        version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    pluginTargets: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-type ValidatedConfig = z.infer<typeof configSchema>;
-
 /** Serialization / projection variant for a canonical feature (see architecture review §3.3). */
 type FeatureFlavor = 'standard' | 'workflows' | 'settings-embedded' | 'projected-skills' | 'gh-actions-lite' | string;
 /** Normalized capability entry: support level plus optional serialization flavor. */
@@ -192,6 +84,93 @@ interface TargetGenerators {
     lint?(files: CanonicalFiles): LintDiagnostic[];
 }
 
+/**
+ * Descriptor-driven importer contract.
+ *
+ * Each target may declare an `importer: TargetImporterDescriptor` block on its
+ * descriptor. The shared runner walks the spec, resolves sources for the active
+ * scope, and dispatches to existing helpers (`importFileDirectory`,
+ * `importDirectorySkill`, …). Scope variance is expressed as data — features
+ * with no `global` source are silently skipped in global mode, eliminating the
+ * `if (scope === 'global')` branches that previously leaked into importer bodies.
+ *
+ * Targets with custom parsing (codex-cli rule splitter, windsurf workflows,
+ * gemini-cli policies) keep their own `generators.importFrom` and may also
+ * delegate the declarable parts of their flow to the runner.
+ */
+
+/**
+ * Per-scope source paths. Omit `global` to make the feature project-only — the
+ * runner skips it under `--global` instead of every importer guarding with
+ * `if (scope === 'global')`.
+ */
+interface ImportSourcePaths {
+    readonly project?: readonly string[];
+    readonly global?: readonly string[];
+}
+type ImportFeatureKind = 'rules' | 'commands' | 'agents' | 'skills' | 'mcp' | 'hooks' | 'permissions' | 'ignore';
+/**
+ * Mapping modes:
+ *  - `singleFile`  — try each `source` path in order, take the first that
+ *                    exists, write to `${canonicalDir}/${canonicalRootFilename}`.
+ *                    Used for root rule files (`AGENTS.md`, `CLAUDE.md`, …).
+ *  - `directory`   — recurse `source` paths and run a per-entry mapper. Built
+ *                    on top of the existing `importFileDirectory` helper.
+ *  - `flatFile`    — copy a single file verbatim (with `trimEnd`) to a fixed
+ *                    canonical destination. Used for `ignore`.
+ *  - `mcpJson`     — parse a JSON MCP servers file and write canonical
+ *                    `mcp.json`.
+ */
+type ImportFeatureMode = 'singleFile' | 'directory' | 'flatFile' | 'mcpJson';
+interface ImportEntryContext {
+    readonly absolutePath: string;
+    readonly relativePath: string;
+    readonly content: string;
+    readonly destDir: string;
+    readonly normalizeTo: (destinationFile: string) => string;
+}
+interface ImportEntryMapping {
+    readonly destPath: string;
+    readonly toPath: string;
+    readonly content: string;
+}
+type ImportEntryMapper = (ctx: ImportEntryContext) => Promise<ImportEntryMapping | null> | ImportEntryMapping | null;
+/** Optional declarative frontmatter post-processing for the default mappers. */
+type FrontmatterRemap = (frontmatter: Record<string, unknown>) => Record<string, unknown>;
+interface ImportFeatureSpec {
+    readonly feature: ImportFeatureKind;
+    readonly mode: ImportFeatureMode;
+    readonly source: ImportSourcePaths;
+    /** Tried after `source` in the same scope when the primary chain finds nothing (singleFile only). */
+    readonly fallbacks?: ImportSourcePaths;
+    /** Canonical destination directory under the project root (e.g. `.agentsmesh/rules`). */
+    readonly canonicalDir: string;
+    /** For `singleFile` only: the destination filename inside `canonicalDir`. */
+    readonly canonicalRootFilename?: string;
+    /** For `directory` mode: file extensions to match (`['.md']`, `['.mdc']`, …). */
+    readonly extensions?: readonly string[];
+    /** For `directory` mode: pick a built-in mapper. */
+    readonly preset?: 'rule' | 'command' | 'agent';
+    /** Optional frontmatter post-processing applied by built-in mappers. */
+    readonly frontmatterRemap?: FrontmatterRemap;
+    /** Custom mapper. Wins over `preset` when both are set. */
+    readonly map?: ImportEntryMapper;
+    /** For `singleFile` rules: marks the imported entry as a root rule (`root: true`). */
+    readonly markAsRoot?: boolean;
+    /** For `flatFile` and `mcpJson`: canonical destination filename. */
+    readonly canonicalFilename?: string;
+}
+interface TargetImporterDescriptor {
+    readonly rules?: ImportFeatureSpec | readonly ImportFeatureSpec[];
+    readonly commands?: ImportFeatureSpec;
+    readonly agents?: ImportFeatureSpec;
+    readonly skills?: ImportFeatureSpec;
+    readonly mcp?: ImportFeatureSpec;
+    readonly hooks?: ImportFeatureSpec;
+    readonly permissions?: ImportFeatureSpec;
+    readonly ignore?: ImportFeatureSpec;
+}
+
 /**
  * Self-describing target descriptor interface.
  *
@@ -212,6 +191,11 @@ interface TargetOutputFamily {
     /** Explicit paths for additional root mirrors (Cursor, Gemini compat). */
     readonly explicitPaths?: readonly string[];
 }
+interface ExtraRuleOutputContext {
+    readonly refs: ReadonlyMap<string, string>;
+    readonly scope: TargetLayoutScope;
+}
+type ExtraRuleOutputResolver = (rule: CanonicalFiles['rules'][number], context: ExtraRuleOutputContext) => readonly string[];
 /**
  * Path resolvers for the output reference map.
  * Each method returns a relative output path, or null to skip.
@@ -235,14 +219,10 @@ interface TargetManagedOutputs {
 interface TargetLayout {
     /** Primary root instruction artifact for this scope, if any. */
     readonly rootInstructionPath?: string;
-    /**
-     * Extra generated paths that should receive the same AgentsMesh root appendix as
-     * `rootInstructionPath` (for example Cursor `AGENTS.md` / `.cursor/AGENTS.md`, Gemini `AGENTS.md`).
-     * @deprecated Prefer `outputFamilies` with `kind: 'additional'`.
-     */
-    readonly additionalRootDecorationPaths?: readonly string[];
     /** Output families for rewrite cache keys and root decoration (see `layout-outputs.ts`). */
     readonly outputFamilies?: readonly TargetOutputFamily[];
+    /** Additional generated rule paths that share source ownership for reference rewriting. */
+    readonly extraRuleOutputPaths?: ExtraRuleOutputResolver;
     /** Optional renderer for scope-specific primary root instruction content. */
     readonly renderPrimaryRootInstruction?: (canonical: CanonicalFiles) => string;
     /** Target-native skills directory for this scope, if any. */
@@ -277,6 +257,7 @@ type RuleLinter = (canonical: CanonicalFiles, projectRoot: string, projectFiles:
 }) => LintDiagnostic[];
 /** Feature-specific lint hook signature. */
 type FeatureLinter = (canonical: CanonicalFiles, options?: unknown) => LintDiagnostic[];
+type GeneratedOutputMerger = (existing: string | null, pending: GenerateResult | undefined, newContent: string, resolvedPath: string) => string | null;
 /** Optional per-feature lint hooks for target-specific validation. */
 interface TargetLintHooks {
     readonly commands?: FeatureLinter;
@@ -297,10 +278,8 @@ interface TargetDescriptor {
     readonly generators: TargetGenerators;
     /** Feature support levels */
     readonly capabilities: TargetCapabilities;
-    /** Consolidated global-mode metadata (preferred over bare `global*` fields). */
+    /** Consolidated global-mode metadata. */
     readonly globalSupport?: GlobalTargetSupport;
-    /** Optional global-scope feature support levels when they differ from project mode */
-    readonly globalCapabilities?: TargetCapabilities;
     /** Message shown when import finds nothing for this target */
     readonly emptyImportMessage: string;
     /** Optional linter for canonical files */
@@ -309,8 +288,6 @@ interface TargetDescriptor {
     readonly lint?: TargetLintHooks;
     /** Project-scope target layout metadata */
     readonly project: TargetLayout;
-    /** Optional global-scope layout (use `globalSupport.layout` when `globalSupport` is set). */
-    readonly global?: TargetLayout;
     /**
      * Declares which embedded-capability features support user-configured conversion.
      * When the corresponding conversion is disabled in config, the feature generator is skipped.
@@ -320,20 +297,18 @@ interface TargetDescriptor {
         readonly agents?: true;
     };
     /**
-     * Optional hook for generating scope-specific extras beyond the standard feature loop.
-     * Prefer `globalSupport.scopeExtras` for global-only extras.
+     * Optional descriptor-driven importer block. When present, the shared
+     * `runDescriptorImport` orchestrator handles scan + map for each declared
+     * feature (with scope variance expressed as data, eliminating
+     * `if (scope === 'global')` branches in importer bodies). Targets with
+     * irreducibly custom parsing keep `generators.importFrom` and may delegate
+     * declarable parts of their flow to the runner.
      */
-    readonly generateScopeExtras?: ScopeExtrasFn;
-    /** @deprecated Use project.skillDir */
-    readonly skillDir?: string;
-    /** @deprecated Use project.paths */
-    readonly paths?: TargetPathResolvers;
+    readonly importer?: TargetImporterDescriptor;
     /** Import reference map builder */
     readonly buildImportPaths: ImportPathBuilder;
     /** Filesystem paths used to detect this target during `init` */
     readonly detectionPaths: readonly string[];
-    /** Optional filesystem paths used to detect this target in global scope during `init --global` */
-    readonly globalDetectionPaths?: readonly string[];
     /**
      * Declares which shared artifact paths this target owns or consumes.
      * Used by the reference rewriter to select the correct artifact map for shared outputs.
@@ -349,6 +324,8 @@ interface TargetDescriptor {
         readonly path: string;
         readonly content: string;
     }[];
+    /** Optional target-specific merge strategy for generated outputs. */
+    readonly mergeGeneratedOutputContent?: GeneratedOutputMerger;
     /**
      * Async post-pass for hook generator outputs (e.g. Copilot hook script assets under `.github/hooks/`).
      */
@@ -359,6 +336,12 @@ interface TargetDescriptor {
         readonly path: string;
         readonly content: string;
     }[]>;
+    /**
+     * When true, the target preserves manual-only activation semantics (e.g.
+     * Cursor's `alwaysApply: false` without globs/description). Targets without
+     * this flag get a lint warning when canonical rules have `trigger: 'manual'`.
+     */
+    readonly preservesManualActivation?: boolean;
 }
 
-export type { FeatureLinter as F, GenerateResult as G, ImportPathBuilder as I, LintDiagnostic as L, RuleLinter as R, ScopeExtrasFn as S, TargetCapabilities as T, ValidatedConfig as V, GlobalTargetSupport as a, ImportResult as b, TargetDescriptor as c, TargetGenerators as d, TargetLayout as e, TargetLayoutScope as f, TargetLintHooks as g, TargetManagedOutputs as h, TargetOutputFamily as i, TargetPathResolvers as j };
+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 };

package/dist/targets.d.ts

@@ -1,6 +1,6 @@
-import { c as TargetDescriptor } from './target-descriptor-DjHhww11.js';
-export { F as FeatureLinter, a as GlobalTargetSupport, I as ImportPathBuilder, R as RuleLinter, S as ScopeExtrasFn, T as TargetCapabilities, d as TargetGenerators, e as TargetLayout, f as TargetLayoutScope, g as TargetLintHooks, h as TargetManagedOutputs, i as TargetOutputFamily, j as TargetPathResolvers } from './target-descriptor-DjHhww11.js';
-import './canonical-types-CZwrJoBX.js';
+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 './schema-BeGiBqbB.js';
 import 'zod';
 
 /** Register a full target descriptor (for plugins). */