agconf 0.2.0

package/dist/chunk-B53WKCQU.js

@@ -0,0 +1,653 @@
+#!/usr/bin/env node
+
+// src/core/skill-metadata.ts
+import { createHash as createHash2 } from "crypto";
+import * as fs from "fs/promises";
+import * as path from "path";
+import fg from "fast-glob";
+
+// src/config/schema.ts
+import { z } from "zod";
+var CURRENT_CONFIG_VERSION = "1.0.0";
+var CanonicalMetaSchema = z.object({
+  /** Unique identifier for this canonical source (e.g., "acme-standards") */
+  name: z.string().min(1),
+  /** Organization name for display purposes */
+  organization: z.string().optional(),
+  /** Description of what this canonical repository provides */
+  description: z.string().optional()
+});
+var CanonicalPathsSchema = z.object({
+  /** Path to the global instructions file (e.g., "instructions/AGENTS.md") */
+  instructions: z.string().default("instructions/AGENTS.md"),
+  /** Path to the skills directory (e.g., "skills") */
+  skills_dir: z.string().default("skills"),
+  /** Path to the rules directory (e.g., "rules") - optional for backward compat */
+  rules_dir: z.string().optional()
+});
+var MarkersConfigSchema = z.object({
+  /**
+   * Prefix for marker comments in managed files.
+   * Generates markers like: <!-- {prefix}:global:start -->
+   * Default: "agent-conf"
+   */
+  prefix: z.string().default("agent-conf")
+});
+var MergeConfigSchema = z.object({
+  /** Whether to preserve repository-specific content blocks during sync */
+  preserve_repo_content: z.boolean().default(true)
+});
+var CanonicalRepoConfigSchema = z.object({
+  /** Schema version in semver format (e.g., "1.0.0") */
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Version must be in semver format (e.g., 1.0.0)"),
+  meta: CanonicalMetaSchema,
+  content: CanonicalPathsSchema.default({}),
+  /** List of supported target agents (e.g., ["claude", "codex"]) */
+  targets: z.array(z.string()).default(["claude"]),
+  markers: MarkersConfigSchema.default({}),
+  merge: MergeConfigSchema.default({})
+});
+var SourceConfigSchema = z.object({
+  /** URL of the canonical repository (e.g., "https://github.com/acme/agent-standards") */
+  url: z.string().url().optional(),
+  /** GitHub repository in owner/repo format (alternative to url) */
+  repository: z.string().optional(),
+  /** Git ref to sync from (branch, tag, or commit) */
+  ref: z.string().optional(),
+  /** Priority for conflict resolution (higher wins). Default: 0 */
+  priority: z.number().default(0)
+});
+var DownstreamConfigSchema = z.object({
+  /**
+   * List of canonical sources to sync from.
+   * For MVP, only single source is supported; multi-source is future work.
+   */
+  sources: z.array(SourceConfigSchema).min(1).optional(),
+  /** Override which targets to sync to (defaults to source repo's targets) */
+  targets: z.array(z.string()).optional()
+});
+var ResolvedConfigSchema = z.object({
+  /** Name of the canonical source */
+  name: z.string(),
+  /** Organization name */
+  organization: z.string().optional(),
+  /** Path to instructions file within source */
+  instructionsPath: z.string(),
+  /** Path to skills directory within source */
+  skillsDir: z.string(),
+  /** Path to rules directory within source - optional for backward compat */
+  rulesDir: z.string().optional(),
+  /** Marker prefix for managed content */
+  markerPrefix: z.string(),
+  /** Target agents to sync to */
+  targets: z.array(z.string()),
+  /** Whether to preserve repo-specific content during merge */
+  preserveRepoContent: z.boolean(),
+  /** CLI name for hooks and workflows */
+  cliName: z.string().default("agent-conf"),
+  /** Directory name for lockfile and config (e.g., ".agent-conf") */
+  configDir: z.string().default(".agent-conf"),
+  /** Lockfile name */
+  lockfileName: z.string().default("lockfile.json")
+});
+function getMarkers(prefix) {
+  return {
+    globalStart: `<!-- ${prefix}:global:start -->`,
+    globalEnd: `<!-- ${prefix}:global:end -->`,
+    repoStart: `<!-- ${prefix}:repo:start -->`,
+    repoEnd: `<!-- ${prefix}:repo:end -->`
+  };
+}
+function getMetadataKeys(prefix) {
+  const keyPrefix = prefix.replace(/-/g, "_");
+  return {
+    managed: `${keyPrefix}_managed`,
+    contentHash: `${keyPrefix}_content_hash`
+  };
+}
+
+// src/core/markers.ts
+import { createHash } from "crypto";
+var DEFAULT_MARKER_PREFIX = "agent-conf";
+function getMarkers2(prefix = DEFAULT_MARKER_PREFIX) {
+  return getMarkers(prefix);
+}
+function parseAgentsMd(content, options = {}) {
+  const { prefix = DEFAULT_MARKER_PREFIX } = options;
+  const markers = getMarkers2(prefix);
+  return parseWithMarkers(content, markers);
+}
+function parseWithMarkers(content, markers) {
+  const globalStartIdx = content.indexOf(markers.globalStart);
+  const globalEndIdx = content.indexOf(markers.globalEnd);
+  const repoStartIdx = content.indexOf(markers.repoStart);
+  const repoEndIdx = content.indexOf(markers.repoEnd);
+  const hasMarkers = globalStartIdx !== -1 || repoStartIdx !== -1;
+  let globalBlock = null;
+  let repoBlock = null;
+  if (globalStartIdx !== -1 && globalEndIdx !== -1 && globalEndIdx > globalStartIdx) {
+    const startContent = globalStartIdx + markers.globalStart.length;
+    globalBlock = content.slice(startContent, globalEndIdx).trim();
+  }
+  if (repoStartIdx !== -1 && repoEndIdx !== -1 && repoEndIdx > repoStartIdx) {
+    const startContent = repoStartIdx + markers.repoStart.length;
+    repoBlock = content.slice(startContent, repoEndIdx).trim();
+  }
+  return { globalBlock, repoBlock, hasMarkers };
+}
+function computeGlobalBlockHash(content) {
+  const hash = createHash("sha256").update(content.trim()).digest("hex");
+  return `sha256:${hash.slice(0, 12)}`;
+}
+function buildGlobalBlock(content, metadata, options = {}) {
+  const { prefix = DEFAULT_MARKER_PREFIX, cliName = "agent-conf" } = options;
+  const markers = getMarkers2(prefix);
+  const contentHash = metadata.contentHash ?? computeGlobalBlockHash(content);
+  const lines = [
+    markers.globalStart,
+    `<!-- DO NOT EDIT THIS SECTION - Managed by ${cliName} CLI -->`,
+    `<!-- Content hash: ${contentHash} -->`,
+    "",
+    content.trim(),
+    "",
+    markers.globalEnd
+  ];
+  return lines.join("\n");
+}
+function buildRepoBlock(content, options = {}) {
+  const { prefix = DEFAULT_MARKER_PREFIX } = options;
+  const markers = getMarkers2(prefix);
+  const lines = [
+    markers.repoStart,
+    "<!-- Repository-specific instructions below -->",
+    "",
+    content?.trim() ?? "",
+    "",
+    markers.repoEnd
+  ];
+  return lines.join("\n");
+}
+function buildAgentsMd(globalContent, repoContent, metadata, options = {}) {
+  const globalBlock = buildGlobalBlock(globalContent, metadata, options);
+  const repoBlock = buildRepoBlock(repoContent, options);
+  return `${globalBlock}
+
+${repoBlock}
+`;
+}
+function extractRepoBlockContent(parsed) {
+  if (!parsed.repoBlock) return null;
+  const lines = parsed.repoBlock.split("\n");
+  const filtered = lines.filter((line) => {
+    const trimmed = line.trim();
+    return trimmed !== "<!-- Repository-specific instructions below -->";
+  });
+  const result = filtered.join("\n").trim();
+  return result || null;
+}
+function stripMetadataComments(globalBlock) {
+  const lines = globalBlock.split("\n");
+  const filteredLines = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("<!-- DO NOT EDIT")) return false;
+    if (trimmed.startsWith("<!-- Source:")) return false;
+    if (trimmed.startsWith("<!-- Last synced:")) return false;
+    if (trimmed.startsWith("<!-- Content hash:")) return false;
+    return true;
+  });
+  return filteredLines.join("\n").trim();
+}
+function parseGlobalBlockMetadata(globalBlock) {
+  const result = {};
+  const sourceMatch = globalBlock.match(/<!--\s*Source:\s*(.+?)\s*-->/);
+  if (sourceMatch?.[1]) {
+    result.source = sourceMatch[1];
+  }
+  const syncedMatch = globalBlock.match(/<!--\s*Last synced:\s*(.+?)\s*-->/);
+  if (syncedMatch?.[1]) {
+    result.syncedAt = syncedMatch[1];
+  }
+  const hashMatch = globalBlock.match(/<!--\s*Content hash:\s*(.+?)\s*-->/);
+  if (hashMatch?.[1]) {
+    result.contentHash = hashMatch[1];
+  }
+  return result;
+}
+function hasGlobalBlockChanges(agentsMdContent, options = {}) {
+  const parsed = parseAgentsMd(agentsMdContent, options);
+  if (!parsed.globalBlock) {
+    return false;
+  }
+  const metadata = parseGlobalBlockMetadata(parsed.globalBlock);
+  if (!metadata.contentHash) {
+    return false;
+  }
+  const content = stripMetadataComments(parsed.globalBlock);
+  const currentHash = computeGlobalBlockHash(content);
+  return metadata.contentHash !== currentHash;
+}
+function isAgentsMdManaged(agentsMdContent, options = {}) {
+  const parsed = parseAgentsMd(agentsMdContent, options);
+  return parsed.hasMarkers && parsed.globalBlock !== null;
+}
+function parseRulesSection(agentsMdContent, options = {}) {
+  const { prefix = DEFAULT_MARKER_PREFIX } = options;
+  const rulesStartMarker = `<!-- ${prefix}:rules:start -->`;
+  const rulesEndMarker = `<!-- ${prefix}:rules:end -->`;
+  const startIdx = agentsMdContent.indexOf(rulesStartMarker);
+  const endIdx = agentsMdContent.indexOf(rulesEndMarker);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return { content: null, hasMarkers: false };
+  }
+  const content = agentsMdContent.slice(startIdx + rulesStartMarker.length, endIdx).trim();
+  return { content, hasMarkers: true };
+}
+function parseRulesSectionMetadata(rulesSection) {
+  const result = {};
+  const hashMatch = rulesSection.match(/<!--\s*Content hash:\s*(.+?)\s*-->/);
+  if (hashMatch?.[1]) {
+    result.contentHash = hashMatch[1];
+  }
+  const countMatch = rulesSection.match(/<!--\s*Rule count:\s*(\d+)\s*-->/);
+  if (countMatch?.[1]) {
+    result.ruleCount = Number.parseInt(countMatch[1], 10);
+  }
+  return result;
+}
+function stripRulesSectionMetadata(rulesSection) {
+  const lines = rulesSection.split("\n");
+  const filteredLines = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("<!-- DO NOT EDIT")) return false;
+    if (trimmed.startsWith("<!-- Content hash:")) return false;
+    if (trimmed.startsWith("<!-- Rule count:")) return false;
+    return true;
+  });
+  return filteredLines.join("\n").trim();
+}
+function computeRulesSectionHash(content) {
+  const hash = createHash("sha256").update(content.trim()).digest("hex");
+  return `sha256:${hash.slice(0, 12)}`;
+}
+function hasRulesSectionChanges(agentsMdContent, options = {}) {
+  const parsed = parseRulesSection(agentsMdContent, options);
+  if (!parsed.content) {
+    return false;
+  }
+  const metadata = parseRulesSectionMetadata(parsed.content);
+  if (!metadata.contentHash) {
+    return false;
+  }
+  const content = stripRulesSectionMetadata(parsed.content);
+  const currentHash = computeRulesSectionHash(content);
+  return metadata.contentHash !== currentHash;
+}
+
+// src/core/skill-metadata.ts
+var DEFAULT_METADATA_PREFIX = "agent-conf";
+function getMetadataKeyNames(prefix = DEFAULT_METADATA_PREFIX) {
+  return getMetadataKeys(prefix);
+}
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match || !match[1]) {
+    return { frontmatter: {}, body: content, raw: "" };
+  }
+  const rawYaml = match[1];
+  const body = content.slice(match[0].length);
+  const frontmatter = parseSimpleYaml(rawYaml);
+  return { frontmatter, body, raw: rawYaml };
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  let currentKey = null;
+  let nestedObject = null;
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    if (line.startsWith("  ") && currentKey && nestedObject !== null) {
+      const nestedMatch = line.match(/^\s+(\w+):\s*["']?(.*)["']?$/);
+      if (nestedMatch?.[1] && nestedMatch[2] !== void 0) {
+        const key = nestedMatch[1];
+        const value = nestedMatch[2];
+        nestedObject[key] = value.replace(/^["']|["']$/g, "");
+      }
+      continue;
+    }
+    if (currentKey && nestedObject !== null) {
+      result[currentKey] = nestedObject;
+      nestedObject = null;
+    }
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match?.[1] && match[2] !== void 0) {
+      const key = match[1];
+      const value = match[2];
+      currentKey = key;
+      if (value.trim() === "") {
+        nestedObject = {};
+      } else {
+        result[key] = value.replace(/^["']|["']$/g, "");
+      }
+    }
+  }
+  if (currentKey && nestedObject !== null) {
+    result[currentKey] = nestedObject;
+  }
+  return result;
+}
+function serializeFrontmatter(frontmatter) {
+  const lines = [];
+  for (const [key, value] of Object.entries(frontmatter)) {
+    if (typeof value === "object" && value !== null) {
+      lines.push(`${key}:`);
+      for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        const quotedValue = needsQuoting(String(nestedValue)) ? `"${String(nestedValue)}"` : String(nestedValue);
+        lines.push(`  ${nestedKey}: ${quotedValue}`);
+      }
+    } else {
+      const strValue = String(value);
+      if (strValue.length > 80 || strValue.includes("\n")) {
+        lines.push(`${key}: ${strValue}`);
+      } else {
+        lines.push(`${key}: ${strValue}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function validateSkillFrontmatter(content, skillName, filePath) {
+  const { frontmatter } = parseFrontmatter(content);
+  const errors = [];
+  if (Object.keys(frontmatter).length === 0) {
+    errors.push("Missing frontmatter (must have --- delimiters)");
+  } else {
+    if (!frontmatter.name) {
+      errors.push("Missing required field: name");
+    }
+    if (!frontmatter.description) {
+      errors.push("Missing required field: description");
+    }
+  }
+  if (errors.length > 0) {
+    return { skillName, path: filePath, errors };
+  }
+  return null;
+}
+function needsQuoting(value) {
+  return value.includes(":") || value.includes("#") || value.includes("@") || value === "true" || value === "false" || /^\d+$/.test(value);
+}
+function computeContentHash(content, options = {}) {
+  const stripped = stripManagedMetadata(content, options);
+  const hash = createHash2("sha256").update(stripped).digest("hex");
+  return `sha256:${hash.slice(0, 12)}`;
+}
+function stripManagedMetadata(content, options = {}) {
+  const { metadataPrefix = DEFAULT_METADATA_PREFIX } = options;
+  const { frontmatter, body } = parseFrontmatter(content);
+  if (Object.keys(frontmatter).length === 0) {
+    return content;
+  }
+  const keyPrefix = `${metadataPrefix.replace(/-/g, "_")}_`;
+  if (frontmatter.metadata && typeof frontmatter.metadata === "object") {
+    const metadata = frontmatter.metadata;
+    const cleanedMetadata = {};
+    for (const [key, value] of Object.entries(metadata)) {
+      if (!key.startsWith(keyPrefix)) {
+        cleanedMetadata[key] = value;
+      }
+    }
+    if (Object.keys(cleanedMetadata).length > 0) {
+      frontmatter.metadata = cleanedMetadata;
+    } else {
+      delete frontmatter.metadata;
+    }
+  }
+  const yamlContent = serializeFrontmatter(frontmatter);
+  return `---
+${yamlContent}
+---
+${body}`;
+}
+function addManagedMetadata(content, options = {}) {
+  const { metadataPrefix = DEFAULT_METADATA_PREFIX } = options;
+  const { frontmatter, body } = parseFrontmatter(content);
+  const contentHash = computeContentHash(content, options);
+  if (!frontmatter.metadata || typeof frontmatter.metadata !== "object") {
+    frontmatter.metadata = {};
+  }
+  const metadata = frontmatter.metadata;
+  const keys = getMetadataKeyNames(metadataPrefix);
+  metadata[keys.managed] = "true";
+  metadata[keys.contentHash] = contentHash;
+  const yamlContent = serializeFrontmatter(frontmatter);
+  return `---
+${yamlContent}
+---
+${body}`;
+}
+function hasManualChanges(content, options = {}) {
+  const { metadataPrefix = DEFAULT_METADATA_PREFIX } = options;
+  const { frontmatter } = parseFrontmatter(content);
+  if (!frontmatter.metadata || typeof frontmatter.metadata !== "object") {
+    return false;
+  }
+  const metadata = frontmatter.metadata;
+  const keys = getMetadataKeyNames(metadataPrefix);
+  const storedHash = metadata[keys.contentHash];
+  if (!storedHash) {
+    return false;
+  }
+  const currentHash = computeContentHash(content, options);
+  return storedHash !== currentHash;
+}
+function isManaged(content, options = {}) {
+  const { metadataPrefix = DEFAULT_METADATA_PREFIX } = options;
+  const { frontmatter } = parseFrontmatter(content);
+  if (!frontmatter.metadata || typeof frontmatter.metadata !== "object") {
+    return false;
+  }
+  const metadata = frontmatter.metadata;
+  const keys = getMetadataKeyNames(metadataPrefix);
+  return metadata[keys.managed] === "true";
+}
+async function checkSkillFiles(targetDir, targets = ["claude"], options = {}) {
+  const results = [];
+  for (const target of targets) {
+    const skillsDir = path.join(targetDir, `.${target}`, "skills");
+    try {
+      await fs.access(skillsDir);
+    } catch {
+      continue;
+    }
+    const skillFiles = await fg("*/SKILL.md", {
+      cwd: skillsDir,
+      absolute: false
+    });
+    for (const skillFile of skillFiles) {
+      const fullPath = path.join(skillsDir, skillFile);
+      const skillName = path.dirname(skillFile);
+      const relativePath = path.join(`.${target}`, "skills", skillFile);
+      try {
+        const content = await fs.readFile(fullPath, "utf-8");
+        const fileIsManaged = isManaged(content, options);
+        const hasChanges = fileIsManaged && hasManualChanges(content, options);
+        results.push({
+          path: relativePath,
+          skillName,
+          isManaged: fileIsManaged,
+          hasChanges
+        });
+      } catch (_error) {
+      }
+    }
+  }
+  return results;
+}
+async function getModifiedSkillFiles(targetDir, targets = ["claude"], options = {}) {
+  const allFiles = await checkSkillFiles(targetDir, targets, options);
+  return allFiles.filter((f) => f.hasChanges);
+}
+async function checkRuleFiles(targetDir, targets = ["claude"], options = {}) {
+  const results = [];
+  for (const target of targets) {
+    const rulesDir = path.join(targetDir, `.${target}`, "rules");
+    try {
+      await fs.access(rulesDir);
+    } catch {
+      continue;
+    }
+    const ruleFiles = await fg("**/*.md", {
+      cwd: rulesDir,
+      absolute: false
+    });
+    for (const ruleFile of ruleFiles) {
+      const fullPath = path.join(rulesDir, ruleFile);
+      const relativePath = path.join(`.${target}`, "rules", ruleFile);
+      try {
+        const content = await fs.readFile(fullPath, "utf-8");
+        const fileIsManaged = isManaged(content, options);
+        const hasChanges = fileIsManaged && hasManualChanges(content, options);
+        const { frontmatter } = parseFrontmatter(content);
+        const metadata = frontmatter.metadata;
+        const keyPrefix = (options.metadataPrefix || "agent-conf").replace(/-/g, "_");
+        const rulePath = metadata?.[`${keyPrefix}_source_path`] || ruleFile;
+        results.push({
+          path: relativePath,
+          rulePath,
+          isManaged: fileIsManaged,
+          hasChanges
+        });
+      } catch (_error) {
+      }
+    }
+  }
+  return results;
+}
+async function getModifiedRuleFiles(targetDir, targets = ["claude"], options = {}) {
+  const allFiles = await checkRuleFiles(targetDir, targets, options);
+  return allFiles.filter((f) => f.hasChanges);
+}
+async function checkAgentsMd(targetDir, options = {}) {
+  const agentsMdPath = path.join(targetDir, "AGENTS.md");
+  try {
+    const content = await fs.readFile(agentsMdPath, "utf-8");
+    const managed = isAgentsMdManaged(content, options);
+    if (!managed) {
+      return null;
+    }
+    const hasChanges = hasGlobalBlockChanges(content, options);
+    const parsed = parseAgentsMd(content, options);
+    let source;
+    let syncedAt;
+    if (parsed.globalBlock) {
+      const metadata = parseGlobalBlockMetadata(parsed.globalBlock);
+      source = metadata.source;
+      syncedAt = metadata.syncedAt;
+    }
+    const result = {
+      path: "AGENTS.md",
+      type: "agents",
+      isManaged: managed,
+      hasChanges
+    };
+    if (source !== void 0) result.source = source;
+    if (syncedAt !== void 0) result.syncedAt = syncedAt;
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function checkAllManagedFiles(targetDir, targets = ["claude"], options = {}) {
+  const results = [];
+  const markerOptions = options.markerPrefix ? { prefix: options.markerPrefix } : {};
+  const metadataOptions = options.metadataPrefix ? { metadataPrefix: options.metadataPrefix } : {};
+  const agentsMdResult = await checkAgentsMd(targetDir, markerOptions);
+  if (agentsMdResult) {
+    results.push(agentsMdResult);
+  }
+  const rulesSectionResult = await checkAgentsMdRulesSection(targetDir, markerOptions);
+  if (rulesSectionResult) {
+    results.push(rulesSectionResult);
+  }
+  const skillFiles = await checkSkillFiles(targetDir, targets, metadataOptions);
+  for (const skill of skillFiles) {
+    if (skill.isManaged) {
+      results.push({
+        path: skill.path,
+        type: "skill",
+        skillName: skill.skillName,
+        isManaged: skill.isManaged,
+        hasChanges: skill.hasChanges
+      });
+    }
+  }
+  const ruleFiles = await checkRuleFiles(targetDir, targets, metadataOptions);
+  for (const rule of ruleFiles) {
+    if (rule.isManaged) {
+      results.push({
+        path: rule.path,
+        type: "rule",
+        rulePath: rule.rulePath,
+        isManaged: rule.isManaged,
+        hasChanges: rule.hasChanges
+      });
+    }
+  }
+  return results;
+}
+async function checkAgentsMdRulesSection(targetDir, options = {}) {
+  const agentsMdPath = path.join(targetDir, "AGENTS.md");
+  try {
+    const content = await fs.readFile(agentsMdPath, "utf-8");
+    const parsed = parseRulesSection(content, options);
+    if (!parsed.hasMarkers || !parsed.content) {
+      return null;
+    }
+    const hasChanges = hasRulesSectionChanges(content, options);
+    return {
+      path: "AGENTS.md",
+      type: "rules-section",
+      isManaged: true,
+      hasChanges
+    };
+  } catch {
+    return null;
+  }
+}
+async function getModifiedManagedFiles(targetDir, targets = ["claude"], options = {}) {
+  const allFiles = await checkAllManagedFiles(targetDir, targets, options);
+  return allFiles.filter((f) => f.hasChanges);
+}
+
+export {
+  CURRENT_CONFIG_VERSION,
+  CanonicalRepoConfigSchema,
+  parseAgentsMd,
+  computeGlobalBlockHash,
+  buildAgentsMd,
+  extractRepoBlockContent,
+  stripMetadataComments,
+  parseGlobalBlockMetadata,
+  parseRulesSection,
+  parseRulesSectionMetadata,
+  stripRulesSectionMetadata,
+  computeRulesSectionHash,
+  getMetadataKeyNames,
+  parseFrontmatter,
+  validateSkillFrontmatter,
+  computeContentHash,
+  stripManagedMetadata,
+  addManagedMetadata,
+  hasManualChanges,
+  isManaged,
+  checkSkillFiles,
+  getModifiedSkillFiles,
+  checkRuleFiles,
+  getModifiedRuleFiles,
+  checkAgentsMd,
+  checkAllManagedFiles,
+  checkAgentsMdRulesSection,
+  getModifiedManagedFiles
+};
+//# sourceMappingURL=chunk-B53WKCQU.js.map