@skaile/workspaces 0.43.1 → 0.45.0

package/dist/{chunk-WKZ5R4NP.js → chunk-L6BKSTAX.js}

@@ -1,15 +1,14 @@
-import { deployAll, removeAsset, createScaffold } from './chunk-NYMRKIOR.js';
-import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-KYQNWFJV.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-HVCZLD5Z.js';
-import { resolveSkWorkspaceConfig, getRepoCommit, buildProvenanceIndex, resolveAll, ensureRepo, scanRepo, checkRepoStatus, resolveAsset, readLinks, getGlobalCacheDir } from './chunk-GJI6FZ56.js';
+import { deployAll, removeAsset, createScaffold } from './chunk-CVWA4RIK.js';
+import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-BLGHFVXE.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-VPXV2Z5E.js';
+import { migrateLegacyDir, resolveSkWorkspaceConfig, getGlobalCacheDir, getRepoCommit, resolveAll, buildProvenanceIndex, ensureRepo, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks } from './chunk-COSTF7QW.js';
 import { parseAssetRef } from './chunk-GEEW6SY2.js';
 import { deployedBase, isDeployed, deployedDir } from './chunk-XGCXFX7X.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
 import { spawnSync } from 'child_process';
 import { existsSync, readdirSync, rmSync, lstatSync, unlinkSync, readFileSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
-import { resolve, join, dirname } from 'path';
+import { resolve, join, sep, dirname } from 'path';
 import { parse, stringify } from 'yaml';
 
 function sourceSlug(url) {
@@ -18,6 +17,46 @@ function sourceSlug(url) {
 function normalizeRepoUrl(url) {
   return url.trim().replace(/^git@([^:]+):/, "https://$1/").replace(/^[a-z]+:\/\//i, "").replace(/\.git$/i, "").replace(/\/+$/, "").toLowerCase();
 }
+var MD_BY_KIND = {
+  skill: "SKILL.md",
+  agent: "AGENT.md",
+  bundle: "BUNDLE.md",
+  "mcp-server": "MCP.md",
+  connector: "CONNECTOR.md",
+  prompt: "PROMPT.md",
+  contract: "CONTRACT.md"
+};
+function matchManifestPath(kind, paths) {
+  const exact = MD_BY_KIND[kind];
+  if (exact) {
+    const hit = paths.find((p) => p.endsWith(exact));
+    if (hit) return hit;
+  }
+  if (kind === "prompt") return paths.find((p) => p.endsWith(".prompt.md"));
+  if (kind === "flow") {
+    return paths.find((p) => p.endsWith(".flow.yaml") || p.endsWith(".flow.json"));
+  }
+  return void 0;
+}
+var NON_DEPLOYABLE_KINDS = /* @__PURE__ */ new Set([
+  "bundle",
+  "mcp-server",
+  "persona",
+  "ruleset",
+  "knowledge"
+]);
+function commonDirPrefix(paths) {
+  if (paths.length === 0) return "";
+  const dirs = paths.map((p) => p.split("/").slice(0, -1));
+  let common = dirs[0];
+  for (let i = 1; i < dirs.length && common.length > 0; i++) {
+    const segs = dirs[i];
+    let n = 0;
+    while (n < common.length && n < segs.length && common[n] === segs[n]) n++;
+    common = common.slice(0, n);
+  }
+  return common.join("/");
+}
 function indexLockByKindName(lock) {
   const lockByKindName = /* @__PURE__ */ new Map();
   for (const [key] of Object.entries(lock?.assets ?? {})) {
@@ -69,6 +108,14 @@ function parseCanonicalLockKey(key) {
     return {};
   }
 }
+var MissingManifestError = class extends Error {
+  constructor(projectDir) {
+    super(`No skaile.yaml in ${projectDir}.`);
+    this.projectDir = projectDir;
+    this.name = "MissingManifestError";
+  }
+  projectDir;
+};
 var FACTORY_SOURCE_URL = "https://github.com/skaile-ai/ai-assets";
 function resolveFactoryAssetsDir() {
   for (const dir of factoryAssetRoots()) {
@@ -99,13 +146,39 @@ var AssetManager = class {
   driverTarget;
   /** Whether this instance operates in global-install mode. */
   global;
+  /** Injected catalog fetcher (tests / custom); falls back to a built one. */
+  injectedStoreFetcher;
+  /** Injected byte fetcher for store staging; falls back to GitHub. */
+  injectedAssetFetcher;
+  /** Injected global catalog URL override for the no-project-store fallback. */
+  catalogUrlOverride;
   constructor(opts) {
     this.projectDir = resolve(opts.projectDir);
     this.driverTarget = opts.driverTarget ?? "claude-code";
     this.global = opts.global ?? false;
+    this.injectedStoreFetcher = opts.storeFetcher;
+    this.injectedAssetFetcher = opts.assetFetcher;
+    this.catalogUrlOverride = opts.catalogUrl;
+  }
+  get storeCacheDir() {
+    return migrateLegacyDir(
+      join(this.projectDir, ".skaile", "cache", "store"),
+      join(this.projectDir, ".skaile", "store-cache")
+    );
   }
   get reposDir() {
-    return join(this.projectDir, ".skaile", "repos");
+    return migrateLegacyDir(
+      join(this.projectDir, ".skaile", "cache", "sources"),
+      join(this.projectDir, ".skaile", "repos")
+    );
+  }
+  /**
+   * Project-scoped cache dirs rooted at `.skaile/cache/` (`store`, `sources`)
+   * relative to `projectDir`. Reading is a side effect: it triggers lazy
+   * migration of the legacy `.skaile/{store-cache,repos}` dirs.
+   */
+  get projectCacheDirs() {
+    return { store: this.storeCacheDir, sources: this.reposDir };
   }
   get lockPath() {
     return join(this.projectDir, "skaile.lock.yaml");
@@ -123,8 +196,7 @@ var AssetManager = class {
     const dependencies = config.dependencies ?? [];
     const overrides = config.overrides ?? [];
     const patches = config.patches ?? {};
-    const skaileHome = process.env.SKAILE_HOME ?? join(homedir(), ".skaile");
-    const sourcesDir = join(skaileHome, "sources");
+    const sourcesDir = getGlobalCacheDir();
     const repositories = {};
     for (const s of sources) {
       const slug = sourceSlug(s.url);
@@ -185,15 +257,6 @@ var AssetManager = class {
       }
     }
     if (!cloneDir || !slug) return null;
-    const MD_BY_KIND = {
-      skill: "SKILL.md",
-      agent: "AGENT.md",
-      bundle: "BUNDLE.md",
-      "mcp-server": "MCP.md",
-      connector: "CONNECTOR.md",
-      prompt: "PROMPT.md",
-      contract: "CONTRACT.md"
-    };
     const mdName = MD_BY_KIND[c.kind];
     const mdRel = c.files.find((f) => mdName ? f.path.endsWith(mdName) : false)?.path;
     const source = mdRel ? join(cloneDir, mdRel) : cloneDir;
@@ -215,6 +278,184 @@ var AssetManager = class {
     if (c.homepage != null) entry.homepage = c.homepage;
     return entry;
   }
+  // ── Store fetch-then-deploy ────────────────────────────────────────────
+  /** A candidate's stable identity key (`<publisher>/<kind>:<name>@<version>`). */
+  candidateKey(c) {
+    return `${c.publisher}/${c.kind}:${c.name}@${c.version}`;
+  }
+  /**
+   * Resolve `deps`, falling back to the global `catalog.url` store when the
+   * project declares no store and the first pass leaves something missing.
+   *
+   * The first pass uses the project stores only, so locally-resolvable refs
+   * never trigger a network probe. The fallback retry is best-effort: any error
+   * (offline, store down) keeps the first pass's result rather than regressing.
+   */
+  async resolveWithStores(deps, opts) {
+    const first = await resolveAll(deps, {
+      provenanceIndex: opts.provenanceIndex,
+      overrides: opts.overrides,
+      stores: opts.stores,
+      storeFetcher: this.storeFetcherFor(opts.stores),
+      projectDir: this.projectDir
+    });
+    if (first.missing.length === 0) return first;
+    const fallback = await this.globalStoreFallback(opts.stores);
+    if (fallback.length === 0) return first;
+    const stores = [...opts.stores, ...fallback];
+    try {
+      const retry = await resolveAll(deps, {
+        provenanceIndex: opts.provenanceIndex,
+        overrides: opts.overrides,
+        stores,
+        storeFetcher: this.storeFetcherFor(stores),
+        projectDir: this.projectDir
+      });
+      return retry.missing.length < first.missing.length ? retry : first;
+    } catch {
+      return first;
+    }
+  }
+  /** The catalog fetcher to use: an injected one, else built from `stores`. */
+  storeFetcherFor(stores) {
+    return this.injectedStoreFetcher ?? this.buildStoreFetcher(stores);
+  }
+  /**
+   * The global `catalog.url` as a single-store fallback, or `[]` when no
+   * project store should be synthesized — `local` sentinel, already-declared,
+   * or no URL. Honours an explicit `catalogUrl` injection (`""` disables it).
+   */
+  async globalStoreFallback(projectStores) {
+    let url = this.catalogUrlOverride;
+    if (url === void 0) {
+      try {
+        const { resolveConfig } = await import('./library/index.js');
+        url = resolveConfig({ projectDir: this.projectDir }).catalog.url;
+      } catch {
+        return [];
+      }
+    }
+    if (!url || url.trim().toLowerCase() === "local") return [];
+    if (projectStores.some((s) => normalizeRepoUrl(s.url) === normalizeRepoUrl(url))) return [];
+    return [{ url }];
+  }
+  /**
+   * Build deployable catalog entries from resolved candidates. Store-resolved
+   * candidates (no local clone bytes) are fetched + SHA-verified into the
+   * project store-cache first, then their entry points at the staged bytes so
+   * the existing copy-deploy path works. Source-backed candidates keep the
+   * clone-relative entry.
+   */
+  async buildCatalogEntries(resolved, repositories) {
+    const staged = await this.stageStoreAssets(resolved, repositories);
+    const entries = [];
+    for (const c of resolved) {
+      const stagedPath = staged.get(this.candidateKey(c));
+      const entry = stagedPath ? this.stagedCandidateToEntry(c, stagedPath) : this.candidateToCatalogEntry(c, repositories);
+      if (entry) entries.push(entry);
+    }
+    return entries;
+  }
+  /**
+   * Fetch + SHA-verify the bytes of every store-resolved deployable candidate
+   * into `.skaile/cache/store/`, reusing the same verified-fetch path the
+   * pointer-only `library.install` uses (`installFromManifest` flat mode).
+   *
+   * @returns Map of candidate key → staged primary-manifest path.
+   */
+  async stageStoreAssets(resolved, repositories) {
+    const staged = /* @__PURE__ */ new Map();
+    let installFromManifest;
+    for (const c of resolved) {
+      if (NON_DEPLOYABLE_KINDS.has(c.kind)) continue;
+      if (!c.files || c.files.length === 0 || !c.sourceUrl || !c.commit) continue;
+      if (this.candidateHasLocalBytes(c, repositories)) continue;
+      if (!installFromManifest) {
+        ({ installFromManifest } = await import('./library/index.js'));
+      }
+      const targetDir = join(this.storeCacheDir, c.publisher, c.kind, c.name, c.version);
+      const cacheRoot = resolve(this.storeCacheDir);
+      if (!resolve(targetDir).startsWith(cacheRoot + sep)) {
+        throw new Error(`unsafe store-cache path for ${this.candidateKey(c)}`);
+      }
+      const manifest = {
+        ref: `${c.kind}:@${c.publisher}/${c.name}#${c.version}`,
+        source: { url: c.sourceUrl, commitSha: c.commit },
+        files: c.files,
+        sha256: c.sha256,
+        kind: c.kind,
+        // tier = catalog storage hint (S3/CDN); flat-mode verified fetch pulls
+        // from source.url@commit and ignores it, so "" is inert.
+        tier: ""
+      };
+      const { installPath } = await installFromManifest({
+        manifest,
+        libraryRoot: this.storeCacheDir,
+        targetDir,
+        fetcher: this.injectedAssetFetcher
+      });
+      staged.set(this.candidateKey(c), join(installPath, this.stagedManifestRel(c)));
+    }
+    return staged;
+  }
+  /** Repo-relative path of a candidate's primary manifest (un-stripped). */
+  primaryManifestRel(c) {
+    const paths = (c.files ?? []).map((f) => f.path);
+    return matchManifestPath(c.kind, paths) ?? paths[0];
+  }
+  /**
+   * The primary-manifest path relative to a staged asset dir. Takes the kind's
+   * manifest (e.g. `SKILL.md`), then strips the same common-dir prefix
+   * `installFromManifest` flat mode removed on write.
+   */
+  stagedManifestRel(c) {
+    const paths = (c.files ?? []).map((f) => f.path);
+    const mdRel = this.primaryManifestRel(c) ?? "";
+    const root = commonDirPrefix(paths);
+    return root && mdRel.startsWith(`${root}/`) ? mdRel.slice(root.length + 1) : mdRel;
+  }
+  /**
+   * `true` when a candidate's primary manifest is present on a local source
+   * clone — its `sourceUrl` matches a registered source AND the manifest file
+   * exists on disk at the expected path. A URL match alone is not enough: a
+   * store can pin a different commit (or a subtree not bundled) of a repo that
+   * is also a registered source, in which case the bytes must be fetched from
+   * the store rather than read from the clone. (Only the primary manifest is
+   * probed — a partially-cloned source is deployed as-is, matching the existing
+   * clone-deploy path.)
+   */
+  candidateHasLocalBytes(c, repositories) {
+    if (!c.sourceUrl) return false;
+    const rel = this.primaryManifestRel(c);
+    for (const [slug, decl] of Object.entries(repositories)) {
+      if (decl.url === void 0 || decl.url !== c.sourceUrl) continue;
+      const dir = this.resolveRepoDir(decl, slug);
+      if (!dir) continue;
+      if (existsSync(rel ? join(dir, rel) : dir)) return true;
+    }
+    return false;
+  }
+  /** Build a copy-deploy catalog entry pointing at staged store bytes. */
+  stagedCandidateToEntry(c, stagedManifestPath) {
+    const entry = {
+      name: c.name,
+      kind: c.kind,
+      description: c.description ?? "",
+      source: stagedManifestPath,
+      // Real publisher (never a clone slug) → deployAsset copies rather than
+      // symlinking the ephemeral store-cache dir.
+      publisher: c.publisher,
+      version: c.version,
+      requires: [],
+      dependencies: c.deps ?? [],
+      metadata: c.metadata
+    };
+    if (c.category != null) entry.category = c.category;
+    if (c.keywords && c.keywords.length > 0) entry.keywords = c.keywords;
+    if (c.license != null) entry.license = c.license;
+    if (c.homepage != null) entry.homepage = c.homepage;
+    return entry;
+  }
   // ── Install / resolve ──────────────────────────────────────────────────
   /**
    * Install all dependencies declared in `skaile.yaml`.
@@ -237,15 +478,13 @@ var AssetManager = class {
     const provenanceIndex = buildProvenanceIndex(this.buildClones(repositories), {
       projectDir: this.projectDir
     });
-    const { resolved, missing, overridesApplied } = await resolveAll(dependencies, {
+    const { resolved, missing, overridesApplied } = await this.resolveWithStores(dependencies, {
       provenanceIndex,
       overrides,
-      stores,
-      storeFetcher: this.buildStoreFetcher(stores),
-      projectDir: this.projectDir
+      stores
     });
     const removed = this.reconcileRemovedAssets(resolved);
-    const entries = resolved.map((c) => this.candidateToCatalogEntry(c, repositories)).filter((e) => e !== null);
+    const entries = await this.buildCatalogEntries(resolved, repositories);
     const deployed = deployAll(entries, repositories, patches, this.deployOpts);
     writeLock(this.lockPath, buildLockFile(resolved, overridesApplied));
     this.recordInstallHistory(deployed, removed);
@@ -453,19 +692,17 @@ var AssetManager = class {
     const provenanceIndex = buildProvenanceIndex(this.buildClones(repositories), {
       projectDir: this.projectDir
     });
-    const { resolved, missing } = await resolveAll([ref], {
+    const { resolved, missing } = await this.resolveWithStores([ref], {
       provenanceIndex,
       overrides,
-      stores,
-      storeFetcher: this.buildStoreFetcher(stores),
-      projectDir: this.projectDir
+      stores
     });
     if (resolved.length === 0) {
       throw new Error(
         `Asset not found: ${ref}${missing.length ? ` (missing: ${missing.join(", ")})` : ""}`
       );
     }
-    const entries = resolved.map((c) => this.candidateToCatalogEntry(c, repositories)).filter((e) => e !== null);
+    const entries = await this.buildCatalogEntries(resolved, repositories);
     const deployed = deployAll(entries, repositories, patches, this.deployOpts);
     this.addDependencyToConfig(ref);
     for (const d of deployed) {
@@ -590,6 +827,65 @@ var AssetManager = class {
     }
     return result;
   }
+  /**
+   * List the **declared** top-level dependencies from `skaile.yaml`, each tagged
+   * with a reconciliation {@link DeclaredState}:
+   *
+   * - `declared` — in `skaile.yaml`, not yet resolved into the lock.
+   * - `installed` — declared + locked, and (for deployable kinds) materialized on
+   *   disk. Non-deployable kinds ({@link NON_DEPLOYABLE_KINDS}) count as installed
+   *   once locked — they are wired at session start, never written to the target dir.
+   * - `drift` — declared + locked but the deployed files are missing on disk.
+   * - `invalid` — the `dependencies:` entry isn't a parseable canonical ref. Only
+   *   surfaced in the unfiltered listing (a `kind` filter can't classify it).
+   *
+   * Transitive (lock-only) deps are excluded by construction — only the declared
+   * set is walked, so a lock entry with no matching `dependencies:` ref never shows.
+   *
+   * @param kind - Filter by asset kind. Omit to return all kinds.
+   * @returns One {@link DeclaredAsset} per declared dep (after the optional kind filter).
+   * @throws {MissingManifestError} when the project has no `skaile.yaml`.
+   * @throws {Error} with a `migrate-skaile-manifest` hint on legacy `repositories:` / `ai_resources:` keys.
+   */
+  listDeclared(kind) {
+    if (!existsSync(join(this.projectDir, SKAILE_YAML_DEFAULT))) {
+      throw new MissingManifestError(this.projectDir);
+    }
+    const dependencies = resolveSkWorkspaceConfig(this.projectDir).dependencies ?? [];
+    const lock = this.tryReadLock();
+    const lockKeys = lock ? Object.keys(lock.assets).map(parseCanonicalLockKey) : [];
+    const out = [];
+    for (const ref of dependencies) {
+      let parsed;
+      try {
+        parsed = parseAssetRef(ref);
+      } catch {
+        if (!kind) out.push({ ref, kind: "", name: ref, state: "invalid" });
+        continue;
+      }
+      if (kind && parsed.kind !== kind) continue;
+      const locked = lockKeys.some(
+        (k) => k.kind === parsed.kind && k.name === parsed.name && (!parsed.publisher || k.publisher === parsed.publisher)
+      );
+      let state;
+      if (!locked) {
+        state = "declared";
+      } else if (NON_DEPLOYABLE_KINDS.has(parsed.kind)) {
+        state = "installed";
+      } else {
+        const onDisk = isDeployed(
+          parsed.kind,
+          parsed.name,
+          this.driverTarget,
+          this.global,
+          this.projectDir
+        );
+        state = onDisk ? "installed" : "drift";
+      }
+      out.push({ ref, kind: parsed.kind, name: parsed.name, state });
+    }
+    return out;
+  }
   /**
    * Build an aggregated workspace overview with domain grouping and sync status.
    *
@@ -739,12 +1035,10 @@ var AssetManager = class {
     const provenanceIndex = buildProvenanceIndex(this.buildClones(repositories), {
       projectDir: this.projectDir
     });
-    const { resolved, overridesApplied } = await resolveAll(dependencies, {
+    const { resolved, overridesApplied } = await this.resolveWithStores(dependencies, {
       provenanceIndex,
       overrides,
-      stores,
-      storeFetcher: this.buildStoreFetcher(stores),
-      projectDir: this.projectDir
+      stores
     });
     const lockData = buildLockFile(resolved, overridesApplied);
     writeLock(this.lockPath, lockData);
@@ -911,8 +1205,8 @@ var AssetManager = class {
    * 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.
+   * `.skaile/cache/sources/`, 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.
@@ -976,7 +1270,7 @@ var AssetManager = class {
     }
     return unmanaged;
   }
-  /** Delete all Skaile-managed state: history file, patches/, repos/, lock. */
+  /** Delete all Skaile-managed state: history file, patches/, cache/sources/, lock. */
   removeAllManagedState() {
     const historyFile = join(this.projectDir, ".skaile", "history.yaml");
     try {
@@ -1039,6 +1333,6 @@ var AssetManager = class {
   }
 };
 
-export { AssetManager, parseCanonicalLockKey };
-//# sourceMappingURL=chunk-WKZ5R4NP.js.map
-//# sourceMappingURL=chunk-WKZ5R4NP.js.map
+export { AssetManager, MissingManifestError, NON_DEPLOYABLE_KINDS, parseCanonicalLockKey };
+//# sourceMappingURL=chunk-L6BKSTAX.js.map
+//# sourceMappingURL=chunk-L6BKSTAX.js.map