@gleanwork/pluginpack 0.5.0

package/dist/chunk-HR2ZVYJA.js

@@ -0,0 +1,1522 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { pathToFileURL } from "url";
+import { createJiti } from "jiti";
+
+// src/components.ts
+var componentDirs = [
+  "skills",
+  "agents",
+  "commands",
+  "rules",
+  "hooks",
+  "scripts",
+  "assets",
+  "policies",
+  "themes"
+];
+var staticFiles = ["README.md", "CHANGELOG.md", "LICENSE"];
+var targetDefaultComponents = {
+  claude: ["skills", "agents", "hooks", "scripts", "assets"],
+  copilot: ["skills", "agents", "hooks", "scripts", "assets"],
+  cursor: ["skills", "agents", "rules", "hooks", "scripts", "assets"],
+  antigravity: ["skills", "agents", "rules", "hooks", "scripts", "assets"]
+};
+function resolveTargetComponents(target, pluginConfig) {
+  return new Set(pluginConfig.components ?? targetDefaultComponents[target]);
+}
+function isComponentPath(relativePath) {
+  return componentDirs.includes(relativePath.split("/")[0]);
+}
+
+// src/fs.ts
+import { promises as fs } from "fs";
+import path from "path";
+import fastGlob from "fast-glob";
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+async function walkFiles(dir) {
+  const entries = await fastGlob("**/*", {
+    cwd: dir,
+    absolute: true,
+    onlyFiles: true,
+    dot: true
+  });
+  return entries.sort();
+}
+async function writeArtifact(outDir, files) {
+  for (const [relativePath, value] of files) {
+    const destination = path.join(outDir, relativePath);
+    await fs.mkdir(path.dirname(destination), { recursive: true });
+    await fs.writeFile(destination, value);
+  }
+}
+function json(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function isSafeRelativePath(value) {
+  if (!value) {
+    return false;
+  }
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    return true;
+  }
+  if (path.isAbsolute(value)) {
+    return false;
+  }
+  const normalized = path.posix.normalize(value.replace(/\\/g, "/"));
+  return normalized !== ".." && !normalized.startsWith("../");
+}
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/schema.ts
+import { z } from "zod";
+var authorSchema = z.object({
+  name: z.string().min(1),
+  email: z.string().optional(),
+  url: z.string().optional()
+});
+var metadataSchema = z.object({
+  displayName: z.string().optional(),
+  description: z.string().optional(),
+  author: authorSchema.optional(),
+  owner: authorSchema.optional(),
+  homepage: z.string().optional(),
+  repository: z.string().optional(),
+  license: z.string().optional(),
+  logo: z.string().optional(),
+  keywords: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var rootPluginSchema = metadataSchema.extend({
+  id: z.string().min(1).optional(),
+  name: z.string().optional(),
+  description: z.string().optional()
+});
+var sourceSchema = z.object({
+  plugins: z.string().optional(),
+  skills: z.string().optional(),
+  rootPlugin: rootPluginSchema.optional()
+});
+var emittedPluginSchema = z.object({
+  from: z.array(z.string().min(1)).min(1),
+  path: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  displayName: z.string().optional(),
+  manifest: z.record(z.string(), z.unknown()).optional(),
+  components: z.array(z.string()).optional()
+});
+var targetSchema = z.object({
+  outDir: z.string().min(1),
+  marketplaceDir: z.string().optional(),
+  pluginRoot: z.string().optional(),
+  version: z.string().optional(),
+  plugins: z.record(z.string(), emittedPluginSchema),
+  manifest: z.record(z.string(), z.unknown()).optional(),
+  ignoredDiffPaths: z.array(z.string()).optional()
+});
+var configSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().min(1),
+  source: sourceSchema.optional(),
+  metadata: metadataSchema.optional(),
+  targets: z.object({
+    claude: targetSchema.optional(),
+    copilot: targetSchema.optional(),
+    cursor: targetSchema.optional(),
+    antigravity: targetSchema.optional()
+  })
+});
+var sourcePluginManifestSchema = metadataSchema.extend({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  mcpServers: z.record(z.string(), z.unknown()).optional()
+});
+
+// src/source.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+function createFilesystemSourceProvider(plugins) {
+  return {
+    listPlugins: () => Promise.resolve(plugins),
+    readPluginFiles: (pluginId, target) => readPluginFiles(pluginOrThrow(plugins, pluginId), target),
+    readMcpServers: (pluginId) => readMcpServers(pluginOrThrow(plugins, pluginId))
+  };
+}
+function pluginOrThrow(plugins, pluginId) {
+  const plugin = plugins.get(pluginId);
+  if (!plugin) {
+    throw new Error(`Unknown source plugin "${pluginId}".`);
+  }
+  return plugin;
+}
+async function readPluginFiles(plugin, target) {
+  const files = /* @__PURE__ */ new Map();
+  for (const dirName of componentDirs) {
+    const dir = plugin.componentRoots?.[dirName] ?? path2.join(plugin.dir, dirName);
+    if (!await exists(dir)) {
+      continue;
+    }
+    for (const file of await walkFiles(dir)) {
+      if (isTargetOverrideFile(file)) {
+        continue;
+      }
+      const relativeToPlugin = toPosix(
+        plugin.componentRoots?.[dirName] ? path2.join(dirName, path2.relative(dir, file)) : path2.relative(plugin.dir, file)
+      );
+      const resolved = await resolveTargetOverride(plugin.dir, file, target);
+      files.set(relativeToPlugin, await fs2.readFile(resolved));
+    }
+  }
+  if (plugin.includeStaticFiles !== false) {
+    for (const fileName of staticFiles) {
+      const file = path2.join(plugin.dir, fileName);
+      if (!await exists(file)) {
+        continue;
+      }
+      const resolved = await resolveTargetOverride(plugin.dir, file, target);
+      files.set(fileName, await fs2.readFile(resolved));
+    }
+  }
+  return files;
+}
+function isTargetOverrideFile(filePath) {
+  return filePath.split(path2.sep).includes("targets");
+}
+async function resolveTargetOverride(pluginDir, file, target) {
+  const basenameOverride = path2.join(
+    path2.dirname(file),
+    "targets",
+    target,
+    path2.basename(file)
+  );
+  if (await exists(basenameOverride)) {
+    return basenameOverride;
+  }
+  const relative = path2.relative(pluginDir, file);
+  const rootOverride = path2.join(pluginDir, "targets", target, relative);
+  if (await exists(rootOverride)) {
+    return rootOverride;
+  }
+  return file;
+}
+async function readMcpServers(plugin) {
+  const filePath = path2.join(plugin.dir, ".mcp.json");
+  if (await exists(filePath)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(await fs2.readFile(filePath, "utf8"));
+    } catch (error2) {
+      throw new Error(
+        `Invalid JSON in ${filePath}: ${error2.message}`
+      );
+    }
+    const servers = parsed.mcpServers;
+    return isObject(servers) ? servers : void 0;
+  }
+  return isObject(plugin.manifest.mcpServers) ? plugin.manifest.mcpServers : void 0;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+async function loadConfig(cwd = process.cwd(), configPath) {
+  const projectConfig = await loadProjectConfig(cwd, configPath);
+  const { config, rootDir } = projectConfig;
+  const sourceRoot = path3.resolve(rootDir, config.source?.plugins ?? "plugins");
+  const plugins = await discoverSourcePlugins(sourceRoot);
+  await addRootSkillsPlugin(rootDir, config, plugins);
+  return {
+    ...projectConfig,
+    sourceRoot,
+    plugins,
+    source: createFilesystemSourceProvider(plugins)
+  };
+}
+async function loadProjectConfig(cwd = process.cwd(), configPath) {
+  const resolvedConfigPath = configPath ? path3.resolve(cwd, configPath) : await findConfig(cwd);
+  const jiti = createJiti(pathToFileURL(resolvedConfigPath).href, {
+    interopDefault: true
+  });
+  const loaded = await jiti.import(resolvedConfigPath, { default: true });
+  const config = parseWithContext(
+    configSchema,
+    loaded,
+    resolvedConfigPath
+  );
+  const rootDir = path3.dirname(resolvedConfigPath);
+  return {
+    rootDir,
+    configPath: resolvedConfigPath,
+    config
+  };
+}
+async function addRootSkillsPlugin(rootDir, config, plugins) {
+  if (!config.source?.skills) {
+    return;
+  }
+  const id = config.source.rootPlugin?.id ?? "core";
+  if (plugins.has(id)) {
+    throw new Error(
+      `Root skills source plugin "${id}" conflicts with an existing source plugin.`
+    );
+  }
+  const skillsDir = path3.resolve(rootDir, config.source.skills);
+  if (!await exists(skillsDir)) {
+    throw new Error(`Root skills source directory is missing: ${skillsDir}`);
+  }
+  const manifest = { ...config.source.rootPlugin ?? {} };
+  delete manifest.id;
+  plugins.set(id, {
+    id,
+    dir: rootDir,
+    manifest,
+    componentRoots: {
+      skills: skillsDir
+    },
+    includeStaticFiles: false
+  });
+}
+async function findConfig(cwd) {
+  const names = [
+    "pluginpack.config.ts",
+    "pluginpack.config.mts",
+    "pluginpack.config.mjs",
+    "pluginpack.config.js"
+  ];
+  for (const name of names) {
+    const candidate = path3.resolve(cwd, name);
+    if (await exists(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `No pluginpack config found in ${cwd}. Expected ${names.join(", ")}.`
+  );
+}
+async function discoverSourcePlugins(sourceRoot) {
+  const plugins = /* @__PURE__ */ new Map();
+  if (!await exists(sourceRoot)) {
+    return plugins;
+  }
+  const entries = await fs3.readdir(sourceRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    const dir = path3.join(sourceRoot, entry.name);
+    if (!await isSourcePluginDir(dir)) {
+      continue;
+    }
+    const manifestPath = path3.join(dir, "plugin.pluginpack.json");
+    const manifest = await readSourceManifest(manifestPath);
+    plugins.set(entry.name, {
+      id: entry.name,
+      dir,
+      manifest
+    });
+  }
+  return plugins;
+}
+async function isSourcePluginDir(dir) {
+  if (await exists(path3.join(dir, "plugin.pluginpack.json"))) {
+    return true;
+  }
+  for (const component of componentDirs) {
+    if (await exists(path3.join(dir, component))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function readSourceManifest(filePath) {
+  if (!await exists(filePath)) {
+    return {};
+  }
+  const raw = await fs3.readFile(filePath, "utf8");
+  try {
+    return parseWithContext(
+      sourcePluginManifestSchema,
+      JSON.parse(raw),
+      filePath
+    );
+  } catch (error2) {
+    if (error2 instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${filePath}: ${error2.message}`);
+    }
+    throw error2;
+  }
+}
+function parseWithContext(schema, value, context) {
+  const parsed = schema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const details = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+  throw new Error(`Invalid pluginpack config in ${context}: ${details}`);
+}
+
+// src/build.ts
+import path6 from "path";
+
+// src/managed.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+function managedManifestPath(target) {
+  return toPosix(path4.join(".pluginpack", `${target}.json`));
+}
+async function writeManagedManifest(artifact2) {
+  const manifest = {
+    version: 1,
+    target: artifact2.target,
+    files: artifact2.managedPaths
+  };
+  const destination = path4.join(
+    artifact2.outDir,
+    managedManifestPath(artifact2.target)
+  );
+  await fs4.mkdir(path4.dirname(destination), { recursive: true });
+  await fs4.writeFile(destination, json(manifest));
+}
+async function readManagedManifest(outDir, target) {
+  const manifestPath = path4.join(outDir, managedManifestPath(target));
+  let raw;
+  try {
+    raw = await fs4.readFile(manifestPath, "utf8");
+  } catch (error2) {
+    if (isNotFound(error2)) {
+      return null;
+    }
+    throw error2;
+  }
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== 1 || parsed.target !== target || !Array.isArray(parsed.files) || !parsed.files.every((file) => typeof file === "string")) {
+    throw new Error(`Invalid managed manifest: ${manifestPath}`);
+  }
+  return parsed;
+}
+async function pruneManagedFiles(artifact2, options = {}) {
+  const previous = await readManagedManifest(artifact2.outDir, artifact2.target);
+  const current = new Set(artifact2.managedPaths.map(normalizeManagedPath));
+  const stale = (previous?.files ?? []).map(normalizeManagedPath).filter((file) => !current.has(file));
+  if (!options.dryRun) {
+    assertNoProtectedDeletions(artifact2.outDir, stale, options.guard, "prune");
+  }
+  const entries = [];
+  for (const normalized of stale) {
+    entries.push({
+      type: "stale",
+      target: artifact2.target,
+      path: normalized
+    });
+    if (!options.dryRun) {
+      await removeManagedPath(artifact2.outDir, normalized);
+    }
+  }
+  return {
+    target: artifact2.target,
+    outDir: artifact2.outDir,
+    entries
+  };
+}
+async function cleanManagedFiles(outDir, target, options = {}) {
+  const previous = await readManagedManifest(outDir, target);
+  const entries = [];
+  if (!previous) {
+    return { target, outDir, entries };
+  }
+  const files = (previous.files ?? []).map(normalizeManagedPath);
+  if (!options.dryRun) {
+    assertNoProtectedDeletions(outDir, files, options.guard, "clean");
+  }
+  for (const normalized of files) {
+    entries.push({ type: "deleted", target, path: normalized });
+    if (!options.dryRun) {
+      await removeManagedPath(outDir, normalized);
+    }
+  }
+  const manifestPath = managedManifestPath(target);
+  entries.push({ type: "deleted", target, path: manifestPath });
+  if (!options.dryRun) {
+    await removeManagedPath(outDir, manifestPath);
+  }
+  return { target, outDir, entries };
+}
+function buildDeleteGuard(rootDir, config, configPath, force) {
+  const protectedRoots = [];
+  if (config.source?.skills) {
+    protectedRoots.push(path4.resolve(rootDir, config.source.skills));
+  }
+  if (config.source?.plugins) {
+    protectedRoots.push(path4.resolve(rootDir, config.source.plugins));
+  }
+  return { protectedRoots, configPath: path4.resolve(configPath), force };
+}
+function assertNoProtectedDeletions(outDir, paths, guard, command) {
+  if (!guard || guard.force) {
+    return;
+  }
+  const blocked = paths.filter(
+    (file) => isProtectedDeletion(outDir, file, guard)
+  );
+  if (blocked.length === 0) {
+    return;
+  }
+  throw new Error(
+    `Refusing to ${command} ${blocked.length} path(s) that resolve inside your source tree or config:
+${blocked.map((file) => `  ${file}`).join("\n")}
+This usually means a target outDir overlaps source.skills/source.plugins. Fix the config, or re-run with --force to delete anyway.`
+  );
+}
+function isProtectedDeletion(outDir, relativePath, guard) {
+  const absolute = path4.resolve(outDir, normalizeManagedPath(relativePath));
+  if (guard.configPath && absolute === guard.configPath) {
+    return true;
+  }
+  return guard.protectedRoots.some(
+    (root) => absolute === root || absolute.startsWith(`${root}${path4.sep}`)
+  );
+}
+function normalizeManagedPath(value) {
+  const normalized = path4.posix.normalize(value.replace(/\\/g, "/"));
+  if (!value || path4.posix.isAbsolute(normalized) || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(`Unsafe managed path: ${value}`);
+  }
+  return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+async function removeManagedPath(outDir, relativePath) {
+  const root = path4.resolve(outDir);
+  const normalized = normalizeManagedPath(relativePath);
+  const destination = path4.resolve(root, normalized);
+  if (destination !== root && !destination.startsWith(`${root}${path4.sep}`)) {
+    throw new Error(`Managed path escapes output directory: ${relativePath}`);
+  }
+  await fs4.rm(destination, { force: true });
+  await removeEmptyParents(path4.dirname(destination), root);
+}
+async function removeEmptyParents(dir, root) {
+  let current = dir;
+  while (current !== root && current.startsWith(`${root}${path4.sep}`)) {
+    try {
+      await fs4.rmdir(current);
+    } catch (error2) {
+      if (isNotFound(error2) || isDirectoryNotEmpty(error2)) {
+        return;
+      }
+      throw error2;
+    }
+    current = path4.dirname(current);
+  }
+}
+function isNotFound(error2) {
+  return error2 instanceof Error && "code" in error2 && error2.code === "ENOENT";
+}
+function isDirectoryNotEmpty(error2) {
+  return error2 instanceof Error && "code" in error2 && (error2.code === "ENOTEMPTY" || error2.code === "EEXIST");
+}
+
+// src/targets.ts
+import path5 from "path";
+
+// src/render.ts
+async function collectPluginFiles(project, target, sourceIds, components) {
+  const files = /* @__PURE__ */ new Map();
+  for (const sourceId of sourceIds) {
+    if (!project.plugins.has(sourceId)) {
+      throw new Error(
+        `Target "${target}" references unknown source plugin "${sourceId}".`
+      );
+    }
+    const pluginFiles = await project.source.readPluginFiles(sourceId, target);
+    for (const [relativePath, value] of pluginFiles) {
+      if (!shouldEmitFile(relativePath, components)) {
+        continue;
+      }
+      setFile(files, relativePath, value, sourceId);
+    }
+  }
+  return files;
+}
+async function resolveMcpServers(project, sourceIds) {
+  const merged = {};
+  let found = false;
+  for (const sourceId of sourceIds) {
+    if (!project.plugins.has(sourceId)) {
+      continue;
+    }
+    const servers = await project.source.readMcpServers(sourceId);
+    if (!servers) {
+      continue;
+    }
+    found = true;
+    for (const [name, config] of Object.entries(servers)) {
+      if (name in merged) {
+        throw new Error(
+          `Duplicate MCP server "${name}" while merging source plugin "${sourceId}".`
+        );
+      }
+      merged[name] = config;
+    }
+  }
+  return found ? merged : void 0;
+}
+function shouldEmitFile(relativePath, components) {
+  if (!components || !isComponentPath(relativePath)) {
+    return true;
+  }
+  return components.has(relativePath.split("/")[0]);
+}
+function setFile(files, relativePath, value, sourceId) {
+  if (files.has(relativePath)) {
+    throw new Error(
+      `Duplicate emitted file "${relativePath}" while merging source plugin "${sourceId}". Add a target override or change the target plugin mapping.`
+    );
+  }
+  files.set(relativePath, value);
+}
+
+// src/targets.ts
+var emitters = {
+  claude: emitClaude,
+  copilot: emitCopilot,
+  cursor: emitCursor,
+  antigravity: emitAntigravity
+};
+async function emitTarget(project, target, outDir) {
+  const targetConfig = project.config.targets[target];
+  if (!targetConfig) {
+    throw new Error(`Target "${target}" is not configured.`);
+  }
+  const emitter = emitters[target];
+  const resolvedOutDir = path5.resolve(
+    project.rootDir,
+    outDir ?? targetConfig.outDir
+  );
+  return emitter(project, target, targetConfig, resolvedOutDir);
+}
+async function emitPlugins(project, target, targetConfig, files, options) {
+  const entries = [];
+  for (const [pluginName, pluginConfig] of Object.entries(
+    targetConfig.plugins
+  )) {
+    const pluginPath = options.resolvePluginPath(pluginName, pluginConfig);
+    const pluginFiles = await collectPluginFiles(
+      project,
+      target,
+      pluginConfig.from,
+      resolveTargetComponents(target, pluginConfig)
+    );
+    const componentDirs2 = new Set(
+      [...pluginFiles.keys()].map((file) => file.split("/")[0])
+    );
+    for (const [relativePath, value] of pluginFiles) {
+      files.set(toPosix(path5.join(pluginPath, relativePath)), value);
+    }
+    const mcpServers = await resolveMcpServers(project, pluginConfig.from);
+    if (mcpServers && options.mcp === "file") {
+      files.set(
+        toPosix(path5.join(pluginPath, ".mcp.json")),
+        json({ mcpServers })
+      );
+    } else if (mcpServers && options.mcp === "antigravity") {
+      files.set(
+        toPosix(path5.join(pluginPath, "mcp_config.json")),
+        json({ mcpServers })
+      );
+    }
+    const metadata = emittedPluginMetadata(project, pluginConfig);
+    const manifest = options.buildManifest(
+      metadata,
+      pluginName,
+      pluginConfig,
+      componentDirs2,
+      mcpServers
+    );
+    files.set(toPosix(options.pluginManifestPath(pluginPath)), json(manifest));
+    if (options.entrySource) {
+      entries.push({
+        name: pluginName,
+        source: options.entrySource(pluginPath),
+        description: pluginConfig.description ?? manifest.description
+      });
+    }
+  }
+  return entries;
+}
+async function emitCursor(project, target, targetConfig, outDir) {
+  const marketplaceDir = targetConfig.marketplaceDir ?? ".cursor-plugin";
+  const version = targetConfig.version ?? project.config.version;
+  const files = /* @__PURE__ */ new Map();
+  const plugins = await emitPlugins(project, target, targetConfig, files, {
+    resolvePluginPath: (pluginName, pluginConfig) => pluginConfig.path ?? pluginName,
+    pluginManifestPath: (pluginPath) => path5.join(pluginPath, marketplaceDir, "plugin.json"),
+    buildManifest: (metadata, pluginName, pluginConfig, componentDirs2, mcpServers) => cursorPluginManifest(
+      metadata,
+      pluginConfig.version ?? version,
+      pluginName,
+      pluginConfig,
+      componentDirs2,
+      mcpServers
+    ),
+    entrySource: (pluginPath) => pluginPath,
+    mcp: "file"
+  });
+  const marketplace = stripUndefined(
+    deepMerge(
+      {
+        name: project.config.name,
+        owner: project.config.metadata?.owner ?? project.config.metadata?.author,
+        metadata: {
+          description: project.config.metadata?.description,
+          keywords: project.config.metadata?.keywords
+        },
+        plugins,
+        version
+      },
+      targetConfig.manifest ?? {}
+    )
+  );
+  files.set(
+    toPosix(path5.join(marketplaceDir, "marketplace.json")),
+    json(marketplace)
+  );
+  return artifact(target, outDir, files);
+}
+async function emitClaude(project, target, targetConfig, outDir) {
+  const marketplaceDir = targetConfig.marketplaceDir ?? ".claude-plugin";
+  const pluginRoot = targetConfig.pluginRoot ?? "plugins";
+  const version = targetConfig.version ?? project.config.version;
+  const files = /* @__PURE__ */ new Map();
+  const plugins = await emitPlugins(project, target, targetConfig, files, {
+    resolvePluginPath: (pluginName, pluginConfig) => pluginConfig.path ?? toPosix(path5.join(pluginRoot, pluginName)),
+    pluginManifestPath: (pluginPath) => path5.join(pluginPath, marketplaceDir, "plugin.json"),
+    buildManifest: (metadata, pluginName, pluginConfig) => claudePluginManifest(
+      metadata,
+      pluginConfig.version ?? version,
+      pluginName,
+      pluginConfig
+    ),
+    entrySource: (pluginPath) => `./${pluginPath}`,
+    mcp: "file"
+  });
+  const marketplace = stripUndefined(
+    deepMerge(
+      {
+        $schema: "https://anthropic.com/claude-code/marketplace.schema.json",
+        name: project.config.name,
+        version,
+        description: project.config.metadata?.description,
+        owner: project.config.metadata?.owner ?? project.config.metadata?.author,
+        plugins
+      },
+      targetConfig.manifest ?? {}
+    )
+  );
+  files.set(
+    toPosix(path5.join(marketplaceDir, "marketplace.json")),
+    json(marketplace)
+  );
+  return artifact(target, outDir, files);
+}
+async function emitAntigravity(project, target, targetConfig, outDir) {
+  const version = targetConfig.version ?? project.config.version;
+  const files = /* @__PURE__ */ new Map();
+  await emitPlugins(project, target, targetConfig, files, {
+    resolvePluginPath: (pluginName, pluginConfig) => pluginConfig.path ?? pluginName,
+    pluginManifestPath: (pluginPath) => path5.join(pluginPath, "plugin.json"),
+    buildManifest: (metadata, pluginName, pluginConfig) => antigravityPluginManifest(
+      metadata,
+      pluginConfig.version ?? version,
+      pluginName,
+      pluginConfig
+    ),
+    mcp: "antigravity"
+  });
+  return artifact(target, outDir, files);
+}
+async function emitCopilot(project, target, targetConfig, outDir) {
+  const version = targetConfig.version ?? project.config.version;
+  const pluginRoot = targetConfig.pluginRoot ?? "plugins";
+  const files = /* @__PURE__ */ new Map();
+  const plugins = [];
+  for (const [pluginName, pluginConfig] of Object.entries(
+    targetConfig.plugins
+  )) {
+    const pluginPath = pluginConfig.path ?? toPosix(path5.join(pluginRoot, pluginName));
+    const pluginFiles = await collectPluginFiles(
+      project,
+      target,
+      pluginConfig.from,
+      resolveTargetComponents(target, pluginConfig)
+    );
+    for (const [relativePath, value] of pluginFiles) {
+      files.set(toPosix(path5.join(pluginPath, relativePath)), value);
+    }
+    const mcpServers = await resolveMcpServers(project, pluginConfig.from);
+    if (mcpServers) {
+      files.set(
+        toPosix(path5.join(pluginPath, ".mcp.json")),
+        json({ mcpServers })
+      );
+    }
+    const skills = [
+      ...new Set(
+        [...pluginFiles.keys()].filter((file) => file.startsWith("skills/")).map((file) => `./skills/${file.split("/")[1]}`)
+      )
+    ].sort();
+    const metadata = emittedPluginMetadata(project, pluginConfig);
+    plugins.push(
+      stripUndefined({
+        name: pluginName,
+        source: `./${pluginPath}`,
+        description: pluginConfig.description ?? metadata?.description,
+        version: pluginConfig.version ?? version,
+        skills,
+        mcpServers: mcpServers ? ".mcp.json" : void 0
+      })
+    );
+  }
+  const marketplace = stripUndefined(
+    deepMerge(
+      {
+        name: project.config.name,
+        metadata: stripUndefined({
+          description: project.config.metadata?.description,
+          version,
+          keywords: project.config.metadata?.keywords
+        }),
+        owner: project.config.metadata?.owner ?? project.config.metadata?.author,
+        plugins
+      },
+      targetConfig.manifest ?? {}
+    )
+  );
+  const marketplaceJson = json(marketplace);
+  files.set(
+    toPosix(path5.join(".claude-plugin", "marketplace.json")),
+    marketplaceJson
+  );
+  files.set(
+    toPosix(path5.join(".github", "plugin", "marketplace.json")),
+    marketplaceJson
+  );
+  return artifact(target, outDir, files);
+}
+function emittedPluginMetadata(project, pluginConfig) {
+  const sourceMetadata = pluginConfig.from.length === 1 ? project.plugins.get(pluginConfig.from[0])?.manifest : void 0;
+  return stripUndefined({
+    ...project.config.metadata,
+    ...sourceMetadata
+  });
+}
+function cursorPluginManifest(metadata, version, pluginName, pluginConfig, componentDirs2, mcpServers) {
+  const manifest = {
+    name: pluginName,
+    displayName: pluginConfig.displayName ?? metadata?.displayName ?? titleCase(pluginName),
+    version,
+    description: pluginConfig.description ?? metadata?.description,
+    author: metadata?.author,
+    homepage: metadata?.homepage,
+    repository: metadata?.repository,
+    license: metadata?.license,
+    logo: metadata?.logo,
+    keywords: metadata?.keywords,
+    category: metadata?.category,
+    tags: metadata?.tags
+  };
+  const components = pluginConfig.components ?? [
+    "skills",
+    "agents",
+    "commands",
+    "rules",
+    "hooks"
+  ];
+  for (const component of components) {
+    if (componentDirs2.has(component)) {
+      manifest[component] = `./${component}/`;
+    }
+  }
+  if (mcpServers) {
+    manifest.mcpServers = "./.mcp.json";
+  }
+  return stripUndefined(deepMerge(manifest, pluginConfig.manifest ?? {}));
+}
+function claudePluginManifest(metadata, version, pluginName, pluginConfig) {
+  const manifest = {
+    name: pluginName,
+    version,
+    description: pluginConfig.description ?? metadata?.description,
+    author: metadata?.author,
+    homepage: metadata?.homepage,
+    repository: metadata?.repository,
+    license: metadata?.license,
+    keywords: metadata?.keywords
+  };
+  return stripUndefined(deepMerge(manifest, pluginConfig.manifest ?? {}));
+}
+function antigravityPluginManifest(metadata, version, pluginName, pluginConfig) {
+  const manifest = {
+    name: pluginName,
+    version,
+    description: pluginConfig.description ?? metadata?.description
+  };
+  return stripUndefined(deepMerge(manifest, pluginConfig.manifest ?? {}));
+}
+function artifact(target, outDir, files) {
+  const managedPaths = [...files.keys()].sort();
+  return {
+    target,
+    outDir,
+    files: new Map([...files.entries()].sort(([a], [b]) => a.localeCompare(b))),
+    managedPaths
+  };
+}
+function stripUndefined(value) {
+  for (const key of Object.keys(value)) {
+    if (value[key] === void 0) {
+      delete value[key];
+    }
+  }
+  return value;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const existing = result[key];
+    result[key] = isPlainObject(existing) && isPlainObject(value) ? deepMerge(existing, value) : value;
+  }
+  return result;
+}
+function titleCase(value) {
+  return value.split(/[-_.]/).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+
+// src/build.ts
+var allTargets = ["cursor", "claude", "antigravity", "copilot"];
+async function build(options = {}) {
+  const project = await loadConfig(options.cwd, options.configPath);
+  const targets = options.target ? [options.target] : allTargets.filter((target) => project.config.targets[target]);
+  const guard = buildDeleteGuard(
+    project.rootDir,
+    project.config,
+    project.configPath
+  );
+  const artifacts = [];
+  for (const target of targets) {
+    artifacts.push(await emitTarget(project, target, options.outDir));
+  }
+  assertNoCrossTargetCollisions(artifacts);
+  if (!options.dryRun) {
+    for (const artifact2 of artifacts) {
+      await pruneManagedFiles(artifact2, { guard });
+      await writeArtifact(artifact2.outDir, artifact2.files);
+      await writeManagedManifest(artifact2);
+    }
+  }
+  return artifacts;
+}
+function assertNoCrossTargetCollisions(artifacts) {
+  const owner = /* @__PURE__ */ new Map();
+  const collisions = [];
+  for (const artifact2 of artifacts) {
+    for (const managedPath of artifact2.managedPaths) {
+      const absolute = path6.resolve(artifact2.outDir, managedPath);
+      const previous = owner.get(absolute);
+      if (previous && previous !== artifact2.target) {
+        collisions.push(`  ${previous} and ${artifact2.target}: ${absolute}`);
+      } else {
+        owner.set(absolute, artifact2.target);
+      }
+    }
+  }
+  if (collisions.length > 0) {
+    throw new Error(
+      `Targets write overlapping output paths; give them distinct outDirs:
+${collisions.join("\n")}`
+    );
+  }
+}
+
+// src/cleanup.ts
+import path7 from "path";
+async function prune(options = {}) {
+  const project = await loadProjectConfig(options.cwd, options.configPath);
+  const guard = buildDeleteGuard(
+    project.rootDir,
+    project.config,
+    project.configPath,
+    options.force
+  );
+  const artifacts = await build({
+    cwd: options.cwd,
+    configPath: options.configPath,
+    target: options.target,
+    dryRun: true
+  });
+  const results = [];
+  for (const artifact2 of artifacts) {
+    results.push(
+      await pruneManagedFiles(artifact2, { dryRun: options.dryRun, guard })
+    );
+  }
+  return results;
+}
+async function clean(options = {}) {
+  const project = await loadProjectConfig(options.cwd, options.configPath);
+  const guard = buildDeleteGuard(
+    project.rootDir,
+    project.config,
+    project.configPath,
+    options.force
+  );
+  const targets = options.target ? [options.target] : Object.keys(project.config.targets);
+  const results = [];
+  for (const target of targets) {
+    const targetConfig = project.config.targets[target];
+    if (!targetConfig) {
+      throw new Error(`Target "${target}" is not configured.`);
+    }
+    const outDir = path7.resolve(project.rootDir, targetConfig.outDir);
+    results.push(
+      await cleanManagedFiles(outDir, target, {
+        dryRun: options.dryRun,
+        guard
+      })
+    );
+  }
+  return results;
+}
+
+// src/diff.ts
+import { promises as fs5 } from "fs";
+import { tmpdir } from "os";
+import path8 from "path";
+async function diffTarget(options) {
+  const tempDir = await fs5.mkdtemp(path8.join(tmpdir(), "pluginpack-diff-"));
+  try {
+    const project = await loadConfig(options.cwd, options.configPath);
+    const ignoredDiffPaths = project.config.targets[options.target]?.ignoredDiffPaths ?? [];
+    const [artifact2] = await build({
+      cwd: options.cwd,
+      configPath: options.configPath,
+      target: options.target,
+      outDir: tempDir
+    });
+    const againstRoot = path8.resolve(
+      options.cwd ?? process.cwd(),
+      options.against
+    );
+    const entries = [];
+    const currentManagedPaths = new Set(
+      artifact2.managedPaths.map(normalizeManagedPath)
+    );
+    for (const relativePath of artifact2.managedPaths) {
+      if (isIgnoredDiffPath(relativePath, ignoredDiffPaths)) {
+        continue;
+      }
+      const generatedPath = path8.join(tempDir, relativePath);
+      const againstPath = path8.join(againstRoot, relativePath);
+      if (!await exists(againstPath)) {
+        entries.push({ type: "added", path: relativePath });
+        continue;
+      }
+      const [generated, existing] = await Promise.all([
+        fs5.readFile(generatedPath),
+        fs5.readFile(againstPath)
+      ]);
+      if (!generated.equals(existing)) {
+        entries.push({ type: "changed", path: relativePath });
+      }
+    }
+    const previous = await readManagedManifest(againstRoot, options.target);
+    for (const previousPath of previous?.files ?? []) {
+      const normalized = normalizeManagedPath(previousPath);
+      if (currentManagedPaths.has(normalized) || isIgnoredDiffPath(normalized, ignoredDiffPaths)) {
+        continue;
+      }
+      if (await exists(path8.join(againstRoot, normalized))) {
+        entries.push({ type: "removed", path: normalized });
+      }
+    }
+    return {
+      ok: entries.length === 0,
+      entries
+    };
+  } finally {
+    await fs5.rm(tempDir, { force: true, recursive: true });
+  }
+}
+function isIgnoredDiffPath(relativePath, ignoredPaths) {
+  const normalized = normalizeDiffPath(relativePath);
+  return ignoredPaths.some((ignoredPath) => {
+    const ignored = normalizeDiffPath(ignoredPath);
+    return normalized === ignored || normalized.startsWith(`${ignored}/`);
+  });
+}
+function normalizeDiffPath(value) {
+  const normalized = path8.posix.normalize(value.replace(/\\/g, "/"));
+  return normalized.startsWith("./") ? normalized.slice(2) : normalized;
+}
+
+// src/validate.ts
+import { promises as fs6, statSync } from "fs";
+import path9 from "path";
+import matter from "gray-matter";
+var pluginNamePattern = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+var marketplaceNamePattern = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+async function validateOutput(target, dir) {
+  const root = path9.resolve(dir);
+  const issues = [];
+  if (target === "cursor") {
+    await validateCursor(root, issues);
+  } else if (target === "claude") {
+    await validateClaude(root, issues);
+  } else if (target === "antigravity") {
+    await validateAntigravity(root, issues);
+  } else {
+    await validateCopilot(root, issues);
+  }
+  return {
+    ok: issues.every((issue) => issue.level !== "error"),
+    issues
+  };
+}
+async function validateAntigravity(root, issues) {
+  const entries = await fs6.readdir(root, { withFileTypes: true });
+  const pluginDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => path9.join(root, entry.name));
+  if (pluginDirs.length === 0) {
+    error(
+      issues,
+      "Antigravity output must contain at least one plugin directory."
+    );
+    return;
+  }
+  for (const pluginDir of pluginDirs) {
+    const manifest = await readJson(
+      path9.join(pluginDir, "plugin.json"),
+      "Antigravity plugin manifest",
+      issues
+    );
+    if (!manifest) {
+      continue;
+    }
+    const pluginName = path9.basename(pluginDir);
+    if (typeof manifest.name !== "string" || !pluginNamePattern.test(manifest.name)) {
+      error(
+        issues,
+        `${pluginName}: plugin.json must have a lowercase kebab-case "name".`
+      );
+    }
+    if (manifest.name && manifest.name !== pluginName) {
+      error(
+        issues,
+        `${pluginName}: manifest name must match plugin directory name.`
+      );
+    }
+    for (const field of ["version", "description"]) {
+      if (typeof manifest[field] !== "string" || !manifest[field]) {
+        error(
+          issues,
+          `${pluginName}: plugin.json is missing required field "${field}".`
+        );
+      }
+    }
+    const mcpConfigPath = path9.join(pluginDir, "mcp_config.json");
+    if (await exists(mcpConfigPath)) {
+      await readJson(mcpConfigPath, `${pluginName} MCP config`, issues);
+    }
+    await validateFrontmatter(pluginDir, pluginName, "antigravity", issues);
+    await validateHooks(pluginDir, pluginName, issues);
+  }
+}
+async function validateCopilot(root, issues) {
+  const marketplacePath = path9.join(root, ".claude-plugin", "marketplace.json");
+  const marketplace = await readJson(
+    marketplacePath,
+    "Marketplace manifest",
+    issues
+  );
+  if (!marketplace) {
+    return;
+  }
+  validateMarketplaceBasics(marketplace, issues);
+  if (!await exists(path9.join(root, ".github", "plugin", "marketplace.json"))) {
+    error(
+      issues,
+      "Copilot output must mirror the marketplace at .github/plugin/marketplace.json."
+    );
+  }
+  const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+  if (plugins.length === 0) {
+    error(issues, 'Marketplace "plugins" must be a non-empty array.');
+    return;
+  }
+  for (const [index, entry] of plugins.entries()) {
+    const pluginName = validatePluginEntry(entry, index, root, issues);
+    if (!pluginName) {
+      continue;
+    }
+    await validateFrontmatter(
+      path9.join(root, entry.source),
+      pluginName,
+      "copilot",
+      issues
+    );
+  }
+}
+async function validateCursor(root, issues) {
+  const marketplacePath = path9.join(root, ".cursor-plugin", "marketplace.json");
+  const marketplace = await readJson(
+    marketplacePath,
+    "Marketplace manifest",
+    issues
+  );
+  if (!marketplace) {
+    return;
+  }
+  validateMarketplaceBasics(marketplace, issues);
+  const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+  if (plugins.length === 0) {
+    error(issues, 'Marketplace "plugins" must be a non-empty array.');
+    return;
+  }
+  for (const [index, entry] of plugins.entries()) {
+    const pluginName = validatePluginEntry(entry, index, root, issues);
+    if (!pluginName) {
+      continue;
+    }
+    const pluginDir = path9.join(root, entry.source);
+    const manifest = await readJson(
+      path9.join(pluginDir, ".cursor-plugin", "plugin.json"),
+      `${pluginName} plugin manifest`,
+      issues
+    );
+    if (!manifest) {
+      continue;
+    }
+    if (manifest.name !== pluginName) {
+      error(
+        issues,
+        `${pluginName}: marketplace entry name does not match plugin.json name ("${manifest.name}").`
+      );
+    }
+    await validateReferencedManifestPaths(
+      pluginDir,
+      pluginName,
+      manifest,
+      ["logo", "commands", "agents", "skills", "rules", "hooks", "mcpServers"],
+      issues
+    );
+    await validateFrontmatter(pluginDir, pluginName, "cursor", issues);
+  }
+}
+async function validateClaude(root, issues) {
+  const marketplacePath = path9.join(root, ".claude-plugin", "marketplace.json");
+  const marketplace = await readJson(
+    marketplacePath,
+    "Marketplace manifest",
+    issues
+  );
+  if (!marketplace) {
+    return;
+  }
+  validateMarketplaceBasics(marketplace, issues);
+  const plugins = Array.isArray(marketplace.plugins) ? marketplace.plugins : [];
+  if (plugins.length === 0) {
+    error(issues, 'Marketplace "plugins" must be a non-empty array.');
+    return;
+  }
+  for (const [index, entry] of plugins.entries()) {
+    const pluginName = validatePluginEntry(entry, index, root, issues);
+    if (!pluginName) {
+      continue;
+    }
+    const pluginDir = path9.join(root, entry.source);
+    const manifest = await readJson(
+      path9.join(pluginDir, ".claude-plugin", "plugin.json"),
+      `${pluginName} plugin manifest`,
+      issues
+    );
+    if (!manifest) {
+      continue;
+    }
+    if (manifest.name !== pluginName) {
+      error(
+        issues,
+        `${pluginName}: marketplace entry name does not match plugin.json name ("${manifest.name}").`
+      );
+    }
+    for (const field of ["name", "version", "description"]) {
+      if (typeof manifest[field] !== "string" || !manifest[field]) {
+        error(
+          issues,
+          `${pluginName}: plugin.json is missing required field "${field}".`
+        );
+      }
+    }
+    if (!manifest.author || typeof manifest.author.name !== "string" || !manifest.author.name) {
+      error(issues, `${pluginName}: plugin.json is missing "author.name".`);
+    }
+    await validateFrontmatter(pluginDir, pluginName, "claude", issues);
+    await validateHooks(pluginDir, pluginName, issues);
+  }
+}
+function validateMarketplaceBasics(marketplace, issues) {
+  if (typeof marketplace.name !== "string" || !marketplaceNamePattern.test(marketplace.name)) {
+    error(
+      issues,
+      'Marketplace "name" must be lowercase kebab-case and start/end with an alphanumeric character.'
+    );
+  }
+  const owner = marketplace.owner;
+  if (owner && (typeof owner.name !== "string" || !owner.name)) {
+    error(
+      issues,
+      'Marketplace "owner.name" must be a non-empty string when owner is present.'
+    );
+  }
+}
+function validatePluginEntry(entry, index, root, issues) {
+  if (!entry || typeof entry !== "object") {
+    error(issues, `plugins[${index}] must be an object.`);
+    return null;
+  }
+  if (typeof entry.name !== "string" || !pluginNamePattern.test(entry.name)) {
+    error(
+      issues,
+      `plugins[${index}].name must be lowercase and use only alphanumerics, hyphens, and periods.`
+    );
+    return null;
+  }
+  if (typeof entry.source !== "string" || !isSafeRelativePath(entry.source)) {
+    error(issues, `plugins[${index}].source must be a safe relative path.`);
+    return null;
+  }
+  const pluginDir = path9.join(root, entry.source);
+  if (!entry.source.startsWith("http") && !pathExistsSync(pluginDir)) {
+    error(
+      issues,
+      `plugins[${index}].source directory is missing: ${entry.source}`
+    );
+    return null;
+  }
+  return entry.name;
+}
+async function validateReferencedManifestPaths(pluginDir, pluginName, manifest, fields, issues) {
+  for (const field of fields) {
+    for (const value of extractPathValues(manifest[field])) {
+      if (value.startsWith("http://") || value.startsWith("https://")) {
+        continue;
+      }
+      if (!isSafeRelativePath(value)) {
+        error(
+          issues,
+          `${pluginName}: field "${field}" has unsafe path "${value}".`
+        );
+        continue;
+      }
+      if (!await exists(path9.join(pluginDir, value))) {
+        error(
+          issues,
+          `${pluginName}: field "${field}" references missing path "${value}".`
+        );
+      }
+    }
+  }
+}
+function extractPathValues(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(extractPathValues);
+  }
+  if (value && typeof value === "object") {
+    const object = value;
+    return [object.path, object.file].filter(
+      (entry) => typeof entry === "string"
+    );
+  }
+  return [];
+}
+async function validateFrontmatter(pluginDir, pluginName, target, issues) {
+  const files = await walkFiles(pluginDir);
+  for (const file of files) {
+    const kind = detectFrontmatterKind(file);
+    if (!kind) {
+      continue;
+    }
+    const relative = toPosix(path9.relative(pluginDir, file));
+    const parsed = parseFrontmatter(await fs6.readFile(file, "utf8"));
+    if (!parsed.ok) {
+      error(
+        issues,
+        `${pluginName}: ${kind} frontmatter error in ${relative}: ${parsed.error}`
+      );
+      continue;
+    }
+    if (kind === "agent") {
+      requireFrontmatter(
+        pluginName,
+        kind,
+        relative,
+        parsed.value,
+        ["name", "description"],
+        issues
+      );
+    } else if (kind === "command") {
+      requireFrontmatter(
+        pluginName,
+        kind,
+        relative,
+        parsed.value,
+        ["description"],
+        issues
+      );
+      if (target === "cursor" || target === "antigravity" || target === "copilot") {
+        requireFrontmatter(
+          pluginName,
+          kind,
+          relative,
+          parsed.value,
+          ["name"],
+          issues
+        );
+      }
+    } else if (kind === "skill") {
+      if (target === "cursor") {
+        requireFrontmatter(
+          pluginName,
+          kind,
+          relative,
+          parsed.value,
+          ["name", "description"],
+          issues
+        );
+      } else if (!parsed.value.description && !parsed.value.when_to_use) {
+        error(
+          issues,
+          `${pluginName}: ${kind} frontmatter error in ${relative}: Missing required "description" field.`
+        );
+      }
+    } else if (kind === "rule") {
+      requireFrontmatter(
+        pluginName,
+        kind,
+        relative,
+        parsed.value,
+        ["description"],
+        issues
+      );
+    }
+  }
+}
+function detectFrontmatterKind(filePath) {
+  const normalized = toPosix(filePath);
+  const inSkillContent = /\/skills\/[^/]+\//.test(normalized) && !normalized.endsWith("/SKILL.md");
+  if (normalized.includes("/agents/") && /\.(md|mdc|markdown)$/.test(normalized) && !inSkillContent) {
+    return "agent";
+  }
+  if (normalized.includes("/skills/") && normalized.endsWith("/SKILL.md")) {
+    return "skill";
+  }
+  if (normalized.includes("/commands/") && /\.(md|mdc|markdown|txt)$/.test(normalized) && !inSkillContent) {
+    return "command";
+  }
+  if (normalized.includes("/rules/") && /\.(md|mdc|markdown)$/.test(normalized) && !inSkillContent) {
+    return "rule";
+  }
+  return null;
+}
+function parseFrontmatter(content) {
+  try {
+    const parsed = matter(content);
+    if (Object.keys(parsed.data).length === 0) {
+      return { ok: false, error: "No frontmatter found" };
+    }
+    return { ok: true, value: parsed.data };
+  } catch (err) {
+    return { ok: false, error: `YAML parse failed: ${err.message}` };
+  }
+}
+function requireFrontmatter(pluginName, kind, relative, frontmatter, fields, issues) {
+  for (const field of fields) {
+    if (typeof frontmatter[field] !== "string" || !frontmatter[field]) {
+      error(
+        issues,
+        `${pluginName}: ${kind} frontmatter error in ${relative}: Missing required "${field}" field.`
+      );
+    }
+  }
+}
+async function validateHooks(pluginDir, pluginName, issues) {
+  const hooksPath = path9.join(pluginDir, "hooks", "hooks.json");
+  if (!await exists(hooksPath)) {
+    return;
+  }
+  const hooks = await readJson(
+    hooksPath,
+    `${pluginName} hooks/hooks.json`,
+    issues
+  );
+  if (hooks && (!hooks.hooks || typeof hooks.hooks !== "object")) {
+    error(
+      issues,
+      `${pluginName}: hooks/hooks.json must have a "hooks" object.`
+    );
+  }
+}
+async function readJson(filePath, context, issues) {
+  try {
+    return JSON.parse(await fs6.readFile(filePath, "utf8"));
+  } catch (err) {
+    error(
+      issues,
+      `${context} is missing or invalid (${filePath}): ${err.message}`
+    );
+    return null;
+  }
+}
+function pathExistsSync(filePath) {
+  try {
+    statSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function error(issues, message) {
+  issues.push({ level: "error", message });
+}
+
+export {
+  defineConfig,
+  loadConfig,
+  build,
+  prune,
+  clean,
+  diffTarget,
+  validateOutput
+};
+//# sourceMappingURL=chunk-HR2ZVYJA.js.map