agentsmesh 0.7.0 → 0.8.0

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

@@ -1,4 +1,4 @@
-import { b as CanonicalFiles, c as CanonicalRule, V as ValidatedConfig } from './schema-B7ZSqkrS.js';
+import { b as CanonicalFiles, c as CanonicalRule, V as ValidatedConfig } from './schema-BeGiBqbB.js';
 
 /** Result of generating files for a target */
 interface GenerateResult {
@@ -84,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.
  *
@@ -209,6 +296,15 @@ interface TargetDescriptor {
         readonly commands?: true;
         readonly agents?: true;
     };
+    /**
+     * 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 importer?: TargetImporterDescriptor;
     /** Import reference map builder */
     readonly buildImportPaths: ImportPathBuilder;
     /** Filesystem paths used to detect this target during `init` */
@@ -240,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 { 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 { e as TargetDescriptor } from './target-descriptor-COp3nil6.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-COp3nil6.js';
-import './schema-B7ZSqkrS.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). */