@skaile/workspaces 0.8.5

package/dist/chunk-CSUBFKAN.js

@@ -0,0 +1,747 @@
+import { scanDirectory } from './chunk-BVHFSUFM.js';
+import { parseAssetRef } from './chunk-JLPC4YWT.js';
+import { mkdirSync, existsSync, readFileSync, writeFileSync, lstatSync, symlinkSync, rmSync, readdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, resolve, parse as parse$1, dirname } from 'path';
+import { parse, stringify } from 'yaml';
+import { spawnSync } from 'child_process';
+
+function getGlobalCacheDir() {
+  return process.env.SKAILE_CACHE_DIR ?? join(homedir(), ".skaile", "repos");
+}
+var GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+function cloneRepo(url, branch, dest) {
+  mkdirSync(dest, { recursive: true });
+  const r = spawnSync(
+    "git",
+    ["clone", "--depth=1", "--filter=blob:none", "--sparse", "--branch", branch, url, dest],
+    { stdio: "pipe", env: GIT_ENV }
+  );
+  if (r.status === 0) {
+    spawnSync("git", ["-C", dest, "sparse-checkout", "init", "--cone"], {
+      stdio: "pipe",
+      env: GIT_ENV
+    });
+    spawnSync("git", ["-C", dest, "sparse-checkout", "disable"], { stdio: "pipe", env: GIT_ENV });
+    return true;
+  }
+  const fallback = spawnSync("git", ["clone", "--depth=1", "--branch", branch, url, dest], {
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  return fallback.status === 0;
+}
+function pullRepo(dest, branch) {
+  const r = spawnSync("git", ["-C", dest, "pull", "--depth=1", "--ff-only"], {
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  if (r.status === 0) return true;
+  const fetch = spawnSync("git", ["-C", dest, "fetch", "--depth=1", "origin", branch], {
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  if (fetch.status !== 0) return false;
+  const reset = spawnSync("git", ["-C", dest, "reset", "--hard", `origin/${branch}`], {
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  return reset.status === 0;
+}
+function getRepoCommit(repoDir) {
+  const r = spawnSync("git", ["-C", repoDir, "rev-parse", "HEAD"], {
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  return r.status === 0 ? r.stdout.trim() : null;
+}
+function checkoutPin(repoDir, pin) {
+  spawnSync("git", ["-C", repoDir, "fetch", "--depth=1", "origin", pin], {
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  const r = spawnSync("git", ["-C", repoDir, "checkout", "FETCH_HEAD"], {
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  if (r.status === 0) return true;
+  const r2 = spawnSync("git", ["-C", repoDir, "checkout", pin], { stdio: "pipe", env: GIT_ENV });
+  return r2.status === 0;
+}
+function linksFile(projectDir) {
+  return join(projectDir, ".skaile", "links.yaml");
+}
+function readLinks(projectDir) {
+  const file = linksFile(projectDir);
+  if (!existsSync(file)) return {};
+  try {
+    return parse(readFileSync(file, "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+function writeLinks(projectDir, links) {
+  const dir = join(projectDir, ".skaile");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(linksFile(projectDir), stringify(links));
+}
+function linkRepo(projectDir, repoName, localPath) {
+  const resolved = resolve(projectDir, localPath);
+  if (!existsSync(resolved)) {
+    throw new Error(`Path not found: ${localPath} (resolved: ${resolved})`);
+  }
+  const links = readLinks(projectDir);
+  links[repoName] = resolved;
+  writeLinks(projectDir, links);
+}
+function unlinkRepo(projectDir, repoName) {
+  const links = readLinks(projectDir);
+  if (!links[repoName]) return false;
+  delete links[repoName];
+  writeLinks(projectDir, links);
+  return true;
+}
+function ensureRepo(decl, name, reposDir, opts) {
+  if (opts?.projectDir) {
+    const links = readLinks(opts.projectDir);
+    if (links[name]) {
+      const linked = links[name];
+      if (!existsSync(linked)) {
+        throw new Error(
+          `Linked path not found: ${linked}. Remove the .skaile/links.yaml entry to clear it.`
+        );
+      }
+      return linked;
+    }
+  }
+  if (decl.path) {
+    const projectDir = opts?.projectDir ?? resolve(reposDir, "..");
+    const resolved = resolve(projectDir, decl.path);
+    if (!existsSync(resolved)) {
+      throw new Error(`Local repository path not found: ${decl.path} (resolved: ${resolved})`);
+    }
+    return resolved;
+  }
+  if (decl.url) {
+    const branch = decl.branch ?? "main";
+    const globalCache = getGlobalCacheDir();
+    const cacheDest = join(globalCache, name);
+    if (existsSync(join(cacheDest, ".git"))) {
+      if (!opts?.pin) pullRepo(cacheDest, branch);
+    } else {
+      if (!cloneRepo(decl.url, branch, cacheDest)) {
+        throw new Error(`Failed to clone ${decl.url} (branch: ${branch})`);
+      }
+    }
+    if (opts?.pin) {
+      checkoutPin(cacheDest, opts.pin);
+    }
+    const projectDest = join(reposDir, name);
+    const projectExists = existsSync(projectDest);
+    const isSymlink = projectExists && lstatSync(projectDest).isSymbolicLink();
+    if (!projectExists) {
+      mkdirSync(reposDir, { recursive: true });
+      try {
+        symlinkSync(cacheDest, projectDest);
+      } catch {
+        return cacheDest;
+      }
+    } else if (!isSymlink) {
+      rmSync(projectDest, { recursive: true });
+      try {
+        symlinkSync(cacheDest, projectDest);
+      } catch {
+      }
+    }
+    return cacheDest;
+  }
+  throw new Error(`Repository "${name}" has neither url nor path`);
+}
+function scanRepo(repoDir, repoName) {
+  return scanDirectory(repoDir, repoName);
+}
+function resolveAsset(ref, repositories, reposDir, opts) {
+  let repoNames;
+  if (ref.repository) {
+    repoNames = [ref.repository];
+  } else if (opts?.preferRepo && opts.preferRepo in repositories) {
+    const rest = Object.keys(repositories).filter((n) => n !== opts.preferRepo);
+    repoNames = [opts.preferRepo, ...rest];
+  } else {
+    repoNames = Object.keys(repositories);
+  }
+  for (const repoName of repoNames) {
+    const decl = repositories[repoName];
+    if (!decl) continue;
+    const repoDir = resolveRepoDir(decl, repoName, reposDir, opts?.projectDir);
+    if (!repoDir || !existsSync(repoDir)) continue;
+    const entries = scanRepo(repoDir, repoName);
+    const match = entries.find((e) => e.kind === ref.kind && e.name === ref.name);
+    if (match) return match;
+  }
+  return null;
+}
+function resolveRepoDir(decl, name, reposDir, projectDir) {
+  if (projectDir) {
+    const links = readLinks(projectDir);
+    if (links[name]) {
+      return existsSync(links[name]) ? links[name] : null;
+    }
+  }
+  if (decl.path) {
+    const base = projectDir ?? resolve(reposDir, "..");
+    const resolved = resolve(base, decl.path);
+    return existsSync(resolved) ? resolved : null;
+  }
+  const projectDest = join(reposDir, name);
+  if (existsSync(projectDest)) return projectDest;
+  const globalDest = join(getGlobalCacheDir(), name);
+  if (existsSync(join(globalDest, ".git"))) return globalDest;
+  return null;
+}
+function resolveAll(deps, repositories, reposDir, opts) {
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  const missing = [];
+  const resolvedBy = /* @__PURE__ */ new Map();
+  function visit(refStr, parent, parentRepo) {
+    const ref = parseAssetRef(refStr);
+    const key = `${ref.kind}:${ref.name}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const preferRepo = ref.repository ?? parentRepo;
+    const entry = resolveAsset(ref, repositories, reposDir, {
+      ...opts,
+      preferRepo
+    });
+    if (!entry) {
+      missing.push(refStr);
+      return;
+    }
+    resolvedBy.set(key, parent);
+    const entryRepo = entry.repository;
+    for (const req of entry.requires) {
+      visit(`${req.kind}:${req.name}`, key, entryRepo);
+    }
+    for (const dep of entry.dependencies) {
+      visit(dep, key, entryRepo);
+    }
+    resolved.push(entry);
+  }
+  for (const dep of deps) {
+    visit(dep, "direct");
+  }
+  const collisions = detectCollisions(resolved, repositories, reposDir, opts?.projectDir);
+  return { resolved, missing, resolvedBy, collisions };
+}
+function detectCollisions(resolved, repositories, reposDir, projectDir) {
+  const repoNames = Object.keys(repositories);
+  if (repoNames.length < 2) return [];
+  const repoEntries = /* @__PURE__ */ new Map();
+  for (const repoName of repoNames) {
+    const decl = repositories[repoName];
+    if (!decl) continue;
+    const repoDir = resolveRepoDir(decl, repoName, reposDir, projectDir);
+    if (!repoDir || !existsSync(repoDir)) continue;
+    repoEntries.set(repoName, scanRepo(repoDir, repoName));
+  }
+  const collisions = [];
+  for (const entry of resolved) {
+    const key = `${entry.kind}:${entry.name}`;
+    const shadowedIn = [];
+    for (const [repoName, entries] of repoEntries) {
+      if (repoName === entry.repository) continue;
+      if (entries.some((e) => e.kind === entry.kind && e.name === entry.name)) {
+        shadowedIn.push(repoName);
+      }
+    }
+    if (shadowedIn.length > 0 && entry.repository) {
+      collisions.push({ key, resolvedFrom: entry.repository, shadowedIn });
+    }
+  }
+  return collisions;
+}
+function checkRepoStatus(decl, name, reposDir, projectDir) {
+  if (projectDir) {
+    const links = readLinks(projectDir);
+    if (links[name]) {
+      return {
+        name,
+        kind: "linked",
+        localHead: "",
+        remoteHead: "",
+        behind: 0,
+        upToDate: true,
+        linkedTo: links[name]
+      };
+    }
+  }
+  const base = {
+    name,
+    kind: decl.path ? "local" : "remote",
+    localHead: "",
+    remoteHead: "",
+    behind: 0,
+    upToDate: true
+  };
+  if (decl.path) return base;
+  let dest = join(getGlobalCacheDir(), name);
+  if (!existsSync(join(dest, ".git"))) {
+    dest = join(reposDir, name);
+  }
+  if (!existsSync(join(dest, ".git"))) {
+    return { ...base, error: "Not cloned yet" };
+  }
+  const branch = decl.branch ?? "main";
+  const localHead = getRepoCommit(dest);
+  if (!localHead) return { ...base, error: "Failed to read local HEAD" };
+  base.localHead = localHead;
+  const fetchR = spawnSync("git", ["-C", dest, "fetch", "--depth=50", "origin", branch], {
+    encoding: "utf8",
+    stdio: "pipe",
+    env: GIT_ENV
+  });
+  if (fetchR.status !== 0) return { ...base, error: "Fetch failed" };
+  const remoteR = spawnSync("git", ["-C", dest, "rev-parse", `origin/${branch}`], {
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  if (remoteR.status !== 0) return { ...base, error: "Failed to read remote HEAD" };
+  base.remoteHead = remoteR.stdout.trim();
+  const countR = spawnSync(
+    "git",
+    ["-C", dest, "rev-list", "--left-right", "--count", `HEAD...origin/${branch}`],
+    { encoding: "utf8", stdio: "pipe" }
+  );
+  if (countR.status === 0) {
+    const parts = countR.stdout.trim().split(/\s+/);
+    base.behind = parseInt(parts[1] ?? "0", 10);
+  }
+  base.upToDate = base.behind === 0;
+  return base;
+}
+
+// core/src/workspace-config.ts
+function validateAssetRecipeAttr(attr) {
+  if (typeof attr !== "string" || attr.length === 0) {
+    throw new Error("AssetRecipe.attr must be a non-empty string");
+  }
+  if (attr.length > 200) {
+    throw new Error(`AssetRecipe.attr too long (${attr.length} chars, max 200)`);
+  }
+  const VALID_ATTR = /^[a-z][a-z0-9._-]*(?:\.[a-z][a-z0-9._-]*)*$/i;
+  if (!VALID_ATTR.test(attr)) {
+    throw new Error(
+      `AssetRecipe.attr "${attr}" contains invalid characters. Allowed: letters, digits, underscore, hyphen, dot. Each dot-segment must start with a letter.`
+    );
+  }
+}
+var COMPACTION_DEFAULTS = {
+  enabled: true,
+  thresholdPercent: 80,
+  compactOnHibernate: true,
+  minCooldownMs: 12e4,
+  manualCompactEnabled: false
+};
+var SKAILE_YAML_SUFFIX = ".skaile.yaml";
+var SKAILE_YAML_DEFAULT = "skaile.yaml";
+var SK_WORKSPACE_SUFFIX = SKAILE_YAML_SUFFIX;
+var SK_WORKSPACE_DEFAULT_NAME = "default";
+function workspaceConfigFilename(name) {
+  if (!name || name === "default") return SKAILE_YAML_DEFAULT;
+  return `${name}${SKAILE_YAML_SUFFIX}`;
+}
+function isWorkspaceConfigFilename(filename) {
+  return filename === SKAILE_YAML_DEFAULT || filename.endsWith(SKAILE_YAML_SUFFIX);
+}
+function workspaceNameFromFilename(filename) {
+  if (filename === SKAILE_YAML_DEFAULT) return "default";
+  return filename.slice(0, -SKAILE_YAML_SUFFIX.length);
+}
+function loadSkWorkspaceConfig(dir, name) {
+  const resolvedDir = resolve(dir);
+  const canonicalName = name && name !== "default" ? name : void 0;
+  const filename = workspaceConfigFilename(canonicalName);
+  const filePath = join(resolvedDir, filename);
+  if (existsSync(filePath)) {
+    return parseConfigFile(filePath, canonicalName ?? "default");
+  }
+  if (!canonicalName) {
+    const found = listSkWorkspaceConfigs(resolvedDir);
+    if (found.length === 1) return found[0];
+  }
+  return null;
+}
+function saveSkWorkspaceConfig(dir, config, name) {
+  const resolvedDir = resolve(dir);
+  const filename = workspaceConfigFilename(name);
+  const filePath = join(resolvedDir, filename);
+  if (!existsSync(resolvedDir)) {
+    mkdirSync(resolvedDir, { recursive: true });
+  }
+  writeFileSync(filePath, stringify(config, { lineWidth: 120 }));
+  return filePath;
+}
+function listSkWorkspaceConfigs(dir) {
+  const resolvedDir = resolve(dir);
+  if (!existsSync(resolvedDir)) return [];
+  const configs = [];
+  try {
+    for (const entry of readdirSync(resolvedDir)) {
+      if (isWorkspaceConfigFilename(entry)) {
+        const wsName = workspaceNameFromFilename(entry);
+        const parsed = parseConfigFile(join(resolvedDir, entry), wsName);
+        if (parsed) configs.push(parsed);
+      }
+    }
+  } catch {
+  }
+  return configs.sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolveSkWorkspaceConfig(projectDir, opts) {
+  const name = opts?.name ?? SK_WORKSPACE_DEFAULT_NAME;
+  const configs = [];
+  const userConfig = loadSkWorkspaceConfig(join(homedir(), ".skaile"), name);
+  if (userConfig) configs.push(userConfig.config);
+  if (opts?.appDir) {
+    const appConfig = loadSkWorkspaceConfig(opts.appDir, name);
+    if (appConfig) configs.push(appConfig.config);
+  }
+  const projectConfig = loadSkWorkspaceConfig(projectDir, name);
+  if (projectConfig) configs.push(projectConfig.config);
+  if (configs.length > 0) return configs.reduce(mergeSkWorkspaceConfigs);
+  return {};
+}
+function findWorkspaceRoot(startDir) {
+  let dir = resolve(startDir);
+  const root = parse$1(dir).root;
+  let depth = 0;
+  while (depth < 20) {
+    if (existsSync(join(dir, SKAILE_YAML_DEFAULT))) return dir;
+    try {
+      for (const entry of readdirSync(dir)) {
+        if (entry.endsWith(SKAILE_YAML_SUFFIX)) return dir;
+      }
+    } catch {
+    }
+    if (dir === root) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+    depth++;
+  }
+  return void 0;
+}
+function mergeSkWorkspaceConfigs(base, overlay) {
+  return {
+    name: overlay.name ?? base.name,
+    description: overlay.description ?? base.description,
+    // agent_config: per-profile key, overlay profile wins
+    agent_config: {
+      ...base.agent_config ?? {},
+      ...overlay.agent_config ?? {}
+    },
+    // startup: overlay wins (project-level only)
+    startup: overlay.startup ?? base.startup,
+    // ai_resources: dedupe by source name — overlay entry wins for same name
+    ai_resources: dedupeByKey(
+      [...base.ai_resources ?? [], ...overlay.ai_resources ?? []],
+      "name"
+    ),
+    // mounts: by id — overlay wins
+    mounts: mergeById(base.mounts ?? [], overlay.mounts ?? []),
+    // connectors: by id — overlay wins
+    connectors: mergeById(base.connectors ?? [], overlay.connectors ?? []),
+    // mcp_servers: by id — overlay wins
+    mcp_servers: mergeById(base.mcp_servers ?? [], overlay.mcp_servers ?? []),
+    agent: {
+      definition: overlay.agent?.definition ?? base.agent?.definition,
+      context: overlay.agent?.context ?? base.agent?.context,
+      permissions: {
+        ...base.agent?.permissions,
+        ...stripUndefined(overlay.agent?.permissions),
+        deny_write: dedupe([
+          ...base.agent?.permissions?.deny_write ?? [],
+          ...overlay.agent?.permissions?.deny_write ?? []
+        ]),
+        deny_read: dedupe([
+          ...base.agent?.permissions?.deny_read ?? [],
+          ...overlay.agent?.permissions?.deny_read ?? []
+        ])
+      },
+      subagents: {
+        ...base.agent?.subagents ?? {},
+        ...overlay.agent?.subagents ?? {}
+      },
+      hooks: {
+        pre_flow: [
+          ...base.agent?.hooks?.pre_flow ?? [],
+          ...overlay.agent?.hooks?.pre_flow ?? []
+        ],
+        post_flow: [
+          ...base.agent?.hooks?.post_flow ?? [],
+          ...overlay.agent?.hooks?.post_flow ?? []
+        ],
+        pre_node: [
+          ...base.agent?.hooks?.pre_node ?? [],
+          ...overlay.agent?.hooks?.pre_node ?? []
+        ],
+        post_node: [
+          ...base.agent?.hooks?.post_node ?? [],
+          ...overlay.agent?.hooks?.post_node ?? []
+        ]
+      }
+    },
+    workspace: {
+      directories: dedupe([
+        ...base.workspace?.directories ?? [],
+        ...overlay.workspace?.directories ?? []
+      ]),
+      git: {
+        init: overlay.workspace?.git?.init ?? base.workspace?.git?.init,
+        ignore: dedupe([
+          ...base.workspace?.git?.ignore ?? [],
+          ...overlay.workspace?.git?.ignore ?? []
+        ])
+      },
+      setup: overlay.workspace?.setup ?? base.workspace?.setup,
+      container: overlay.workspace?.container ?? base.workspace?.container
+    },
+    // secrets: overlay wins entirely
+    secrets: overlay.secrets ?? base.secrets,
+    // telemetry: overlay wins entirely (raw pass-through)
+    telemetry: overlay.telemetry ?? base.telemetry,
+    // repositories: always empty in merged output; the schema no longer
+    // accepts this key. The internal install pipeline builds its own map
+    // from `ai_resources[]` entries.
+    repositories: {},
+    // dependencies: concatenate and dedupe
+    dependencies: dedupe([...base.dependencies ?? [], ...overlay.dependencies ?? []])
+  };
+}
+function normalizeConfig(raw) {
+  const config = {};
+  if (raw.name) config.name = String(raw.name);
+  if (raw.description) config.description = String(raw.description);
+  const agentConfigRaw = raw["agent-config"] ?? raw.agent_config;
+  if (agentConfigRaw && typeof agentConfigRaw === "object" && !Array.isArray(agentConfigRaw)) {
+    config.agent_config = agentConfigRaw;
+  }
+  if (Array.isArray(raw.startup)) {
+    config.startup = raw.startup;
+  }
+  const aiResRaw = raw.ai_resources;
+  if (Array.isArray(aiResRaw)) {
+    config.ai_resources = aiResRaw;
+  } else if (aiResRaw && typeof aiResRaw === "object") {
+    const old = aiResRaw;
+    const sources = Array.isArray(old.sources) ? old.sources : [];
+    const requires = Array.isArray(old.requires) ? old.requires.filter(Boolean) : [];
+    const autoDeploy = Boolean(old.auto_deploy ?? false);
+    config.ai_resources = sources.map((s, i) => {
+      const entry = {
+        name: String(s.name ?? ""),
+        path: String(s.path ?? s.url ?? "")
+      };
+      if (s.branch) entry.branch = String(s.branch);
+      if (autoDeploy) entry.auto_deploy = true;
+      if (i === 0 && requires.length > 0) entry.dependencies = requires;
+      return entry;
+    });
+  }
+  if (Array.isArray(raw.mounts)) {
+    config.mounts = raw.mounts;
+  }
+  if (Array.isArray(raw.connectors)) {
+    config.connectors = raw.connectors;
+  }
+  if (Array.isArray(raw.mcp_servers)) {
+    config.mcp_servers = raw.mcp_servers;
+  }
+  if (raw.agent) config.agent = raw.agent;
+  if (raw.workspace) config.workspace = raw.workspace;
+  if (raw.secrets && typeof raw.secrets === "object") {
+    config.secrets = raw.secrets;
+  }
+  if (Array.isArray(raw.dependencies)) {
+    config.dependencies = raw.dependencies.filter((d) => typeof d === "string");
+  }
+  if (raw.telemetry && typeof raw.telemetry === "object" && !Array.isArray(raw.telemetry)) {
+    config.telemetry = raw.telemetry;
+  }
+  return config;
+}
+function parseConfigFile(filePath, name) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = parse(raw) ?? {};
+  } catch {
+    return null;
+  }
+  const config = normalizeConfig(parsed);
+  return { path: filePath, name, config };
+}
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+function dedupeByKey(arr, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let i = arr.length - 1; i >= 0; i--) {
+    const val = String(arr[i][key] ?? "");
+    if (!seen.has(val)) {
+      seen.add(val);
+      result.unshift(arr[i]);
+    }
+  }
+  return result;
+}
+function mergeById(base, overlay) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of base) map.set(r.id, r);
+  for (const r of overlay) map.set(r.id, r);
+  return [...map.values()];
+}
+function stripUndefined(obj) {
+  if (!obj) return {};
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) result[k] = v;
+  }
+  return result;
+}
+function mcpDeclFromCatalogEntry(entry) {
+  const m = entry.metadata;
+  if (!m) return null;
+  const decl = { id: entry.name };
+  if (m.transport) decl.transport = String(m.transport);
+  if (m.command) decl.command = String(m.command);
+  if (Array.isArray(m.args)) decl.args = m.args.map(String);
+  if (m.env && typeof m.env === "object") decl.env = m.env;
+  if (m.url) decl.url = String(m.url);
+  if (m.headers && typeof m.headers === "object") {
+    decl.headers = m.headers;
+  }
+  if (entry.description) decl.description = entry.description;
+  if (m.recipe && typeof m.recipe === "object" && !Array.isArray(m.recipe)) {
+    const r = m.recipe;
+    if (typeof r.attr === "string") {
+      try {
+        validateAssetRecipeAttr(r.attr);
+        decl.recipe = { attr: r.attr };
+      } catch (err) {
+        console.warn(
+          `[workspace-config] mcpDeclFromCatalogEntry: invalid recipe.attr for entry "${entry.name}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+  if (!decl.command && !decl.url) return null;
+  return decl;
+}
+function mergeMcpDeclarations(base, overlay) {
+  return {
+    id: overlay.id,
+    transport: overlay.transport ?? base.transport,
+    command: overlay.command ?? base.command,
+    args: overlay.args ?? base.args,
+    env: overlay.env ? base.env ? { ...base.env, ...overlay.env } : overlay.env : base.env,
+    url: overlay.url ?? base.url,
+    headers: overlay.headers ? base.headers ? { ...base.headers, ...overlay.headers } : overlay.headers : base.headers,
+    description: overlay.description ?? base.description,
+    tags: overlay.tags ?? base.tags,
+    recipe: overlay.recipe ?? base.recipe
+  };
+}
+function loadMcpServerDeclarations(projectDir) {
+  const config = resolveSkWorkspaceConfig(projectDir);
+  const explicit = config.mcp_servers ?? [];
+  const mcpRefStrings = [];
+  for (const dep of config.dependencies ?? []) {
+    const ref = parseAssetRef(dep);
+    if (ref.kind === "mcp-server") mcpRefStrings.push(dep);
+  }
+  for (const res of config.ai_resources ?? []) {
+    for (const dep of res.dependencies ?? []) {
+      const ref = parseAssetRef(dep);
+      if (ref.kind === "mcp-server") mcpRefStrings.push(dep);
+    }
+  }
+  if (mcpRefStrings.length === 0) return explicit;
+  const repositories = config.repositories ?? {};
+  const allRepos = { ...repositories };
+  for (const res of config.ai_resources ?? []) {
+    if (res.name && res.path && !(res.name in allRepos)) {
+      allRepos[res.name] = {
+        url: res.path.startsWith("/") ? void 0 : res.path,
+        path: res.path.startsWith("/") ? res.path : void 0,
+        branch: res.branch
+      };
+    }
+  }
+  const reposDir = getGlobalCacheDir();
+  const explicitById = new Map(explicit.map((d) => [d.id, d]));
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const refStr of mcpRefStrings) {
+    const ref = parseAssetRef(refStr);
+    if (seen.has(ref.name)) continue;
+    seen.add(ref.name);
+    const entry = resolveAsset(ref, allRepos, reposDir, { projectDir });
+    if (!entry) continue;
+    const catalogDecl = mcpDeclFromCatalogEntry(entry);
+    if (!catalogDecl) continue;
+    const override = explicitById.get(entry.name);
+    if (override) {
+      explicitById.delete(entry.name);
+      result.push(mergeMcpDeclarations(catalogDecl, override));
+    } else {
+      result.push(catalogDecl);
+    }
+  }
+  for (const decl of explicitById.values()) {
+    result.push(decl);
+  }
+  return result;
+}
+function findAiAssetsDir(from) {
+  let dir = resolve(from);
+  for (let i = 0; i < 8; i++) {
+    const candidate = join(dir, "ai-assets");
+    if (existsSync(candidate)) return candidate;
+    const resolved = resolve(dir, "..");
+    if (resolved === dir) break;
+    dir = resolved;
+  }
+  return void 0;
+}
+function resolveAgentDir(projectDir) {
+  const config = resolveSkWorkspaceConfig(projectDir);
+  const definition = config.agent?.definition;
+  if (!definition) return void 0;
+  if (definition.startsWith("ai-assets://")) {
+    const relPath = definition.slice("ai-assets://".length);
+    const aiAssetsDir = findAiAssetsDir(projectDir);
+    if (!aiAssetsDir) return void 0;
+    return join(aiAssetsDir, relPath);
+  }
+  if (definition.startsWith("agent:")) {
+    const ref = parseAssetRef(definition);
+    const repositories = config.repositories ?? {};
+    const reposDir = getGlobalCacheDir();
+    const entry = resolveAsset(ref, repositories, reposDir, { projectDir });
+    if (!entry) return void 0;
+    return dirname(entry.source);
+  }
+  return resolve(projectDir, definition);
+}
+
+export { COMPACTION_DEFAULTS, SKAILE_YAML_DEFAULT, SKAILE_YAML_SUFFIX, SK_WORKSPACE_DEFAULT_NAME, SK_WORKSPACE_SUFFIX, checkRepoStatus, checkoutPin, cloneRepo, ensureRepo, findWorkspaceRoot, getGlobalCacheDir, getRepoCommit, isWorkspaceConfigFilename, linkRepo, listSkWorkspaceConfigs, loadMcpServerDeclarations, loadSkWorkspaceConfig, mergeSkWorkspaceConfigs, normalizeConfig, pullRepo, readLinks, resolveAgentDir, resolveAll, resolveAsset, resolveSkWorkspaceConfig, saveSkWorkspaceConfig, scanRepo, unlinkRepo, validateAssetRecipeAttr, workspaceConfigFilename, workspaceNameFromFilename, writeLinks };
+//# sourceMappingURL=chunk-CSUBFKAN.js.map
+//# sourceMappingURL=chunk-CSUBFKAN.js.map