@skaile/workspaces 5.15.0 → 5.16.0

package/dist/chunk-FWAJUWXQ.js

@@ -0,0 +1,1016 @@
+import { registeredAssetKeys, unresolvedManifestDependencies, warnIgnoredDomainFiles, warnLegacyBundleFiles, removedDomainOption, rejectRemovedDomainOption, reportLibrarySymlinks, composeRefContext, assetEntryRef, manifestPublisherProblems, manifestRootProblems, manifestEntryNameProblems, manifestRequiresProblems, findAssetManifestFile, declaredVersion, manifestVersionMismatchMessage, checkAsset, invalidSemverText } from './chunk-5CE6J4DB.js';
+import { AI_RESOURCES } from './chunk-WKEBNB5S.js';
+import { logErr, logInfo, logWarn, logOk } from './chunk-VJ2DZLDM.js';
+import { getKindRegistry } from './chunk-2SKPPIV7.js';
+import { validateFlowVersions } from './chunk-D5REDKVU.js';
+import { loadFlow } from './chunk-SPV2CXJ3.js';
+import { flowSkillVersionPins } from './chunk-7RGTAEG6.js';
+import { missingRootAssets, assertManifestEditable } from './chunk-D3PU3C6F.js';
+import { parseManifestFile } from './chunk-ES6ARJPQ.js';
+import { resolveRuntimeAssets } from './chunk-5RDZ5JHH.js';
+import { decodeSkaileYaml, normalizeAgentInstances, agentBlockKeyDiagnostics, agentInstanceDiagnostics, localConnectorMountDir, isInsideProject, resolveAgentDefinitionDir, AgentRefResolutionError } from './chunk-ZVZTCDUN.js';
+import { SKAILE_MANIFEST_FILENAME, loadSkPublishManifest, isNonAssetPath } from './chunk-H7R7R5BN.js';
+import { readAssetBody } from './chunk-YW2BNDSE.js';
+import { parseAssetRef, isValidAssetName, ASSET_NAME_HINT } from './chunk-FT4ZHLYR.js';
+import { execFileSync } from 'child_process';
+import fs2 from 'fs';
+import path2 from 'path';
+import { Command } from 'commander';
+import { parse } from 'yaml';
+
+// cli/src/type-guards.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// cli/src/commands/validate-instances.ts
+var AGENT_MANIFEST_FILE = "agent.yaml";
+var TRIGGER_REQUIRED_FIELDS = {
+  schedule: ["cron", "prompt"],
+  webhook: ["prompt"],
+  channel: ["when"],
+  event: ["event"]
+};
+var err = (code, message, at) => ({
+  code,
+  severity: "error",
+  message,
+  path: at
+});
+function readAssetFacts(manifest) {
+  const facts = {
+    lifecycle: manifest.lifecycle,
+    hasIo: manifest.io !== void 0 && manifest.io !== null,
+    connectorSlots: [],
+    otherSlots: [],
+    triggerIds: []
+  };
+  for (const item of Array.isArray(manifest.composes) ? manifest.composes : []) {
+    if (!isRecord(item) || typeof item.id !== "string") continue;
+    (item.kind === "connector" ? facts.connectorSlots : facts.otherSlots).push(item.id);
+  }
+  for (const t of Array.isArray(manifest.triggers) ? manifest.triggers : []) {
+    if (isRecord(t) && typeof t.id === "string") facts.triggerIds.push(t.id);
+  }
+  return facts;
+}
+function loadAsset(projectDir, id, ref) {
+  const at = `agents.${id}.ref`;
+  let dir;
+  try {
+    dir = resolveAgentDefinitionDir(projectDir, ref);
+  } catch (e) {
+    if (!(e instanceof AgentRefResolutionError)) throw e;
+    return { diagnostic: err("agent_ref_unresolved", `agents.${id}: ${e.message}`, at) };
+  }
+  if (dir === void 0) {
+    return {
+      diagnostic: err(
+        "agent_ref_unresolved",
+        `agents.${id}: ref "${ref}" cannot be resolved \u2014 no ai-assets/ directory above the project`,
+        at
+      )
+    };
+  }
+  const manifestPath = path2.join(dir, AGENT_MANIFEST_FILE);
+  let text;
+  try {
+    text = fs2.readFileSync(manifestPath, "utf-8");
+  } catch {
+    return {
+      diagnostic: err(
+        "agent_ref_unresolved",
+        `agents.${id}: ref "${ref}" resolves to ${dir}, which has no ${AGENT_MANIFEST_FILE}`,
+        at
+      )
+    };
+  }
+  let manifest;
+  try {
+    manifest = parse(text);
+  } catch (e) {
+    return {
+      diagnostic: err(
+        "agent_manifest_invalid",
+        `agents.${id}: ${manifestPath} is not valid YAML: ${e instanceof Error ? e.message : String(e)}`,
+        at
+      )
+    };
+  }
+  if (!isRecord(manifest)) {
+    return {
+      diagnostic: err(
+        "agent_manifest_invalid",
+        `agents.${id}: ${manifestPath} is not a mapping`,
+        at
+      )
+    };
+  }
+  return { facts: readAssetFacts(manifest) };
+}
+function checkTriggers(id, triggers, assetTriggerIds) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  triggers.forEach((trigger, i) => {
+    const at = `agents.${id}.triggers[${i}]`;
+    if (seen.has(trigger.id)) {
+      out.push(
+        err(
+          "agent_trigger_duplicate",
+          `agents.${id}: trigger id "${trigger.id}" is declared twice`,
+          `${at}.id`
+        )
+      );
+      return;
+    }
+    seen.add(trigger.id);
+    if (!assetTriggerIds || assetTriggerIds.includes(trigger.id)) return;
+    if (!trigger.kind) {
+      out.push(
+        err(
+          "agent_trigger_unknown",
+          `agents.${id}: trigger "${trigger.id}" is not declared by the agent asset (${assetTriggerIds.length > 0 ? `has: ${assetTriggerIds.join(", ")}` : "it declares no triggers"}) \u2014 add \`kind\` and the trigger's fields to declare a new one`,
+          `${at}.id`
+        )
+      );
+      return;
+    }
+    const missing = TRIGGER_REQUIRED_FIELDS[trigger.kind].filter(
+      (field) => trigger[field] === void 0
+    );
+    if (missing.length > 0) {
+      out.push(
+        err(
+          "agent_trigger_incomplete",
+          `agents.${id}: trigger "${trigger.id}" (kind ${trigger.kind}) is not in the asset, so it must declare ${missing.join(", ")}`,
+          at
+        )
+      );
+    }
+  });
+  return out;
+}
+function checkConnectors(id, instance, facts, connectorIds) {
+  const out = [];
+  for (const [slot, connectorId] of Object.entries(instance.connectors ?? {})) {
+    const at = `agents.${id}.connectors.${slot}`;
+    if (!facts.connectorSlots.includes(slot)) {
+      const hint = facts.otherSlots.includes(slot) ? `"${slot}" is a slot of a non-connector item` : facts.connectorSlots.length > 0 ? `the asset's connector slots are: ${facts.connectorSlots.join(", ")}` : "the asset declares no connector slots";
+      out.push(
+        err(
+          "agent_connector_slot_unknown",
+          `agents.${id}: connectors.${slot} is not a connector slot id of the agent asset (${hint})`,
+          at
+        )
+      );
+    }
+    if (!connectorIds.includes(connectorId)) {
+      out.push(
+        err(
+          "agent_connector_unknown",
+          `agents.${id}: connectors.${slot} points at "${connectorId}", which is not in skaile.yaml connectors[]${connectorIds.length > 0 ? ` (has: ${connectorIds.join(", ")})` : ""}`,
+          at
+        )
+      );
+    }
+  }
+  return out;
+}
+function checkAgentInstances(projectDir, parsed) {
+  const diagnostics = [];
+  const instances = normalizeAgentInstances(parsed.agents, diagnostics);
+  const agent = isRecord(parsed.agent) ? parsed.agent : void 0;
+  diagnostics.push(...agentBlockKeyDiagnostics(parsed.agent));
+  if (agent?.subagents !== void 0) {
+    diagnostics.push(
+      err(
+        "agent_subagents_removed",
+        "`agent.subagents` was removed \u2014 declare each subagent as an agent asset and bind it under `agents:` with `lifecycle: role`",
+        "agent.subagents"
+      )
+    );
+  }
+  if (agent?.instances !== void 0) {
+    diagnostics.push(
+      err(
+        "misplaced_agent_instances",
+        "`agent.instances` is not a skaile.yaml key \u2014 declare instances under root `agents:`",
+        "agent.instances"
+      )
+    );
+  }
+  diagnostics.push(
+    ...agentInstanceDiagnostics({
+      agent: {
+        definition: typeof agent?.definition === "string" ? agent.definition : void 0,
+        instances
+      }
+    })
+  );
+  if (!instances) return diagnostics;
+  const connectorIds = (Array.isArray(parsed.connectors) ? parsed.connectors : []).flatMap(
+    (c) => isRecord(c) && typeof c.id === "string" ? [c.id] : []
+  );
+  for (const [id, instance] of Object.entries(instances)) {
+    const loaded = loadAsset(projectDir, id, instance.ref);
+    if ("diagnostic" in loaded) {
+      diagnostics.push(loaded.diagnostic, ...checkTriggers(id, instance.triggers ?? [], void 0));
+      continue;
+    }
+    const { facts } = loaded;
+    const lifecycle = instance.lifecycle ?? facts.lifecycle ?? "standing";
+    if (lifecycle === "role" && !facts.hasIo) {
+      diagnostics.push(
+        err(
+          "agent_role_missing_io",
+          `agents.${id}: lifecycle "role" needs the agent asset to declare \`io\` ({ input, output } JSON Schemas)`,
+          `agents.${id}.lifecycle`
+        )
+      );
+    }
+    diagnostics.push(...checkConnectors(id, instance, facts, connectorIds));
+    diagnostics.push(...checkTriggers(id, instance.triggers ?? [], facts.triggerIds));
+  }
+  return diagnostics;
+}
+
+// cli/src/commands/validate.ts
+var MANIFEST_GLOBS = [
+  { pattern: /\/SKILL\.md$/, kind: "skill" },
+  { pattern: /\/agent\.yaml$/, kind: "agent" },
+  { pattern: /\/AGENT\.md$/, kind: "agent" },
+  { pattern: /\/CONTRACT\.md$/, kind: "contract" },
+  { pattern: /\.flow\.yaml$/, kind: "flow" },
+  { pattern: /\.flow\.json$/, kind: "flow" },
+  { pattern: /\/CONNECTOR\.md$/, kind: "connector" },
+  { pattern: /\.prompt\.md$/, kind: "prompt" },
+  { pattern: /\/MCP\.md$/, kind: "mcp-server" },
+  { pattern: /\/knowledge\.yaml$/, kind: "knowledge" },
+  { pattern: /\/knowledge\/index\.yaml$/, kind: "knowledge" },
+  { pattern: /\.preset\.yaml$/, kind: "preset" }
+];
+var HARNESS_DIRS = /* @__PURE__ */ new Set([".claude", ".codex", ".omp"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".git",
+  ".skaile",
+  "__pycache__",
+  ...HARNESS_DIRS
+]);
+function findManifestCandidates(rootPath) {
+  const candidates = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(fullPath);
+      } else if (entry.isFile()) {
+        for (const glob of MANIFEST_GLOBS) {
+          if (glob.pattern.test(fullPath)) {
+            candidates.push({ filePath: fullPath, kind: glob.kind });
+            break;
+          }
+        }
+      }
+    }
+  }
+  walk(rootPath);
+  return candidates;
+}
+function parseManifestCandidate(c, absRoot) {
+  const content = fs2.readFileSync(c.filePath, "utf-8");
+  const res = parseManifestFile(c.filePath, content);
+  if (!res.ok) {
+    logErr(`${path2.relative(absRoot, c.filePath)} [${c.kind}] \u2014 parse error: ${res.reason}`);
+    return { kind: "error" };
+  }
+  return {
+    kind: "value",
+    parsed: res.data,
+    body: readAssetBody(c.filePath, content)
+  };
+}
+function libraryRootOf(absRoot) {
+  for (let dir = absRoot; ; dir = path2.dirname(dir)) {
+    if (fs2.existsSync(path2.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path2.dirname(dir) === dir) return absRoot;
+  }
+}
+function validateManifestCandidate(c, parsed, body, absRoot, registry, strictConformance, composeRefs) {
+  const relPath = path2.relative(absRoot, c.filePath);
+  let errors = 0;
+  let warnings = 0;
+  const dirName = path2.basename(path2.dirname(c.filePath));
+  const checked = checkAsset(
+    c.kind,
+    parsed ?? {},
+    body,
+    dirName,
+    registry,
+    fs2.readFileSync(c.filePath, "utf-8"),
+    path2.basename(c.filePath),
+    { dir: path2.dirname(c.filePath), libraryRoot: libraryRootOf(absRoot), composeRefs }
+  );
+  for (const f of checked.errors) {
+    logErr(`${relPath} [${f.tag}] \u2014 ${f.text}`);
+    errors++;
+  }
+  for (const f of checked.advisories) {
+    const line = `${relPath} [${f.tag}] \u2014 ${f.text}`;
+    if (f.conformance && strictConformance || f.scaffoldBody) {
+      logErr(line);
+      errors++;
+    } else {
+      logWarn(line);
+      warnings++;
+    }
+  }
+  return { errors, warnings };
+}
+function scanIdentities(root) {
+  const identities = /* @__PURE__ */ new Set();
+  for (const c of findManifestCandidates(root)) {
+    let parsed;
+    try {
+      const res = parseManifestFile(c.filePath, fs2.readFileSync(c.filePath, "utf-8"));
+      if (!res.ok) continue;
+      parsed = res.data;
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object") continue;
+    const identity = parsed[c.kind === "flow" ? "id" : "name"];
+    if (typeof identity === "string" && identity.length > 0)
+      identities.add(`${c.kind}:${identity}`);
+  }
+  return identities;
+}
+function validateManifests(rootPath, strictConformance, registeredAssets = /* @__PURE__ */ new Set()) {
+  const absRoot = path2.resolve(rootPath);
+  if (!fs2.existsSync(absRoot)) {
+    logErr(`Path does not exist: ${absRoot}`);
+    return { total: 0, errors: 1, warnings: 0 };
+  }
+  const registry = getKindRegistry();
+  const candidates = findManifestCandidates(absRoot);
+  const isLibrary = fs2.existsSync(path2.join(absRoot, SKAILE_MANIFEST_FILENAME));
+  let errors = reportLibrarySymlinks(absRoot, {
+    wholeTree: isLibrary,
+    skipDirs: isLibrary ? void 0 : HARNESS_DIRS
+  });
+  let warnings = 0;
+  const seenIdentity = /* @__PURE__ */ new Map();
+  const libraryRoot = libraryRootOf(absRoot);
+  const composeRefs = composeRefContext(
+    scanIdentities(libraryRoot),
+    registeredAssets,
+    loadSkPublishManifest(libraryRoot)?.publisher
+  );
+  for (const c of candidates) {
+    const parseResult = parseManifestCandidate(c, absRoot);
+    if (parseResult.kind === "error") {
+      errors++;
+      continue;
+    }
+    const delta = validateManifestCandidate(
+      c,
+      parseResult.parsed,
+      parseResult.body,
+      absRoot,
+      registry,
+      strictConformance,
+      composeRefs
+    );
+    errors += delta.errors;
+    warnings += delta.warnings;
+    const obj = parseResult.parsed;
+    const identity = obj && typeof obj === "object" ? obj[c.kind === "flow" ? "id" : "name"] : null;
+    if (typeof identity === "string" && identity.length > 0) {
+      const dir = path2.dirname(c.filePath);
+      const key = `${c.kind}:${identity}`;
+      const first = seenIdentity.get(key);
+      if (first === void 0) {
+        seenIdentity.set(key, dir);
+      } else if (first !== dir) {
+        logErr(
+          `${path2.relative(absRoot, c.filePath)} [${c.kind}] \u2014 ${key} is also defined in ${path2.relative(absRoot, first) || "."}; two directories cannot share a kind and name (\`skaile library index\` keeps only the first).`
+        );
+        errors++;
+      }
+    }
+  }
+  return { total: candidates.length, errors, warnings };
+}
+function findWorkspaceManifests(rootPath) {
+  const out = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(full);
+      } else if (entry.isFile() && /(^|\.)skaile\.yaml$/.test(entry.name)) {
+        out.push(full);
+      }
+    }
+  }
+  walk(rootPath);
+  return out;
+}
+function collectWorkspaceRefFields(parsed) {
+  const refFields = [];
+  if (Array.isArray(parsed.dependencies)) {
+    for (const d of parsed.dependencies) {
+      if (typeof d === "string") refFields.push(["dependencies", d]);
+    }
+  }
+  if (Array.isArray(parsed.overrides)) {
+    for (const o of parsed.overrides) {
+      const ref = o?.ref;
+      if (typeof ref === "string") refFields.push(["overrides.ref", ref]);
+    }
+  }
+  return refFields;
+}
+function validateWorkspaceRefs(refFields, relPath) {
+  let errors = 0;
+  for (const [field, ref] of refFields) {
+    try {
+      parseAssetRef(ref);
+    } catch (e) {
+      logErr(`${relPath} [${field}] \u2014 ${e instanceof Error ? e.message : String(e)}`);
+      errors++;
+    }
+  }
+  return errors;
+}
+function validateWorkspaceAssets(parsed, relPath) {
+  if (!Array.isArray(parsed.assets)) return 0;
+  let errors = 0;
+  const topPublisher = typeof parsed.publisher === "string" ? parsed.publisher : void 0;
+  for (const a of parsed.assets) {
+    const asset = a;
+    const name = asset?.name;
+    const kind = typeof asset?.kind === "string" ? asset.kind : "skill";
+    if (typeof name !== "string" || name.length === 0) continue;
+    const publisher = typeof asset?.publisher === "string" ? asset.publisher : topPublisher;
+    if (publisher !== void 0) {
+      try {
+        parseAssetRef(`${kind}:@${publisher}/${name}`);
+      } catch (e) {
+        logErr(`${relPath} [assets] \u2014 ${e instanceof Error ? e.message : String(e)}`);
+        errors++;
+      }
+    } else if (!isValidAssetName(name)) {
+      logErr(`${relPath} [assets] \u2014 invalid asset name "${name}" \u2014 ${ASSET_NAME_HINT}`);
+      errors++;
+    }
+  }
+  return errors;
+}
+var CONNECTOR_ERROR_CODES = [
+  "connector_missing_driver",
+  "connector_missing_id",
+  "connector_duplicate_id",
+  "connector_invalid_access"
+];
+function validateLocalConnectorMountPaths(projectDir, relPath, connectors) {
+  let errors = 0;
+  for (const c of connectors) {
+    if (c.driver !== "local" || c.mount) continue;
+    const dir = localConnectorMountDir(c, projectDir);
+    if (!dir) continue;
+    if (!fs2.existsSync(dir)) {
+      logErr(
+        `${relPath} [connectors] \u2014 connector_mount_path_missing: connectors.${c.id}.mountPath: ${dir} does not exist; create the directory or fix the path`
+      );
+      errors++;
+    } else if (!isInsideProject(dir, projectDir)) {
+      logWarn(
+        `${relPath} [connectors] \u2014 connectors.${c.id}.mountPath: ${dir} is outside the project ${projectDir}; the agent reads${c.access === "read-write" ? " and writes" : ""} there`
+      );
+    }
+  }
+  return errors;
+}
+async function validateWorkspaceManifests(rootPath) {
+  const absRoot = path2.resolve(rootPath);
+  const files = findWorkspaceManifests(absRoot);
+  let errors = 0;
+  for (const file of files) {
+    const relPath = path2.relative(absRoot, file);
+    let parsed;
+    try {
+      parsed = parse(fs2.readFileSync(file, "utf-8")) ?? {};
+    } catch (e) {
+      logErr(`${relPath} \u2014 parse error: ${e instanceof Error ? e.message : String(e)}`);
+      errors++;
+      continue;
+    }
+    errors += validateWorkspaceRefs(collectWorkspaceRefFields(parsed), relPath);
+    errors += validateWorkspaceAssets(parsed, relPath);
+    for (const d of checkAgentInstances(path2.dirname(file), parsed)) {
+      const line = `${relPath} [agents] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`;
+      if (d.severity === "error") {
+        logErr(line);
+        errors++;
+      } else {
+        logWarn(line);
+      }
+    }
+    const decoded = decodeSkaileYaml(fs2.readFileSync(file, "utf-8"));
+    for (const d of decoded.diagnostics) {
+      if (!CONNECTOR_ERROR_CODES.includes(d.code)) continue;
+      logErr(`${relPath} [connectors] \u2014 ${d.code}: ${d.path ? `${d.path}: ` : ""}${d.message}`);
+      errors++;
+    }
+    errors += validateLocalConnectorMountPaths(
+      path2.dirname(file),
+      relPath,
+      decoded.config?.connectors ?? []
+    );
+    if ((decoded.config?.connectors ?? []).length > 0) {
+      const assets = await resolveRuntimeAssets(path2.dirname(file));
+      if (!assets.warnings.some((w) => w.code === "repo_unavailable")) {
+        for (const w of assets.warnings) {
+          if (w.code !== "missing_driver" || !w.name) continue;
+          logErr(`${relPath} [connectors] \u2014 ${w.code}: ${w.message}`);
+          errors++;
+        }
+      }
+    }
+  }
+  return { total: files.length, errors };
+}
+function validatePublishManifestRoots(rootPath) {
+  const absRoot = path2.resolve(rootPath);
+  const manifest = loadSkPublishManifest(absRoot);
+  if (!manifest) return 0;
+  const missing = missingRootAssets(absRoot, manifest);
+  for (const a of missing) {
+    logErr(
+      `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${assetEntryRef(a, manifest)}: root "${a.root}" does not exist. Run \`skaile library index <library>\` to drop the entry, or restore the directory.`
+    );
+  }
+  return missing.length;
+}
+function validatePublishManifestRequires(rootPath) {
+  const problems = manifestRequiresProblems(path2.resolve(rootPath));
+  for (const p of problems) {
+    logErr(
+      `${SKAILE_MANIFEST_FILENAME} [assets] \u2014 ${p.asset}: ${p.message}. Use the \`kind:@<publisher>/name[#version]\` form.`
+    );
+  }
+  return problems.length;
+}
+function validatePublishManifestPublisherSlugs(rootPath) {
+  const problems = manifestPublisherProblems(path2.resolve(rootPath));
+  for (const message of problems) logErr(message);
+  return problems.length;
+}
+function validatePublishManifestRootPaths(rootPath) {
+  const problems = [
+    ...manifestRootProblems(path2.resolve(rootPath)),
+    ...manifestEntryNameProblems(path2.resolve(rootPath))
+  ];
+  for (const message of problems) logErr(message);
+  return problems.length;
+}
+function validatePublishManifestParses(rootPath) {
+  try {
+    assertManifestEditable(path2.resolve(rootPath));
+    return 0;
+  } catch (err2) {
+    logErr(err2 instanceof Error ? err2.message : String(err2));
+    return 1;
+  }
+}
+function validatePublishManifestVersions(rootPath) {
+  const absRoot = path2.resolve(rootPath);
+  const manifest = loadSkPublishManifest(absRoot);
+  if (!manifest || manifest.source) return 0;
+  let warnings = 0;
+  for (const a of manifest.assets ?? []) {
+    if (!a.root || a.source || !a.version) continue;
+    const file = findAssetManifestFile(path2.join(absRoot, a.root), a.kind, a.name);
+    if (!file) continue;
+    const res = parseManifestFile(file, fs2.readFileSync(file, "utf-8"));
+    if (!res.ok) continue;
+    const fileVersion = declaredVersion(res.data);
+    if (fileVersion === void 0 || fileVersion === a.version) continue;
+    logWarn(
+      manifestVersionMismatchMessage(
+        assetEntryRef(a, manifest),
+        a.version,
+        toPosix(path2.relative(absRoot, file)),
+        fileVersion
+      )
+    );
+    warnings++;
+  }
+  return warnings;
+}
+function validatePublishManifestPublishers(rootPath) {
+  const absRoot = path2.resolve(rootPath);
+  const manifest = loadSkPublishManifest(absRoot);
+  if (!manifest || manifest.source) return 0;
+  const bare = (p) => p.trim().replace(/^@/, "");
+  let warnings = 0;
+  for (const a of manifest.assets ?? []) {
+    const resolved = a.publisher ?? manifest.publisher;
+    if (!a.root || a.source || !resolved) continue;
+    const file = findAssetManifestFile(path2.join(absRoot, a.root), a.kind, a.name);
+    if (!file) continue;
+    const res = parseManifestFile(file, fs2.readFileSync(file, "utf-8"));
+    if (!res.ok) continue;
+    const meta = res.data.metadata;
+    const declared = meta !== null && typeof meta === "object" ? meta.publisher : null;
+    if (typeof declared !== "string" || bare(declared) === bare(resolved)) continue;
+    logWarn(
+      `${toPosix(path2.relative(absRoot, file))} [publisher] \u2014 metadata.publisher "${bare(declared)}" differs from the manifest publisher "${bare(resolved)}" for ${assetEntryRef(a, manifest)}. The manifest wins and the file value is ignored: delete \`metadata.publisher\` from the file, or set the publisher in ${SKAILE_MANIFEST_FILENAME}.`
+    );
+    warnings++;
+  }
+  return warnings;
+}
+var EXCLUDED_PATHS = ["skaileup-shared/", "external/", "docs/"];
+function toPosix(p) {
+  return p.split(path2.sep).join("/");
+}
+function isExcludedPath(relPath) {
+  const rel = toPosix(relPath);
+  return EXCLUDED_PATHS.some((prefix) => rel.startsWith(prefix));
+}
+var VERSIONED_KINDS = {
+  skill: true,
+  agent: true,
+  flow: true,
+  prompt: true,
+  preset: true,
+  contract: true
+};
+function readAssetVersion(c) {
+  const kind = c.kind;
+  const fileName = path2.basename(c.filePath);
+  const dirName = path2.basename(path2.dirname(c.filePath));
+  const content = fs2.readFileSync(c.filePath, "utf-8");
+  if (c.filePath.endsWith(".md")) {
+    const res = parseManifestFile(c.filePath, content);
+    const data = res.ok ? res.data : {};
+    const stem = fileName.replace(/\.prompt\.md$/, "");
+    return {
+      kind,
+      name: typeof data.name === "string" ? data.name : kind === "prompt" ? stem : dirName,
+      version: declaredVersion(data) ?? "",
+      filePath: c.filePath
+    };
+  }
+  let parsed = null;
+  try {
+    parsed = parse(content);
+  } catch {
+  }
+  if (kind === "flow") {
+    return {
+      kind,
+      name: String(parsed?.id ?? fileName.replace(".flow.yaml", "")),
+      version: String(parsed?.version ?? ""),
+      filePath: c.filePath
+    };
+  }
+  return {
+    kind,
+    name: String(parsed?.name ?? dirName),
+    version: String(parsed?.version ?? ""),
+    filePath: c.filePath
+  };
+}
+function collectAssetVersions(root) {
+  if (!fs2.existsSync(root)) return [];
+  const assets = [];
+  for (const c of findManifestCandidates(root)) {
+    if (!VERSIONED_KINDS[c.kind]) continue;
+    if (c.filePath.endsWith(".flow.json")) continue;
+    if (isExcludedPath(path2.relative(root, c.filePath))) continue;
+    assets.push(readAssetVersion(c));
+  }
+  return assets;
+}
+function assetLocation(a, root) {
+  return toPosix(path2.relative(root, a.filePath));
+}
+function findChangelogUnit(assetRelPath, root) {
+  let dir = path2.posix.dirname(toPosix(assetRelPath));
+  for (; ; ) {
+    const candidate = dir === "." ? "CHANGELOG.md" : `${dir}/CHANGELOG.md`;
+    if (fs2.existsSync(path2.join(root, candidate))) return candidate;
+    if (dir === ".") return null;
+    dir = path2.posix.dirname(dir);
+  }
+}
+function checkChangelogUnits(modifiedFiles, root) {
+  const modified = new Set(modifiedFiles.map(toPosix));
+  const assetPattern = /(SKILL\.md|agent\.yaml|\.flow\.yaml|\.prompt\.md)$/;
+  const units = /* @__PURE__ */ new Set();
+  const orphans = [];
+  for (const f of modified) {
+    if (!assetPattern.test(f) || isExcludedPath(f)) continue;
+    const unit = findChangelogUnit(f, root);
+    if (unit) units.add(unit);
+    else orphans.push(f);
+  }
+  const updated = [...units].filter((u) => modified.has(u));
+  const stale = [...units].filter((u) => !modified.has(u));
+  return { updated, stale, orphans };
+}
+function extractVersionFromContent(filePath, content) {
+  if (filePath.endsWith(".yaml")) {
+    const parsed2 = parse(content);
+    return parsed2?.version ?? null;
+  }
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return null;
+  const parsed = parse(fmMatch[1]);
+  return parsed?.metadata?.version ?? parsed?.version ?? null;
+}
+function checkAssetVersions(assets, root) {
+  let errors = 0;
+  const warnings = 0;
+  for (const a of assets) {
+    const location = assetLocation(a, root);
+    if (!a.version) {
+      logErr(`${a.kind}:${a.name} (${location}) \u2014 missing version`);
+      errors++;
+      continue;
+    }
+    const invalid = invalidSemverText(a.version);
+    if (invalid) {
+      logErr(`${a.kind}:${a.name} (${location}) \u2014 ${invalid}`);
+      errors++;
+    }
+  }
+  return { errors, warnings };
+}
+function checkVersionBumps(assets, root) {
+  let warnings = 0;
+  for (const a of assets) {
+    if (!a.version) continue;
+    const relPath = toPosix(path2.relative(root, a.filePath));
+    try {
+      const headContent = execFileSync("git", ["show", `HEAD:./${relPath}`], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const headVersion = extractVersionFromContent(a.filePath, headContent);
+      if (headVersion && headVersion === a.version) {
+        logWarn(
+          `${a.kind}:${a.name} (${assetLocation(a, root)}) \u2014 file changed but version not bumped (${a.version})`
+        );
+        warnings++;
+      }
+    } catch {
+    }
+  }
+  return warnings;
+}
+function checkFlowVersionPins(assets, root) {
+  const flows = assets.filter((a) => a.kind === "flow");
+  const skillVersionMap = /* @__PURE__ */ new Map();
+  for (const a of assets.filter((a2) => a2.kind === "skill")) {
+    skillVersionMap.set(a.name, a.version);
+  }
+  let errors = 0;
+  let warnings = 0;
+  for (const f of flows) {
+    let pins;
+    try {
+      pins = flowSkillVersionPins(loadFlow(f.filePath));
+    } catch (err2) {
+      logWarn(
+        `flow:${f.name} (${path2.relative(root, f.filePath)}) \u2014 could not be read: ${err2 instanceof Error ? err2.message : err2}`
+      );
+      warnings++;
+      continue;
+    }
+    if (pins.length === 0) continue;
+    const checks = validateFlowVersions(pins, skillVersionMap);
+    for (const c of checks.filter((c2) => !c2.satisfied)) {
+      logErr(
+        `flow:${f.name} node ${c.nodeId} \u2014 wants ${c.requested}, found ${c.actual || "(none)"}`
+      );
+      errors++;
+    }
+  }
+  return { errors, warnings };
+}
+function resolveCheckRoot(pathArg) {
+  if (pathArg) {
+    const abs = path2.resolve(pathArg);
+    if (!fs2.existsSync(abs)) {
+      logErr(`Path does not exist: ${abs}`);
+      return null;
+    }
+    return abs;
+  }
+  for (let dir = process.cwd(); ; dir = path2.dirname(dir)) {
+    if (fs2.existsSync(path2.join(dir, SKAILE_MANIFEST_FILENAME))) return dir;
+    if (path2.dirname(dir) === dir) return AI_RESOURCES;
+  }
+}
+function isInGitWorkTree(root) {
+  try {
+    return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function changedFiles(root, ref, what, opts = {}) {
+  if (!isInGitWorkTree(root)) {
+    logErr(`${what} needs a git repository: ${root} is not inside a git work tree.`);
+    return null;
+  }
+  try {
+    const out = execFileSync(
+      "git",
+      ["diff", "--name-only", "--relative", "--end-of-options", ref],
+      {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    const changed = out.trim().split("\n").filter(Boolean);
+    if (opts.untracked) {
+      const fresh = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      changed.push(...fresh.trim().split("\n").filter(Boolean));
+    }
+    return changed;
+  } catch (err2) {
+    const stderr = err2 instanceof Error && "stderr" in err2 ? String(err2.stderr).trim() : "";
+    const reason = (stderr || (err2 instanceof Error ? err2.message : String(err2))).split("\n")[0];
+    logErr(`git diff failed in ${root}: ${reason}`);
+    return null;
+  }
+}
+function assetOwnDir(a) {
+  const dir = path2.dirname(a.filePath);
+  if (["skill", "agent", "contract"].includes(a.kind) || path2.basename(dir) === a.name) return dir;
+  return null;
+}
+function assetChanged(a, changedAbs) {
+  if (changedAbs.has(a.filePath)) return true;
+  const dir = assetOwnDir(a);
+  if (dir === null) return false;
+  for (const f of changedAbs) {
+    const rel = path2.relative(dir, f);
+    if (rel.startsWith("..") || path2.isAbsolute(rel)) continue;
+    if (!isNonAssetPath(toPosix(rel))) return true;
+  }
+  return false;
+}
+function runVersionsCheck(pathArg, opts) {
+  const root = resolveCheckRoot(pathArg);
+  if (root === null) {
+    process.exit(1);
+    return;
+  }
+  let assets = collectAssetVersions(root);
+  if (opts.changedOnly) {
+    const changed = changedFiles(root, "HEAD", "--changed-only", { untracked: true });
+    if (changed === null) {
+      process.exit(1);
+      return;
+    }
+    const changedAbs = new Set(changed.map((f) => path2.resolve(root, f)));
+    assets = assets.filter((a) => assetChanged(a, changedAbs));
+  }
+  logInfo(`Checking versions in ${root}`);
+  const versionCheck = checkAssetVersions(assets, root);
+  let errors = versionCheck.errors;
+  let warnings = versionCheck.warnings;
+  if (opts.changedOnly) {
+    warnings += checkVersionBumps(assets, root);
+  }
+  const pinCheck = checkFlowVersionPins(assets, root);
+  errors += pinCheck.errors;
+  warnings += pinCheck.warnings;
+  console.log();
+  logInfo(`Checked ${assets.length} assets`);
+  if (errors === 0 && warnings === 0) {
+    logOk("All versions valid");
+  } else {
+    if (errors > 0) logErr(`${errors} error(s)`);
+    if (warnings > 0) logWarn(`${warnings} warning(s)`);
+  }
+  if (errors > 0 || opts.strict && warnings > 0) {
+    process.exit(1);
+  }
+}
+function makeValidateCommand() {
+  const cmd = new Command("validate").description(
+    "Validate asset manifests, versions, and changelogs"
+  );
+  cmd.argument("[path]", "Path to asset repo or directory to validate", ".").option(
+    "--strict-conformance",
+    "Treat Agent Skills (agentskills.io) standard findings as errors"
+  ).action(async (targetPath, opts) => {
+    const absPath = path2.resolve(targetPath);
+    if (fs2.existsSync(absPath) && !fs2.statSync(absPath).isDirectory()) {
+      logErr(`${absPath} is not a directory: nothing to validate. Pass the library directory.`);
+      process.exit(1);
+      return;
+    }
+    logInfo(`Validating manifests in ${absPath}`);
+    const { total, errors, warnings } = validateManifests(
+      absPath,
+      opts.strictConformance ?? false,
+      await registeredAssetKeys(libraryRootOf(absPath))
+    );
+    const ws = await validateWorkspaceManifests(absPath);
+    const rootErrors = validatePublishManifestRoots(absPath);
+    const slugErrors = validatePublishManifestPublisherSlugs(absPath);
+    const rootPathErrors = validatePublishManifestRootPaths(absPath);
+    const parseErrors = validatePublishManifestParses(absPath);
+    const requiresErrors = validatePublishManifestRequires(absPath);
+    const versionWarnings = validatePublishManifestVersions(absPath);
+    const publisherWarnings = validatePublishManifestPublishers(absPath);
+    const dependencyProblems = await unresolvedManifestDependencies(absPath);
+    for (const w of dependencyProblems) logWarn(w);
+    const dependencyWarnings = dependencyProblems.length;
+    const totalErrors = errors + ws.errors + rootErrors + slugErrors + rootPathErrors + parseErrors + requiresErrors;
+    console.log();
+    warnIgnoredDomainFiles(absPath);
+    warnLegacyBundleFiles(absPath);
+    logInfo(`Scanned ${total} asset manifest(s) and ${ws.total} skaile.yaml file(s)`);
+    if (total === 0 && ws.total === 0 && totalErrors === 0 && !fs2.existsSync(path2.join(absPath, SKAILE_MANIFEST_FILENAME))) {
+      logErr(
+        `Nothing to validate in ${absPath}: no asset manifest, skaile.yaml or ${SKAILE_MANIFEST_FILENAME} found.`
+      );
+      process.exit(1);
+      return;
+    }
+    const totalWarnings = warnings + versionWarnings + publisherWarnings + dependencyWarnings;
+    if (totalWarnings > 0) logWarn(`${totalWarnings} warning(s)`);
+    if (totalErrors === 0) {
+      logOk("All manifests valid");
+    } else {
+      logErr(`${totalErrors} validation error(s)`);
+      process.exit(1);
+    }
+  });
+  cmd.command("versions").description("Check version fields and flow version pins").argument("[path]", "Library or asset directory (default: the current library)").option("--changed-only", "Only check assets modified since last commit").option("--strict", "Exit 1 on warnings (for CI)").addOption(removedDomainOption()).action(
+    (pathArg, opts) => {
+      rejectRemovedDomainOption(opts);
+      runVersionsCheck(pathArg, opts);
+    }
+  );
+  cmd.command("changelog").description("Check that modified assets have an updated nearest CHANGELOG.md").argument("[path]", "Library or asset directory (default: the current library)").option("--base <ref>", "Git base ref for diff", "HEAD").action((pathArg, opts) => {
+    const root = resolveCheckRoot(pathArg);
+    if (root === null) {
+      process.exit(1);
+      return;
+    }
+    const modifiedFiles = changedFiles(root, opts.base, "changelog");
+    if (modifiedFiles === null) {
+      process.exit(1);
+      return;
+    }
+    const { updated, stale, orphans } = checkChangelogUnits(modifiedFiles, root);
+    if (updated.length + stale.length + orphans.length === 0) {
+      logOk("No modified assets found");
+      return;
+    }
+    for (const unit of updated) logOk(`${unit} updated`);
+    for (const unit of stale) logErr(`${unit} not updated (assets were modified)`);
+    for (const asset of orphans) {
+      logErr(`${asset} \u2014 no CHANGELOG.md in any ancestor directory up to the asset root`);
+    }
+    if (stale.length + orphans.length > 0) process.exit(1);
+  });
+  return cmd;
+}
+
+export { isRecord, makeValidateCommand, scanIdentities };
+//# sourceMappingURL=chunk-FWAJUWXQ.js.map
+//# sourceMappingURL=chunk-FWAJUWXQ.js.map