agentpacks 0.2.0

package/dist/core/dependency-resolver.js

@@ -0,0 +1,151 @@
+// @bun
+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 = import.meta.require;
+
+// src/core/dependency-resolver.ts
+function buildDependencyGraph(manifests) {
+  const graph = new Map;
+  for (const m of manifests) {
+    graph.set(m.name, {
+      name: m.name,
+      manifest: m,
+      dependencies: m.dependencies,
+      conflicts: m.conflicts
+    });
+  }
+  return graph;
+}
+function resolveDependencies(manifests) {
+  const graph = buildDependencyGraph(manifests);
+  const allNames = new Set(graph.keys());
+  const missingDeps = [];
+  for (const [name, node] of graph) {
+    for (const dep of node.dependencies) {
+      if (!allNames.has(dep)) {
+        missingDeps.push([name, dep]);
+      }
+    }
+  }
+  const { sorted, cycles } = topologicalSort(graph);
+  const conflictPairs = detectConflicts(graph);
+  const ok = cycles.length === 0 && conflictPairs.length === 0 && missingDeps.length === 0;
+  return { sorted, cycles, conflictPairs, missingDeps, ok };
+}
+function topologicalSort(graph) {
+  const inDegree = new Map;
+  for (const name of graph.keys()) {
+    inDegree.set(name, 0);
+  }
+  for (const [, node] of graph) {
+    for (const dep of node.dependencies) {
+      if (graph.has(dep)) {
+        inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0)
+      queue.push(name);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    const node = graph.get(current);
+    for (const dep of node.dependencies) {
+      if (!graph.has(dep))
+        continue;
+      const newDegree = (inDegree.get(dep) ?? 1) - 1;
+      inDegree.set(dep, newDegree);
+      if (newDegree === 0) {
+        queue.push(dep);
+      }
+    }
+  }
+  const cycles = [];
+  if (sorted.length < graph.size) {
+    const remaining = new Set;
+    for (const name of graph.keys()) {
+      if (!sorted.includes(name))
+        remaining.add(name);
+    }
+    const visited = new Set;
+    for (const start of remaining) {
+      if (visited.has(start))
+        continue;
+      const cycle = traceCycle(start, graph, remaining);
+      if (cycle.length > 0) {
+        cycles.push(cycle);
+        for (const n of cycle)
+          visited.add(n);
+      }
+    }
+  }
+  return { sorted: sorted.reverse(), cycles };
+}
+function traceCycle(start, graph, remaining) {
+  const path = [];
+  const pathSet = new Set;
+  let current = start;
+  while (current && !pathSet.has(current)) {
+    path.push(current);
+    pathSet.add(current);
+    const node = graph.get(current);
+    if (!node)
+      break;
+    current = node.dependencies.find((d) => remaining.has(d) && graph.has(d));
+  }
+  if (current && pathSet.has(current)) {
+    const cycleStart = path.indexOf(current);
+    return path.slice(cycleStart);
+  }
+  return path;
+}
+function detectConflicts(graph) {
+  const conflicts = [];
+  const seen = new Set;
+  for (const [name, node] of graph) {
+    for (const conflict of node.conflicts) {
+      if (graph.has(conflict)) {
+        const key = [name, conflict].sort().join(":");
+        if (!seen.has(key)) {
+          seen.add(key);
+          conflicts.push([name, conflict]);
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+export {
+  resolveDependencies,
+  buildDependencyGraph
+};

package/dist/core/feature-merger.d.ts

@@ -0,0 +1,61 @@
+import type { LoadedPack } from './pack-loader.js';
+import type { ParsedRule } from '../features/rules.js';
+import type { ParsedCommand } from '../features/commands.js';
+import type { ParsedAgent } from '../features/agents.js';
+import type { ParsedSkill } from '../features/skills.js';
+import type { ParsedHooks } from '../features/hooks.js';
+import type { ParsedPlugin } from '../features/plugins.js';
+import type { McpServerEntry } from '../features/mcp.js';
+/**
+ * Merged features from all active packs.
+ */
+export interface MergedFeatures {
+    rules: ParsedRule[];
+    commands: ParsedCommand[];
+    agents: ParsedAgent[];
+    skills: ParsedSkill[];
+    hooks: ParsedHooks[];
+    plugins: ParsedPlugin[];
+    mcpServers: Record<string, McpServerEntry>;
+    ignorePatterns: string[];
+}
+/**
+ * Merges features from multiple packs with conflict detection.
+ * First pack wins for name-based conflicts.
+ */
+export declare class FeatureMerger {
+    private packs;
+    private warnings;
+    constructor(packs: LoadedPack[]);
+    /**
+     * Merge all features from loaded packs.
+     */
+    merge(): {
+        features: MergedFeatures;
+        warnings: string[];
+    };
+    /**
+     * Rules are additive. Same filename from different packs: first wins.
+     */
+    private mergeRules;
+    /**
+     * Generic name-based merge for commands, agents, skills.
+     */
+    private mergeByName;
+    /**
+     * Hooks are additive per event.
+     */
+    private mergeHooks;
+    /**
+     * Plugins are additive.
+     */
+    private mergePlugins;
+    /**
+     * MCP servers merge by name. First pack wins.
+     */
+    private mergeMcp;
+    /**
+     * Ignore patterns are additive (deduplicated).
+     */
+    private mergeIgnore;
+}

package/dist/core/feature-merger.js

@@ -0,0 +1,139 @@
+// @bun
+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 = import.meta.require;
+
+// 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
+};

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export { type TargetId, type FeatureId, type RepoMode, type PackManifest, type WorkspaceConfig, TARGET_IDS, FEATURE_IDS, REPO_MODES, PackManifestSchema, WorkspaceConfigSchema, loadWorkspaceConfig, loadPackManifest, resolveFeatures, resolveTargets, } from './config.js';
+export { PackLoader } from './pack-loader.js';
+export { FeatureMerger } from './feature-merger.js';
+export { type Lockfile, type LockfileSourceEntry, type LockfileSkillEntry, loadLockfile, saveLockfile, getLockedSource, setLockedSource, computeIntegrity, isLockfileFrozenValid, } from './lockfile.js';
+export { type DependencyNode, type DependencyResolution, buildDependencyGraph, resolveDependencies, } from './dependency-resolver.js';