agentpacks 0.2.0

package/dist/core/lockfile.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Entry for a single skill in the lockfile.
+ */
+export interface LockfileSkillEntry {
+    integrity: string;
+}
+/**
+ * Entry for a single source in the lockfile.
+ */
+export interface LockfileSourceEntry {
+    requestedRef: string;
+    resolvedRef: string;
+    resolvedAt: string;
+    skills: Record<string, LockfileSkillEntry>;
+    packs?: Record<string, LockfileSkillEntry>;
+}
+/**
+ * Full lockfile structure.
+ */
+export interface Lockfile {
+    lockfileVersion: number;
+    sources: Record<string, LockfileSourceEntry>;
+}
+/**
+ * Load lockfile from disk, or return empty lockfile.
+ */
+export declare function loadLockfile(projectRoot: string): Lockfile;
+/**
+ * Save lockfile to disk.
+ */
+export declare function saveLockfile(projectRoot: string, lockfile: Lockfile): void;
+/**
+ * Get a locked source entry by key.
+ */
+export declare function getLockedSource(lockfile: Lockfile, sourceKey: string): LockfileSourceEntry | undefined;
+/**
+ * Update or create a source entry in the lockfile.
+ */
+export declare function setLockedSource(lockfile: Lockfile, sourceKey: string, entry: LockfileSourceEntry): void;
+/**
+ * Compute SHA-256 integrity hash for content.
+ */
+export declare function computeIntegrity(content: string): string;
+/**
+ * Check if lockfile covers all declared sources.
+ */
+export declare function isLockfileFrozenValid(lockfile: Lockfile, sourceKeys: string[]): {
+    valid: boolean;
+    missing: string[];
+};

package/dist/core/lockfile.js

@@ -0,0 +1,72 @@
+// @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/lockfile.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { createHash } from "crypto";
+var LOCKFILE_VERSION = 1;
+var LOCKFILE_NAME = "agentpacks.lock";
+function loadLockfile(projectRoot) {
+  const filepath = resolve(projectRoot, LOCKFILE_NAME);
+  if (!existsSync(filepath)) {
+    return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
+  }
+  const raw = readFileSync(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveLockfile(projectRoot, lockfile) {
+  const filepath = resolve(projectRoot, LOCKFILE_NAME);
+  writeFileSync(filepath, JSON.stringify(lockfile, null, 2) + `
+`);
+}
+function getLockedSource(lockfile, sourceKey) {
+  return lockfile.sources[sourceKey];
+}
+function setLockedSource(lockfile, sourceKey, entry) {
+  lockfile.sources[sourceKey] = entry;
+}
+function computeIntegrity(content) {
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256-${hash}`;
+}
+function isLockfileFrozenValid(lockfile, sourceKeys) {
+  const missing = sourceKeys.filter((key) => !(key in lockfile.sources));
+  return { valid: missing.length === 0, missing };
+}
+export {
+  setLockedSource,
+  saveLockfile,
+  loadLockfile,
+  isLockfileFrozenValid,
+  getLockedSource,
+  computeIntegrity
+};

package/dist/core/metarepo.d.ts

@@ -0,0 +1,26 @@
+import type { WorkspaceConfig } from './config.js';
+/**
+ * A discovered sub-repo within a metarepo.
+ */
+export interface MetarepoEntry {
+    /** Relative path from metarepo root */
+    path: string;
+    /** Absolute path */
+    absolutePath: string;
+    /** Whether it has agentpacks config */
+    hasConfig: boolean;
+    /** Loaded config (if hasConfig) */
+    config: WorkspaceConfig | null;
+}
+/**
+ * Discover sub-repos in a metarepo root.
+ * Looks for directories containing agentpacks.jsonc or package.json.
+ */
+export declare function discoverMetarepoEntries(metarepoRoot: string, options?: {
+    maxDepth?: number;
+}): MetarepoEntry[];
+/**
+ * Generate for all discovered sub-repos in a metarepo.
+ * Returns paths that were processed.
+ */
+export declare function getMetarepoBaseDirs(metarepoRoot: string): string[];

package/dist/core/metarepo.js

@@ -0,0 +1,218 @@
+// @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/config.ts
+var exports_config = {};
+__export(exports_config, {
+  resolveTargets: () => resolveTargets,
+  resolveFeatures: () => resolveFeatures,
+  loadWorkspaceConfig: () => loadWorkspaceConfig,
+  loadPackManifest: () => loadPackManifest,
+  WorkspaceConfigSchema: () => WorkspaceConfigSchema,
+  TARGET_IDS: () => TARGET_IDS,
+  REPO_MODES: () => REPO_MODES,
+  PackManifestSchema: () => PackManifestSchema,
+  FEATURE_IDS: () => FEATURE_IDS
+});
+import { z } from "zod";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+function loadWorkspaceConfig(projectRoot) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = resolve(projectRoot, filename);
+    if (existsSync(filepath)) {
+      const raw = readFileSync(filepath, "utf-8");
+      const parsed = parseJsonc(raw);
+      return WorkspaceConfigSchema.parse(parsed);
+    }
+  }
+  return WorkspaceConfigSchema.parse({});
+}
+function loadPackManifest(packDir) {
+  const filepath = resolve(packDir, "pack.json");
+  if (!existsSync(filepath)) {
+    const dirName = packDir.split("/").pop() ?? "unknown";
+    return PackManifestSchema.parse({ name: dirName });
+  }
+  const raw = readFileSync(filepath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return PackManifestSchema.parse(parsed);
+}
+function resolveFeatures(config, targetId) {
+  const { features } = config;
+  if (features === "*") {
+    return [...FEATURE_IDS];
+  }
+  if (Array.isArray(features)) {
+    if (features.includes("*"))
+      return [...FEATURE_IDS];
+    return features.filter((f) => FEATURE_IDS.includes(f));
+  }
+  const targetFeatures = features[targetId];
+  if (!targetFeatures)
+    return [];
+  if (targetFeatures === "*")
+    return [...FEATURE_IDS];
+  if (Array.isArray(targetFeatures) && targetFeatures.includes("*"))
+    return [...FEATURE_IDS];
+  return targetFeatures.filter((f) => FEATURE_IDS.includes(f));
+}
+function resolveTargets(config) {
+  if (config.targets === "*")
+    return [...TARGET_IDS];
+  return config.targets;
+}
+var TARGET_IDS, FEATURE_IDS, REPO_MODES, PackManifestSchema, FeaturesSchema, WorkspaceConfigSchema, CONFIG_FILES;
+var init_config = __esm(() => {
+  TARGET_IDS = [
+    "opencode",
+    "cursor",
+    "claudecode",
+    "codexcli",
+    "geminicli",
+    "copilot",
+    "agentsmd",
+    "cline",
+    "kilo",
+    "roo",
+    "qwencode",
+    "kiro",
+    "factorydroid",
+    "antigravity",
+    "junie",
+    "augmentcode",
+    "windsurf",
+    "warp",
+    "replit",
+    "zed"
+  ];
+  FEATURE_IDS = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "hooks",
+    "plugins",
+    "mcp",
+    "ignore"
+  ];
+  REPO_MODES = ["repo", "monorepo", "metarepo"];
+  PackManifestSchema = z.object({
+    name: z.string().min(1),
+    version: z.string().default("1.0.0"),
+    description: z.string().default(""),
+    author: z.union([
+      z.string(),
+      z.object({ name: z.string(), email: z.string().optional() })
+    ]).optional(),
+    tags: z.array(z.string()).default([]),
+    dependencies: z.array(z.string()).default([]),
+    conflicts: z.array(z.string()).default([]),
+    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+    features: z.union([z.literal("*"), z.array(z.string())]).default("*")
+  });
+  FeaturesSchema = z.union([
+    z.literal("*"),
+    z.array(z.string()),
+    z.record(z.string(), z.union([z.literal("*"), z.array(z.string())]))
+  ]);
+  WorkspaceConfigSchema = z.object({
+    $schema: z.string().optional(),
+    packs: z.array(z.string()).default(["./packs/default"]),
+    disabled: z.array(z.string()).default([]),
+    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+    features: FeaturesSchema.default("*"),
+    mode: z.enum(REPO_MODES).default("repo"),
+    baseDirs: z.array(z.string()).default(["."]),
+    global: z.boolean().default(false),
+    delete: z.boolean().default(true),
+    verbose: z.boolean().default(false),
+    silent: z.boolean().default(false),
+    overrides: z.record(z.string(), z.record(z.string(), z.string())).default({}),
+    sources: z.array(z.object({
+      source: z.string(),
+      packs: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional()
+    })).default([])
+  });
+  CONFIG_FILES = ["agentpacks.local.jsonc", "agentpacks.jsonc"];
+});
+
+// src/core/metarepo.ts
+init_config();
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join, relative } from "path";
+function discoverMetarepoEntries(metarepoRoot, options = {}) {
+  const maxDepth = options.maxDepth ?? 2;
+  const entries = [];
+  scanDir(metarepoRoot, metarepoRoot, 0, maxDepth, entries);
+  return entries;
+}
+function scanDir(root, dir, depth, maxDepth, entries) {
+  if (depth > maxDepth)
+    return;
+  const children = readdirSync(dir, { withFileTypes: true });
+  for (const child of children) {
+    if (!child.isDirectory())
+      continue;
+    if (child.name.startsWith(".") || child.name === "node_modules")
+      continue;
+    const childPath = join(dir, child.name);
+    const hasConfig = existsSync2(join(childPath, "agentpacks.jsonc")) || existsSync2(join(childPath, "agentpacks.local.jsonc"));
+    const hasPackageJson = existsSync2(join(childPath, "package.json"));
+    if (hasConfig || hasPackageJson) {
+      let config = null;
+      if (hasConfig) {
+        try {
+          config = loadWorkspaceConfig(childPath);
+        } catch {
+          config = null;
+        }
+      }
+      entries.push({
+        path: relative(root, childPath),
+        absolutePath: childPath,
+        hasConfig,
+        config
+      });
+    }
+    scanDir(root, childPath, depth + 1, maxDepth, entries);
+  }
+}
+function getMetarepoBaseDirs(metarepoRoot) {
+  const entries = discoverMetarepoEntries(metarepoRoot);
+  return entries.filter((e) => e.hasConfig).map((e) => e.path);
+}
+export {
+  getMetarepoBaseDirs,
+  discoverMetarepoEntries
+};

package/dist/core/pack-loader.d.ts

@@ -0,0 +1,61 @@
+import { type PackManifest, type WorkspaceConfig } from './config.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 ParsedMcp } from '../features/mcp.js';
+import { type ParsedIgnore } from '../features/ignore.js';
+/**
+ * A fully loaded pack with all parsed features.
+ */
+export interface LoadedPack {
+    manifest: PackManifest;
+    directory: string;
+    rules: ParsedRule[];
+    commands: ParsedCommand[];
+    agents: ParsedAgent[];
+    skills: ParsedSkill[];
+    hooks: ParsedHooks | null;
+    plugins: ParsedPlugin[];
+    mcp: ParsedMcp | null;
+    ignore: ParsedIgnore | null;
+}
+/**
+ * Loads packs from a workspace configuration.
+ */
+export declare class PackLoader {
+    private projectRoot;
+    private config;
+    constructor(projectRoot: string, config: WorkspaceConfig);
+    /**
+     * Load all active packs from the workspace config.
+     * Returns packs in declaration order (first = highest priority).
+     */
+    loadAll(): {
+        packs: LoadedPack[];
+        warnings: string[];
+    };
+    /**
+     * Load a single pack from a directory.
+     */
+    private loadPack;
+    /**
+     * Load packs scoped to a specific baseDir (monorepo support).
+     * Looks for an agentpacks.jsonc in the baseDir and loads its packs.
+     */
+    loadForBaseDir(baseDir: string): {
+        packs: LoadedPack[];
+        warnings: string[];
+    };
+    /**
+     * Resolve a curated (installed) pack from .agentpacks/.curated/.
+     */
+    private resolveCuratedPack;
+    /**
+     * Resolve a pack reference to an absolute directory path.
+     * Supports: ./relative, /absolute, npm:pkg, github:owner/repo, curated cache
+     */
+    private resolvePackPath;
+}