@skaile/workspaces 1.0.0 → 1.1.0

package/dist/{chunk-SFVEHSCI.js → chunk-L3SLC3S4.js}

@@ -1,9 +1,10 @@
-import { deployAll, removeAsset, createScaffold } from './chunk-FLRHP3UC.js';
-import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-3KPNDTMR.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-W53D5Q52.js';
+import { deployAll, removeAsset, createScaffold } from './chunk-35TLBMHX.js';
+import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-MG6UIS7G.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-BM37QD6U.js';
+import { globalSkaileDir, resolveGlobalBackends, globalCacheRoot, migrateLegacyDir, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks } from './chunk-5AGARSQT.js';
+import { parseRequires } from './chunk-BQCGFPHW.js';
+import { parseAssetRef, assetRefToStr } from './chunk-GEEW6SY2.js';
 import { deployedBase, isDeployed, deployedDir } from './chunk-F3HNW354.js';
-import { globalSkaileDir, resolveGlobalBackends, globalCacheRoot, migrateLegacyDir, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks } from './chunk-NXC6IEL4.js';
-import { parseAssetRef } from './chunk-GEEW6SY2.js';
 import { appendHistory, getRecentHistory, clearHistory } from './chunk-KTBKW2FI.js';
 import { commitChanges } from './chunk-UQ6LFBPZ.js';
 import { spawnSync } from 'child_process';
@@ -105,6 +106,40 @@ function parseCanonicalLockKey(key) {
     return {};
   }
 }
+function softDepName(ref) {
+  const at = ref.lastIndexOf("@");
+  const base = at > 0 ? ref.slice(0, at) : ref;
+  const slash = base.lastIndexOf("/");
+  return slash >= 0 ? base.slice(slash + 1) : base;
+}
+function depRefFromDef(def) {
+  const publisher = def.publisher.replace(/^@/, "");
+  if (!publisher) return void 0;
+  return assetRefToStr({ kind: def.kind, name: def.name, publisher });
+}
+function parseRefLoose(ref) {
+  try {
+    return parseAssetRef(ref);
+  } catch {
+    const hash = ref.indexOf("#");
+    if (hash < 0) return null;
+    try {
+      return parseAssetRef(ref.slice(0, hash));
+    } catch {
+      return null;
+    }
+  }
+}
+function matchDefsForRef(defs, ref) {
+  const exact = defs.filter((d) => d.id === ref);
+  if (exact.length > 0) return exact;
+  const parsed = parseRefLoose(ref);
+  if (!parsed) return [];
+  const wantPub = parsed.publisher?.replace(/^@/, "");
+  return defs.filter(
+    (d) => d.name === parsed.name && d.kind === parsed.kind && (wantPub === void 0 || d.publisher.replace(/^@/, "") === wantPub)
+  );
+}
 var MissingManifestError = class extends Error {
   constructor(projectDir) {
     super(`No skaile.yaml in ${projectDir}.`);
@@ -151,6 +186,8 @@ var AssetManager = class {
   injectedAssetFetcher;
   /** Injected global catalog URL override for the no-project-store fallback. */
   catalogUrlOverride;
+  /** Injected index SQLite path override (tests); else the default index.db. */
+  indexPathOverride;
   constructor(opts) {
     this.projectDir = resolve(opts.projectDir);
     this.driverTarget = opts.driverTarget ?? "claude-code";
@@ -159,6 +196,7 @@ var AssetManager = class {
     this.injectedStoreFetcher = opts.storeFetcher;
     this.injectedAssetFetcher = opts.assetFetcher;
     this.catalogUrlOverride = opts.catalogUrl;
+    this.indexPathOverride = opts.indexPath;
   }
   /**
    * Root for this manager's **state** — config SSOT, lock, cache, history.
@@ -766,6 +804,198 @@ var AssetManager = class {
     }
     return deployed;
   }
+  /**
+   * Report the body-link **soft dependencies** of the given assets that are not
+   * already present in the project.
+   *
+   * Looks up each ref's persisted `softDeps` in the local index
+   * (`~/.skaile/index.db`, populated by `skaile source sync`) and returns the
+   * edges whose target is neither a declared dependency nor deployed on disk. It
+   * does **not** install anything and never touches the resolver / lock /
+   * reconcile path: callers surface the result as a hint, the user opts in with
+   * a follow-up `skaile add`. Inspects exactly the passed `refs` — soft deps of
+   * their transitively-deployed dependencies are not surfaced here.
+   *
+   * Opening the index runs its idempotent migrations, so this is not a pure
+   * read — but it is **best-effort**: any failure (legacy/corrupt index, a
+   * removed-backend guard) yields `[]`, so it can never fail a primary `add`
+   * that already succeeded.
+   *
+   * @param refs - Asset refs to inspect (canonical, `kind:@pub/name`, or `kind:name`).
+   * @returns One edge per absent soft-dep target (deduped by target). `toRef` is
+   *   the parseable `skaile add` ref, omitted when the target isn't in the index.
+   */
+  async reportSoftDeps(refs) {
+    if (refs.length === 0) return [];
+    return this.withIndexDefs(
+      (allDefs) => this.collectSoftDeps(allDefs, refs, true),
+      []
+    );
+  }
+  /**
+   * All body-link soft dependencies of the given assets — present or not.
+   *
+   * Unlike {@link reportSoftDeps} (which filters to *absent* targets so it can
+   * nudge a follow-up `skaile add`), this returns the asset's full inferred
+   * soft-dep set for display surfaces (`skaile info` / `tree` / `why`). Read-only
+   * and best-effort: any index failure yields `[]`. Targets are deduped.
+   *
+   * @param refs - Asset refs to inspect (canonical, `kind:@pub/name`, or `kind:name`).
+   * @returns One {@link SoftDepEdge} per soft-dep target. `toRef` is the parseable
+   *   ref, omitted when the target isn't in the index.
+   */
+  async softDepsOf(refs) {
+    if (refs.length === 0) return [];
+    return this.withIndexDefs((allDefs) => this.collectSoftDeps(allDefs, refs, false), []);
+  }
+  /**
+   * Reverse lookup: refs (canonical ids) of cached assets whose persisted
+   * `softDeps` include `targetRef`. Scans the whole index, not just present
+   * assets. Read-only and best-effort (`[]` on any index failure).
+   *
+   * @param targetRef - Canonical soft-dep target ref (`<publisher>/<name>@<version>`).
+   * @returns Def ids that declare `targetRef` as a soft dependency.
+   */
+  async softDepDependents(targetRef) {
+    return this.withIndexDefs(
+      (allDefs) => allDefs.filter((d) => d.softDeps?.includes(targetRef)).map((d) => d.id),
+      []
+    );
+  }
+  /**
+   * Compute which soft-dependency targets would be left **orphaned** by removing
+   * `refs`: targets still present in the project that came in as one of `refs`'
+   * soft dependencies and that **nothing else still needs** — neither another
+   * present asset's soft-dep ({@link softDepDependents}) nor a typed `requires`.
+   *
+   * Pure read — never removes anything. The CLI / manage surfaces each result as
+   * a prompt (default No) so the user opts in to an extra `skaile remove`. Safe to
+   * call before or after the primary remove: assets being removed are excluded
+   * from the "needed by others" scan, so a soft target referenced only by the
+   * removed asset is still reported as an orphan.
+   *
+   * @param refs - Asset refs being removed (canonical, `kind:@pub/name`, or `kind:name`).
+   * @returns One {@link OrphanedSoftDep} per orphaned target (deduped).
+   */
+  async orphanedSoftDepsAfterRemoving(refs) {
+    if (refs.length === 0) return [];
+    return this.withIndexDefs((allDefs) => {
+      const byId = new Map(allDefs.map((d) => [d.id, d]));
+      const present = this.presentRefNames();
+      const removedNames = /* @__PURE__ */ new Set();
+      for (const ref of refs) {
+        for (const def of matchDefsForRef(allDefs, ref)) removedNames.add(def.name);
+        try {
+          removedNames.add(parseAssetRef(ref).name);
+        } catch {
+        }
+      }
+      const neededByOthers = /* @__PURE__ */ new Set();
+      for (const presentRef of this.presentRefs()) {
+        for (const def of matchDefsForRef(allDefs, presentRef)) {
+          if (removedNames.has(def.name)) continue;
+          for (const to of def.softDeps ?? []) neededByOthers.add(softDepName(to));
+          for (const req of parseRequires(def.manifest)) neededByOthers.add(softDepName(req.name));
+        }
+      }
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const ref of refs) {
+        for (const def of matchDefsForRef(allDefs, ref)) {
+          for (const to of def.softDeps ?? []) {
+            const targetName = softDepName(to);
+            if (!present.has(targetName)) continue;
+            if (removedNames.has(targetName)) continue;
+            if (neededByOthers.has(targetName)) continue;
+            if (seen.has(to)) continue;
+            seen.add(to);
+            const targetDef = byId.get(to);
+            out.push({
+              from: def.id,
+              target: to,
+              targetRef: targetDef ? depRefFromDef(targetDef) : void 0
+            });
+          }
+        }
+      }
+      return out;
+    }, []);
+  }
+  /**
+   * Open the local index, run `fn` against its cached asset defs, and close it.
+   * Best-effort: no index (user never ran `source sync`), a missing file, or any
+   * open/guard failure yields `fallback` — so a read surface can never throw or
+   * create an empty `index.db` as a side effect.
+   */
+  async withIndexDefs(fn, fallback) {
+    try {
+      const { LocalIndex, resolveIndexPath } = await import('./library/index.js');
+      const indexPath = this.indexPathOverride ?? resolveIndexPath();
+      if (!existsSync(indexPath)) return fallback;
+      const index = new LocalIndex({ indexPath });
+      try {
+        return fn(await index.listAssetDefs());
+      } finally {
+        index.close();
+      }
+    } catch {
+      return fallback;
+    }
+  }
+  /**
+   * Build soft-dep edges for `refs` from cached defs. With `onlyAbsent`, targets
+   * already present in the project are skipped (the `reportSoftDeps` nudge); else
+   * the full inferred set is returned (the `softDepsOf` display). Deduped by target.
+   */
+  collectSoftDeps(allDefs, refs, onlyAbsent) {
+    const present = onlyAbsent ? this.presentRefNames() : null;
+    const byId = new Map(allDefs.map((d) => [d.id, d]));
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      for (const def of matchDefsForRef(allDefs, ref)) {
+        for (const to of def.softDeps ?? []) {
+          if (present?.has(softDepName(to))) continue;
+          if (seen.has(to)) continue;
+          seen.add(to);
+          const targetDef = byId.get(to);
+          out.push({ from: def.id, to, toRef: targetDef ? depRefFromDef(targetDef) : void 0 });
+        }
+      }
+    }
+    return out;
+  }
+  /**
+   * Names of assets already in the project — declared deps + deployed on disk.
+   * Bare name only (see {@link softDepName}): a same-named asset of a different
+   * publisher/kind counts as present, so the report under-reports rather than
+   * nags about something already installed.
+   */
+  presentRefNames() {
+    const names = /* @__PURE__ */ new Set();
+    for (const ref of this.presentRefs()) {
+      try {
+        names.add(parseAssetRef(ref).name);
+      } catch {
+      }
+    }
+    return names;
+  }
+  /**
+   * Present asset refs — declared `skaile.yaml` deps (canonical refs as written)
+   * plus deployed assets as `kind:name`. Used by the soft-dep present-check and
+   * the orphan "needed by others" scan.
+   */
+  presentRefs() {
+    const refs = [];
+    try {
+      for (const ref of resolveSkWorkspaceConfig(this.projectDir).dependencies ?? [])
+        refs.push(ref);
+    } catch {
+    }
+    for (const e of this.listDeployed()) refs.push(`${e.kind}:${e.name}`);
+    return refs;
+  }
   /**
    * Remove a deployed asset and unregister it from `skaile.yaml`.
    *
@@ -780,7 +1010,7 @@ var AssetManager = class {
     }
     if (ok) {
       const depRef = `${parsed.kind}:${parsed.name}`;
-      this.removeDependencyFromConfig(depRef);
+      this.removeDependencyFromConfig(parsed);
       appendHistory(this.projectDir, {
         ref: depRef,
         action: "remove",
@@ -1080,8 +1310,10 @@ var AssetManager = class {
   why(ref) {
     const lock = this.tryReadLock();
     if (!lock) return [];
-    if (!lock.assets[ref]) return [];
-    return [ref, "direct (skaile.yaml)"];
+    const bare = (s) => s.includes("#") ? s.slice(0, s.indexOf("#")) : s;
+    const key = lock.assets[ref] ? ref : Object.keys(lock.assets).find((k) => bare(k) === bare(ref));
+    if (!key) return [];
+    return [key, "direct (skaile.yaml)"];
   }
   /**
    * List installed assets whose source repository is behind the remote.
@@ -1440,12 +1672,19 @@ var AssetManager = class {
    * Remove a dependency ref from the manifest `dependencies:`. Targets the same
    * file as {@link addDependencyToConfig} (`~/.skaile/skaile.yaml` in global mode).
    */
-  removeDependencyFromConfig(ref) {
+  removeDependencyFromConfig(target) {
     const configPath = join(this.stateRoot, "skaile.yaml");
     if (!existsSync(configPath)) return;
     const raw = parse(readFileSync(configPath, "utf8")) ?? {};
-    if (!raw.dependencies) return;
-    const idx = raw.dependencies.indexOf(ref);
+    if (!Array.isArray(raw.dependencies)) return;
+    const wantPub = target.publisher?.replace(/^@/, "");
+    const idx = raw.dependencies.findIndex((dep) => {
+      if (typeof dep !== "string") return false;
+      const p = parseRefLoose(dep);
+      if (!p || p.kind !== target.kind || p.name !== target.name) return false;
+      const havePub = p.publisher?.replace(/^@/, "");
+      return wantPub === void 0 || havePub === void 0 || havePub === wantPub;
+    });
     if (idx !== -1) {
       raw.dependencies.splice(idx, 1);
       writeFileSync(configPath, stringify(raw, { lineWidth: 120 }));
@@ -1468,6 +1707,6 @@ var AssetManager = class {
   }
 };
 
-export { AssetManager, MissingManifestError, NON_DEPLOYABLE_KINDS, parseCanonicalLockKey };
-//# sourceMappingURL=chunk-SFVEHSCI.js.map
-//# sourceMappingURL=chunk-SFVEHSCI.js.map
+export { AssetManager, MissingManifestError, NON_DEPLOYABLE_KINDS, parseCanonicalLockKey, softDepName };
+//# sourceMappingURL=chunk-L3SLC3S4.js.map
+//# sourceMappingURL=chunk-L3SLC3S4.js.map