@skaile/workspaces 0.8.5

package/dist/chunk-EE3XTJ62.js

@@ -0,0 +1,840 @@
+import { removeAsset, deployAll, createScaffold } from './chunk-UMMBL7SW.js';
+import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
+import { commitChanges } from './chunk-UQ6LFBPZ.js';
+import { readLock, buildLockFile, writeLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-65CYXYUW.js';
+import { deployedBase, isDeployed, deployedDir } from './chunk-JKNWJ64A.js';
+import { resolveRuntimeAssets } from './chunk-XEGHWFAX.js';
+import { resolveSkWorkspaceConfig, ensureRepo, resolveAll, resolveAsset, scanRepo, checkRepoStatus, readLinks, getGlobalCacheDir } from './chunk-CSUBFKAN.js';
+import { parseAssetRef } from './chunk-JLPC4YWT.js';
+import { __require } from './chunk-NSBPE2FW.js';
+import { existsSync, readFileSync, readdirSync, lstatSync, unlinkSync, rmSync } from 'fs';
+import { resolve, join } from 'path';
+
+var AssetManager = class {
+  /** Resolved absolute path to the workspace root. */
+  projectDir;
+  /** Agent framework driver target used for all deploy operations. */
+  driverTarget;
+  /** Whether this instance operates in global-install mode. */
+  global;
+  constructor(opts) {
+    this.projectDir = resolve(opts.projectDir);
+    this.driverTarget = opts.driverTarget ?? "claude-code";
+    this.global = opts.global ?? false;
+  }
+  get reposDir() {
+    return join(this.projectDir, ".skaile", "repos");
+  }
+  get lockPath() {
+    return join(this.projectDir, "skaile.lock.yaml");
+  }
+  get patchDir() {
+    return join(this.projectDir, ".skaile", "patches");
+  }
+  get deployOpts() {
+    return { driverTarget: this.driverTarget, global: this.global, cwd: this.projectDir };
+  }
+  loadConfig() {
+    const configPath = join(this.projectDir, "skaile.yaml");
+    let raw = {};
+    if (existsSync(configPath)) {
+      try {
+        const { parse } = __require("yaml");
+        raw = parse(readFileSync(configPath, "utf8")) ?? {};
+      } catch {
+      }
+    }
+    const config = resolveSkWorkspaceConfig(this.projectDir);
+    const repositories = {};
+    let dependencies = raw.dependencies ?? [];
+    const patches = raw.patches ?? {};
+    const aiResources = raw.ai_resources ?? config.ai_resources;
+    if (aiResources?.length) {
+      for (const entry of aiResources) {
+        if (repositories[entry.name]) continue;
+        const isUrl = /^(https?:|git@|git:)/.test(entry.path);
+        repositories[entry.name] = isUrl ? { url: entry.path, branch: entry.branch } : { path: entry.path, branch: entry.branch };
+        if (entry.dependencies) {
+          dependencies = [...dependencies, ...entry.dependencies];
+        }
+      }
+    }
+    return { repositories, dependencies, patches, config };
+  }
+  // ── Install / resolve ──────────────────────────────────────────────────
+  /**
+   * Install all dependencies declared in `skaile.yaml`.
+   *
+   * Steps: clone/pull repositories → resolve transitive dependencies → reconcile
+   * (remove stale assets) → deploy new assets → write `skaile.lock.yaml` → record history.
+   *
+   * @param opts - Optional installation options.
+   * @param opts.locked - When `true`, restore the exact versions recorded in the existing
+   *   lock file instead of resolving from source. Throws if no lock file is found.
+   * @returns {@link InstallResult} summarising what was deployed, what was missing, and any collisions.
+   */
+  async install(opts) {
+    const { repositories, dependencies, patches } = this.loadConfig();
+    if (opts?.locked) {
+      return this.installLocked(repositories, patches);
+    }
+    for (const [name, decl] of Object.entries(repositories)) {
+      try {
+        ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
+      } catch (err) {
+        return {
+          deployed: [],
+          removed: [],
+          missing: [`repo:${name}`],
+          lockWritten: false,
+          collisions: []
+        };
+      }
+    }
+    const { resolved, missing, resolvedBy, collisions } = resolveAll(
+      dependencies,
+      repositories,
+      this.reposDir,
+      { projectDir: this.projectDir }
+    );
+    const oldLock = readLock(this.lockPath);
+    const resolvedRefs = new Set(resolved.map((e) => `${e.kind}:${e.name}`));
+    const removed = [];
+    if (oldLock) {
+      for (const ref of Object.keys(oldLock.assets)) {
+        if (!resolvedRefs.has(ref)) {
+          const [kind, name] = ref.split(":");
+          removeAsset(kind, name, this.deployOpts);
+          removed.push(ref);
+        }
+      }
+    }
+    const deployed = deployAll(resolved, repositories, patches, this.deployOpts);
+    const lockData = buildLockFile(
+      repositories,
+      resolved,
+      resolvedBy,
+      this.reposDir,
+      this.projectDir
+    );
+    writeLock(this.lockPath, lockData);
+    for (const ref of deployed) {
+      appendHistory(this.projectDir, {
+        ref,
+        action: "add",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: this.global ? "global" : "project"
+      });
+    }
+    for (const ref of removed) {
+      appendHistory(this.projectDir, {
+        ref,
+        action: "remove",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: this.global ? "global" : "project"
+      });
+    }
+    const { npmInstalled, npmFailed } = await this.installRuntimeAssetDeps();
+    return {
+      deployed,
+      removed,
+      missing,
+      lockWritten: true,
+      collisions,
+      npmInstalled,
+      npmFailed
+    };
+  }
+  /**
+   * Resolve runtime assets and install any missing npm peer deps.
+   *
+   * - Required deps: installed via `bun add --optional`. Failure is recorded
+   *   in `npmFailed` but does not throw — install() proceeds so users get a
+   *   useful error message rather than a hung command.
+   * - Optional deps: not installed automatically (would force every consumer
+   *   to pull every connector's deps). Future: add a flag to opt in.
+   */
+  async installRuntimeAssetDeps() {
+    const npmInstalled = [];
+    const npmFailed = [];
+    let runtimeAssets = null;
+    try {
+      runtimeAssets = await resolveRuntimeAssets(this.projectDir);
+    } catch {
+      return { npmInstalled, npmFailed };
+    }
+    const required = runtimeAssets.requiredNpmDeps.required;
+    if (required.length === 0) return { npmInstalled, npmFailed };
+    const { findMissingPackages, installNpmPackages } = await import('./connectors/index.js');
+    const missing = findMissingPackages(required, this.projectDir);
+    if (missing.length === 0) return { npmInstalled, npmFailed };
+    const result = await installNpmPackages(missing, this.projectDir);
+    if (result.success) {
+      npmInstalled.push(...missing);
+    } else {
+      npmFailed.push(...missing);
+    }
+    return { npmInstalled, npmFailed };
+  }
+  installLocked(repositories, patches) {
+    const lock = readLock(this.lockPath);
+    if (!lock) {
+      throw new Error("No lock file found. Run `skaile install` first.");
+    }
+    for (const [name, lockRepo] of Object.entries(lock.repositories)) {
+      const decl = repositories[name] ?? {
+        url: lockRepo.url,
+        path: lockRepo.path,
+        branch: lockRepo.branch
+      };
+      ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
+    }
+    const verification = verifyLock(lock, this.reposDir);
+    if (!verification.ok) {
+      const issues = [
+        ...verification.drifted.map((r) => `drifted: ${r}`),
+        ...verification.missing.map((r) => `missing: ${r}`)
+      ];
+      throw new Error(`Lock file verification failed:
+  ${issues.join("\n  ")}`);
+    }
+    const resolved = [];
+    for (const [ref, entry] of Object.entries(lock.assets)) {
+      const [kind, name] = ref.split(":");
+      const repoDecl = repositories[entry.repository];
+      let repoDir;
+      if (repoDecl?.path) {
+        repoDir = resolve(this.projectDir, repoDecl.path);
+      } else {
+        repoDir = join(this.reposDir, entry.repository);
+      }
+      resolved.push({
+        name,
+        kind,
+        description: "",
+        source: join(repoDir, entry.source),
+        repository: entry.repository,
+        version: entry.version,
+        requires: [],
+        dependencies: []
+      });
+    }
+    const deployed = deployAll(resolved, repositories, patches, this.deployOpts);
+    return { deployed, removed: [], missing: [], lockWritten: false, collisions: [] };
+  }
+  /**
+   * Add a single asset (and its transitive dependencies) to the workspace.
+   *
+   * Resolves `ref`, deploys the asset and all requirements, then records the ref
+   * in `skaile.yaml` `dependencies` so subsequent `skaile install` runs re-deploy it.
+   *
+   * @param ref - Asset ref in `kind:name` or `repo/kind:name` form (e.g. `skill:my-skill`).
+   * @returns Array of asset refs that were deployed in this call.
+   * @throws When the asset cannot be found in any configured repository.
+   */
+  add(ref) {
+    const { repositories, patches } = this.loadConfig();
+    const parsed = parseAssetRef(ref);
+    for (const [name, decl] of Object.entries(repositories)) {
+      try {
+        ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
+      } catch {
+      }
+    }
+    const entry = resolveAsset(parsed, repositories, this.reposDir);
+    if (!entry) throw new Error(`Asset not found: ${ref}`);
+    const { resolved, missing } = resolveAll([ref], repositories, this.reposDir);
+    const deployed = deployAll(resolved, repositories, patches, this.deployOpts);
+    const depRef = `${parsed.kind}:${parsed.name}`;
+    this.addDependencyToConfig(depRef);
+    for (const d of deployed) {
+      appendHistory(this.projectDir, {
+        ref: d,
+        action: "add",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: this.global ? "global" : "project"
+      });
+    }
+    return deployed;
+  }
+  /**
+   * Remove a deployed asset and unregister it from `skaile.yaml`.
+   *
+   * @param ref - Asset ref in `kind:name` form (e.g. `skill:my-skill`).
+   * @returns `true` if the asset was found and removed, `false` if it was not deployed.
+   */
+  remove(ref) {
+    const parsed = parseAssetRef(ref);
+    const ok = removeAsset(parsed.kind, parsed.name, this.deployOpts);
+    if (ok) {
+      const depRef = `${parsed.kind}:${parsed.name}`;
+      this.removeDependencyFromConfig(depRef);
+      appendHistory(this.projectDir, {
+        ref: depRef,
+        action: "remove",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        context: this.global ? "global" : "project"
+      });
+    }
+    return ok;
+  }
+  // ── Query ──────────────────────────────────────────────────────────────
+  /**
+   * Search the catalog across all configured repositories.
+   *
+   * @param query - Substring to match against entry names and descriptions (case-insensitive).
+   *   Omit to return all entries.
+   * @param kind - Filter by asset kind (`"skill"`, `"agent"`, `"prompt"`, `"flow"`, `"contract"`).
+   *   Omit to return all kinds.
+   * @returns Array of matching {@link CatalogEntry} objects from all accessible repositories.
+   */
+  search(query, kind) {
+    const { repositories } = this.loadConfig();
+    let all = [];
+    for (const [name, decl] of Object.entries(repositories)) {
+      const repoDir = this.resolveRepoDir(decl, name);
+      if (!repoDir) continue;
+      all = [...all, ...scanRepo(repoDir, name)];
+    }
+    if (kind) all = all.filter((e) => e.kind === kind);
+    if (query) {
+      const q = query.toLowerCase();
+      all = all.filter(
+        (e) => e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q)
+      );
+    }
+    return all;
+  }
+  /**
+   * Look up a single asset's full catalog entry.
+   *
+   * @param ref - Asset ref in `kind:name` or `repo/kind:name` form.
+   * @returns The matching {@link CatalogEntry}, or `null` when not found.
+   */
+  info(ref) {
+    const { repositories } = this.loadConfig();
+    const parsed = parseAssetRef(ref);
+    for (const [name, decl] of Object.entries(repositories)) {
+      const repoDir = this.resolveRepoDir(decl, name);
+      if (!repoDir) continue;
+      if (parsed.repository && parsed.repository !== name) continue;
+      const entries = scanRepo(repoDir, name);
+      const match = entries.find((e) => e.kind === parsed.kind && e.name === parsed.name);
+      if (match) return match;
+    }
+    return null;
+  }
+  /**
+   * List all assets currently deployed in the workspace (or global cache).
+   *
+   * Scans the framework deploy directories rather than the lock file, so it
+   * also returns assets that were installed manually or outside of `skaile install`.
+   *
+   * @param kind - Filter by asset kind. Omit to return all kinds.
+   * @returns Shallow {@link CatalogEntry} objects (description and version will be empty).
+   */
+  listDeployed(kind) {
+    const kinds = kind ? [kind] : ["skill", "agent", "prompt", "flow", "contract"];
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const k of kinds) {
+      try {
+        const base = deployedBase(k, this.driverTarget, this.global, this.projectDir);
+        if (!existsSync(base)) continue;
+        for (const item of readdirSync(base, { withFileTypes: true })) {
+          let name;
+          if (item.isDirectory() || item.isSymbolicLink()) {
+            name = item.name;
+          } else if (item.isFile()) {
+            name = item.name.replace(/\.prompt\.md$/, "").replace(/\.flow\.(yaml|json)$/, "").replace(/\.bundle\.yaml$/, "").replace(/\.(md|toml|yaml|json)$/, "");
+          } else {
+            continue;
+          }
+          const key = `${k}:${name}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          result.push({
+            name,
+            kind: k,
+            description: "",
+            source: join(base, item.name),
+            version: "",
+            requires: [],
+            dependencies: []
+          });
+        }
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Build an aggregated workspace overview with domain grouping and sync status.
+   *
+   * Combines deployed assets, lock file metadata, and live repository status
+   * into a single structured result. Used by `skaile status`.
+   *
+   * @returns {@link OverviewResult} with entries grouped by domain and per-repo sync status.
+   */
+  overview() {
+    const { repositories } = this.loadConfig();
+    const lock = readLock(this.lockPath);
+    const deployed = this.listDeployed();
+    const repoStatuses = /* @__PURE__ */ new Map();
+    for (const [name, decl] of Object.entries(repositories)) {
+      const status = checkRepoStatus(decl, name, this.reposDir);
+      repoStatuses.set(name, {
+        name,
+        kind: status.kind,
+        behind: status.behind,
+        upToDate: status.upToDate,
+        error: status.error
+      });
+    }
+    const entries = [];
+    for (const d of deployed) {
+      const lockKey = `${d.kind}:${d.name}`;
+      const lockEntry = lock?.assets[lockKey];
+      const domain = lockEntry?.domain ?? "unknown";
+      const repository = lockEntry?.repository ?? "";
+      const version = lockEntry?.version ?? "";
+      let syncStatus = "unknown";
+      if (repository) {
+        const repoStatus = repoStatuses.get(repository);
+        if (!repoStatus) syncStatus = "unknown";
+        else if (repoStatus.kind === "local") syncStatus = "local";
+        else if (repoStatus.error) syncStatus = "error";
+        else if (repoStatus.upToDate) syncStatus = "synced";
+        else syncStatus = "outdated";
+      }
+      entries.push({ kind: d.kind, name: d.name, domain, repository, version, syncStatus });
+    }
+    const byDomain = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      if (!byDomain.has(e.domain)) byDomain.set(e.domain, []);
+      byDomain.get(e.domain).push(e);
+    }
+    const sorted = /* @__PURE__ */ new Map();
+    for (const key of [...byDomain.keys()].sort()) {
+      sorted.set(
+        key,
+        byDomain.get(key).sort(
+          (a, b) => a.kind !== b.kind ? a.kind.localeCompare(b.kind) : a.name.localeCompare(b.name)
+        )
+      );
+    }
+    return {
+      byDomain: sorted,
+      total: entries.length,
+      repos: [...repoStatuses.values()]
+    };
+  }
+  /**
+   * Build the resolved dependency tree from the lock file.
+   *
+   * @returns Root {@link DependencyNode} with `ref === "project"` whose children
+   *   are the directly-declared dependencies, each with their own transitive subtrees.
+   *   Returns a single node with `ref === "(no lock file)"` when no lock exists.
+   */
+  tree() {
+    const lock = readLock(this.lockPath);
+    if (!lock) return { ref: "(no lock file)", children: [] };
+    const byParent = /* @__PURE__ */ new Map();
+    for (const [ref, entry] of Object.entries(lock.assets)) {
+      const parent = entry.resolved_by;
+      if (!byParent.has(parent)) byParent.set(parent, []);
+      byParent.get(parent).push(ref);
+    }
+    function buildNode(ref) {
+      const children = (byParent.get(ref) ?? []).map(buildNode);
+      return { ref, children };
+    }
+    const directChildren = byParent.get("direct") ?? [];
+    return {
+      ref: "project",
+      children: directChildren.map(buildNode)
+    };
+  }
+  /**
+   * Explain why an asset is installed by tracing its dependency chain in the lock file.
+   *
+   * @param ref - Asset ref in `kind:name` form.
+   * @returns Chain of refs from the asset back to `"direct (skaile.yaml)"`, or `[]` when
+   *   the asset is not in the lock file.
+   */
+  why(ref) {
+    const lock = readLock(this.lockPath);
+    if (!lock) return [];
+    if (!lock.assets[ref]) return [];
+    const chain = [];
+    let current = ref;
+    const seen = /* @__PURE__ */ new Set();
+    while (current && current !== "direct") {
+      if (seen.has(current)) break;
+      seen.add(current);
+      chain.push(current);
+      const entry = lock.assets[current];
+      if (!entry) break;
+      current = entry.resolved_by;
+    }
+    if (current === "direct") chain.push("direct (skaile.yaml)");
+    return chain;
+  }
+  /**
+   * List installed assets whose source repository is behind the remote.
+   *
+   * Only remote repositories (not local paths) are checked for staleness.
+   *
+   * @returns Array of {@link OutdatedEntry} objects, one per asset in a repository
+   *   that has commits not yet pulled locally.
+   */
+  outdated() {
+    const { repositories } = this.loadConfig();
+    const lock = readLock(this.lockPath);
+    if (!lock) return [];
+    const result = [];
+    for (const [name, lockRepo] of Object.entries(lock.repositories)) {
+      if (!lockRepo.commit || lockRepo.path) continue;
+      const decl = repositories[name];
+      if (!decl) continue;
+      const status = checkRepoStatus(decl, name, this.reposDir);
+      if (status.behind > 0) {
+        for (const [ref, entry] of Object.entries(lock.assets)) {
+          if (entry.repository === name) {
+            const [kind, assetName] = ref.split(":");
+            result.push({
+              kind,
+              name: assetName,
+              repository: name,
+              currentVersion: entry.version,
+              behind: status.behind
+            });
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Produce a unified diff between the deployed asset and its catalog source.
+   *
+   * Useful for detecting manual edits to deployed files or verifying that a patch
+   * was applied correctly.
+   *
+   * @param ref - Asset ref in `kind:name` form.
+   * @returns Unified diff string, or `null` when there are no differences or the
+   *   asset is not deployed/resolvable.
+   */
+  diff(ref) {
+    const parsed = parseAssetRef(ref);
+    const entry = this.info(ref);
+    if (!entry) return null;
+    const deployedPath = join(
+      deployedBase(parsed.kind, this.driverTarget, this.global, this.projectDir),
+      parsed.name
+    );
+    if (!existsSync(deployedPath) || !existsSync(entry.source)) return null;
+    const { spawnSync } = __require("child_process");
+    const r = spawnSync("diff", ["-ruN", entry.source, deployedPath], { encoding: "utf8" });
+    return r.status === 1 ? r.stdout : null;
+  }
+  // ── Lock ───────────────────────────────────────────────────────────────
+  /**
+   * Resolve all declared dependencies and write (or overwrite) `skaile.lock.yaml`.
+   *
+   * Performs repository sync and full dependency resolution without deploying assets.
+   * Use this to regenerate the lock file after manually editing `skaile.yaml`.
+   *
+   * @returns The written {@link LockFile} data.
+   */
+  lock() {
+    const { repositories, dependencies } = this.loadConfig();
+    for (const [name, decl] of Object.entries(repositories)) {
+      try {
+        ensureRepo(decl, name, this.reposDir, { projectDir: this.projectDir });
+      } catch {
+      }
+    }
+    const { resolved, resolvedBy } = resolveAll(dependencies, repositories, this.reposDir);
+    const lockData = buildLockFile(
+      repositories,
+      resolved,
+      resolvedBy,
+      this.reposDir,
+      this.projectDir
+    );
+    writeLock(this.lockPath, lockData);
+    return lockData;
+  }
+  // ── Patch workflow ─────────────────────────────────────────────────────
+  /**
+   * Extract a deployed asset into a patch working directory for editing.
+   *
+   * Copies the deployed asset to `.skaile/patches/<kind>-<name>/` so changes
+   * can be made there and then committed as a patch file via `patchCommit`.
+   *
+   * @param ref - Asset ref in `kind:name` form.
+   * @returns Absolute path to the patch working directory.
+   * @throws When the asset cannot be found in the catalog.
+   */
+  patch(ref) {
+    const entry = this.info(ref);
+    if (!entry) throw new Error(`Asset not found: ${ref}`);
+    return extractForPatch(entry, this.patchDir);
+  }
+  /**
+   * Generate a `.patch` file from changes made in the patch working directory.
+   *
+   * Diffs the patch working directory against the original catalog source and
+   * writes the result to `.skaile/patches/<kind>-<name>.patch`.
+   *
+   * @param ref - Asset ref in `kind:name` form.
+   * @returns Absolute path to the generated `.patch` file.
+   * @throws When the patch working directory does not exist or no differences are found.
+   */
+  patchCommit(ref) {
+    const parsed = parseAssetRef(ref);
+    const entry = this.info(ref);
+    if (!entry) throw new Error(`Asset not found: ${ref}`);
+    const patchedDir = join(this.patchDir, `${parsed.kind}-${parsed.name}`);
+    if (!existsSync(patchedDir)) {
+      throw new Error(`No patch working dir found. Run \`skaile patch ${ref}\` first.`);
+    }
+    const { dirname } = __require("path");
+    const originalDir = dirname(entry.source);
+    const content = generatePatch(originalDir, patchedDir);
+    if (!content) throw new Error("No differences found.");
+    const patchFile = join(this.patchDir, `${parsed.kind}-${parsed.name}.patch`);
+    savePatch(patchFile, content);
+    return patchFile;
+  }
+  /**
+   * Apply the committed patch file to the repository clone and open a contribution branch.
+   *
+   * Applies `.skaile/patches/<kind>-<name>.patch` to the repository clone, creates a
+   * `patch/<kind>-<name>` branch, and stages a commit — ready to push via `contribPush`.
+   *
+   * @param ref - Asset ref in `kind:name` form.
+   * @throws When the asset is not found, has no repository, or the patch file is missing.
+   */
+  patchSubmit(ref) {
+    const parsed = parseAssetRef(ref);
+    const entry = this.info(ref);
+    if (!entry?.repository) throw new Error(`Asset not found or no repository: ${ref}`);
+    const { repositories } = this.loadConfig();
+    const decl = repositories[entry.repository];
+    if (!decl?.url) throw new Error("Can only submit patches for remote repositories.");
+    const repoDir = join(this.reposDir, entry.repository);
+    const branchName = `patch/${parsed.kind}-${parsed.name}`;
+    const patchFile = join(this.patchDir, `${parsed.kind}-${parsed.name}.patch`);
+    if (!existsSync(patchFile)) throw new Error("No patch file. Run `skaile patch-commit` first.");
+    applyPatch(repoDir, patchFile);
+    commitChanges(repoDir, `fix: improve ${parsed.kind} ${parsed.name}`, branchName);
+  }
+  /**
+   * Delete the patch working directory and patch file for an asset.
+   *
+   * @param ref - Asset ref in `kind:name` form.
+   */
+  patchRemove(ref) {
+    const parsed = parseAssetRef(ref);
+    const patchFile = join(this.patchDir, `${parsed.kind}-${parsed.name}.patch`);
+    const patchedDir = join(this.patchDir, `${parsed.kind}-${parsed.name}`);
+    const { rmSync: rmSync2 } = __require("fs");
+    try {
+      rmSync2(patchFile);
+    } catch {
+    }
+    try {
+      rmSync2(patchedDir, { recursive: true });
+    } catch {
+    }
+  }
+  // ── Doctor ─────────────────────────────────────────────────────────────
+  /**
+   * Scan deployed assets for unsatisfied transitive dependencies.
+   *
+   * For each deployed asset, checks that all entries in its `requires` list are
+   * also deployed. Returns a list of issues with a flag indicating whether the
+   * missing dependency can be resolved from a configured repository.
+   *
+   * @returns Array of {@link DepIssue} objects. An empty array means the workspace is healthy.
+   */
+  doctor() {
+    const { repositories } = this.loadConfig();
+    const deployed = this.listDeployed();
+    const issues = [];
+    for (const entry of deployed) {
+      const full = this.info(`${entry.kind}:${entry.name}`);
+      if (!full) continue;
+      for (const req of full.requires) {
+        if (!isDeployed(
+          req.kind,
+          req.name,
+          this.driverTarget,
+          this.global,
+          this.projectDir
+        )) {
+          const inRepos = resolveAsset({ kind: req.kind, name: req.name }, repositories, this.reposDir) !== null;
+          issues.push({
+            assetKind: entry.kind,
+            assetName: entry.name,
+            depKind: req.kind,
+            depName: req.name,
+            inRepos
+          });
+        }
+      }
+    }
+    return issues;
+  }
+  // ── Scaffold ───────────────────────────────────────────────────────────
+  /**
+   * Create a minimal asset scaffold directory (delegates to {@link createScaffold}).
+   *
+   * @param name - Asset name (also used as the directory name).
+   * @param kind - Asset kind: `skill` | `agent` | `bundle` | `flow` | `prompt` | `contract`.
+   * @param destDir - Parent directory to create the asset in.
+   * @returns `{ ok: true, path }` on success, `{ ok: false, path: errorMessage }` if the
+   *   directory already exists.
+   */
+  create(name, kind, destDir) {
+    return createScaffold(name, kind, destDir);
+  }
+  // ── Contrib (REMOVED 2026-05-12) ───────────────────────────────────────
+  //
+  // The `contribChanges / contribDiff / contribCommit / contribPush /
+  // contribCompare` methods were retired alongside `skaile repo contrib *`.
+  // The refinement push-back workflow is being re-introduced in Phase 4 as
+  // `skaile publish` + `skaile preset push` against the Library Source model.
+  // ── History ────────────────────────────────────────────────────────────
+  /**
+   * Return recent asset action history entries, newest first.
+   *
+   * @param limit - Maximum number of entries to return. Defaults to `20`.
+   * @returns Array of {@link HistoryEntry} objects in reverse-chronological order.
+   */
+  history(limit = 20) {
+    return getRecentHistory(this.projectDir, limit);
+  }
+  /**
+   * Erase all asset action history for this workspace.
+   */
+  clearHistory() {
+    clearHistory(this.projectDir);
+  }
+  // ── Clean ───────────────────────────────────────────────────────────────
+  /**
+   * Remove deployed assets tracked by the lock file and report unmanaged ones.
+   *
+   * With `opts.all`, also deletes `.skaile/history.yaml`, `.skaile/patches/`,
+   * `.skaile/repos/`, and `skaile.lock.yaml` — effectively resetting the workspace
+   * to a pre-install state.
+   *
+   * @param opts - Optional cleanup options.
+   * @param opts.all - When `true`, remove all Skaile-managed state in addition to deployed assets.
+   * @returns Object with `removed` (successfully cleaned refs), `skipped` (with reasons),
+   *   and `unmanaged` (deployed assets not in the lock file).
+   */
+  clean(opts) {
+    const lock = readLock(this.lockPath);
+    const removed = [];
+    const skipped = [];
+    if (lock) {
+      for (const ref of Object.keys(lock.assets)) {
+        const [kind, name] = ref.split(":");
+        const dest = deployedDir(
+          kind,
+          name,
+          this.driverTarget,
+          this.global,
+          this.projectDir
+        );
+        try {
+          const stat = lstatSync(dest);
+          if (stat.isSymbolicLink()) unlinkSync(dest);
+          else rmSync(dest, { recursive: true, force: true });
+          removed.push(ref);
+        } catch {
+          removed.push(ref);
+        }
+      }
+    }
+    const lockRefs = lock ? new Set(Object.keys(lock.assets)) : /* @__PURE__ */ new Set();
+    const unmanaged = [];
+    const allDeployed = this.listDeployed();
+    for (const d of allDeployed) {
+      const ref = `${d.kind}:${d.name}`;
+      if (!lockRefs.has(ref)) {
+        unmanaged.push(ref);
+      }
+    }
+    if (opts?.all) {
+      const historyFile = join(this.projectDir, ".skaile", "history.yaml");
+      try {
+        unlinkSync(historyFile);
+      } catch {
+      }
+      try {
+        rmSync(this.patchDir, { recursive: true, force: true });
+      } catch {
+      }
+      try {
+        rmSync(this.reposDir, { recursive: true, force: true });
+      } catch {
+      }
+      try {
+        unlinkSync(this.lockPath);
+      } catch {
+      }
+    }
+    return { removed, skipped, unmanaged };
+  }
+  // ── Helpers ────────────────────────────────────────────────────────────
+  /** Add a dependency ref to skaile.yaml if not already present. */
+  addDependencyToConfig(ref) {
+    if (this.global) return;
+    const configPath = join(this.projectDir, "skaile.yaml");
+    if (!existsSync(configPath)) return;
+    const { parse, stringify } = __require("yaml");
+    const raw = parse(readFileSync(configPath, "utf8")) ?? {};
+    if (!raw.dependencies) raw.dependencies = [];
+    if (!raw.dependencies.includes(ref)) {
+      raw.dependencies.push(ref);
+      __require("fs").writeFileSync(configPath, stringify(raw, { lineWidth: 120 }));
+    }
+  }
+  /** Remove a dependency ref from skaile.yaml. */
+  removeDependencyFromConfig(ref) {
+    if (this.global) return;
+    const configPath = join(this.projectDir, "skaile.yaml");
+    if (!existsSync(configPath)) return;
+    const { parse, stringify } = __require("yaml");
+    const raw = parse(readFileSync(configPath, "utf8")) ?? {};
+    if (!raw.dependencies) return;
+    const idx = raw.dependencies.indexOf(ref);
+    if (idx !== -1) {
+      raw.dependencies.splice(idx, 1);
+      __require("fs").writeFileSync(configPath, stringify(raw, { lineWidth: 120 }));
+    }
+  }
+  resolveRepoDir(decl, name) {
+    const links = readLinks(this.projectDir);
+    if (links[name]) {
+      return existsSync(links[name]) ? links[name] : null;
+    }
+    if (decl.path) {
+      const resolved = resolve(this.projectDir, decl.path);
+      return existsSync(resolved) ? resolved : null;
+    }
+    const dest = join(this.reposDir, name);
+    if (existsSync(dest)) return dest;
+    const globalDest = join(getGlobalCacheDir(), name);
+    if (existsSync(join(globalDest, ".git"))) return globalDest;
+    return null;
+  }
+};
+
+export { AssetManager };
+//# sourceMappingURL=chunk-EE3XTJ62.js.map
+//# sourceMappingURL=chunk-EE3XTJ62.js.map