agentpacks 0.2.0

package/dist/node/core/feature-merger.js

@@ -0,0 +1,139 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/core/feature-merger.ts
+class FeatureMerger {
+  packs;
+  warnings = [];
+  constructor(packs) {
+    this.packs = packs;
+  }
+  merge() {
+    this.warnings = [];
+    const features = {
+      rules: this.mergeRules(),
+      commands: this.mergeByName("commands"),
+      agents: this.mergeByName("agents"),
+      skills: this.mergeByName("skills"),
+      hooks: this.mergeHooks(),
+      plugins: this.mergePlugins(),
+      mcpServers: this.mergeMcp(),
+      ignorePatterns: this.mergeIgnore()
+    };
+    return { features, warnings: this.warnings };
+  }
+  mergeRules() {
+    const seen = new Map;
+    const result = [];
+    for (const pack of this.packs) {
+      for (const rule of pack.rules) {
+        const existing = seen.get(rule.name);
+        if (existing) {
+          this.warnings.push(`Rule "${rule.name}" from pack "${rule.packName}" skipped (already defined by "${existing}").`);
+          continue;
+        }
+        seen.set(rule.name, rule.packName);
+        result.push(rule);
+      }
+    }
+    return result;
+  }
+  mergeByName(featureKey) {
+    const seen = new Map;
+    const result = [];
+    for (const pack of this.packs) {
+      const items = pack[featureKey];
+      for (const item of items) {
+        const existing = seen.get(item.name);
+        if (existing) {
+          this.warnings.push(`${featureKey.slice(0, -1)} "${item.name}" from pack "${item.packName}" skipped (already defined by "${existing}").`);
+          continue;
+        }
+        seen.set(item.name, item.packName);
+        result.push(item);
+      }
+    }
+    return result;
+  }
+  mergeHooks() {
+    return this.packs.map((p) => p.hooks).filter((h) => h !== null);
+  }
+  mergePlugins() {
+    const seen = new Map;
+    const result = [];
+    for (const pack of this.packs) {
+      for (const plugin of pack.plugins) {
+        const key = `${plugin.name}.${plugin.extension}`;
+        const existing = seen.get(key);
+        if (existing) {
+          this.warnings.push(`Plugin "${key}" from pack "${plugin.packName}" skipped (already defined by "${existing}").`);
+          continue;
+        }
+        seen.set(key, plugin.packName);
+        result.push(plugin);
+      }
+    }
+    return result;
+  }
+  mergeMcp() {
+    const servers = {};
+    for (const pack of this.packs) {
+      if (!pack.mcp)
+        continue;
+      for (const [name, entry] of Object.entries(pack.mcp.servers)) {
+        if (name in servers) {
+          this.warnings.push(`MCP server "${name}" from pack "${pack.manifest.name}" skipped (already defined).`);
+          continue;
+        }
+        servers[name] = entry;
+      }
+    }
+    return servers;
+  }
+  mergeIgnore() {
+    const seen = new Set;
+    const result = [];
+    for (const pack of this.packs) {
+      if (!pack.ignore)
+        continue;
+      for (const pattern of pack.ignore.patterns) {
+        if (!seen.has(pattern)) {
+          seen.add(pattern);
+          result.push(pattern);
+        }
+      }
+    }
+    return result;
+  }
+}
+export {
+  FeatureMerger
+};