@skaile/workspaces 1.6.0 → 1.7.0

package/dist/{chunk-2ZMO4CFG.js → chunk-VK24PIAB.js}

@@ -1,4 +1,5 @@
-import { factoryAssetRoots } from './chunk-ZBZQC5R7.js';
+import { resolveLibraryDir } from './chunk-MWE7DEGC.js';
+import { factoryAssetRoots } from './chunk-7J7LQP6T.js';
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
@@ -19,10 +20,10 @@ var MONOREPO_ROOT = findMonorepoRoot(__ownDir);
 var AI_RESOURCES = factoryAssetRoots()[0] ?? path.join(os.homedir(), ".skaile", "libraries");
 function aiResourceRoots() {
   const roots = [...factoryAssetRoots()];
-  roots.push(path.join(os.homedir(), ".skaile", "libraries"));
+  roots.push(resolveLibraryDir());
   return [...new Set(roots)].filter((r) => fs.existsSync(r));
 }
 
 export { AI_RESOURCES, MONOREPO_ROOT, aiResourceRoots };
-//# sourceMappingURL=chunk-2ZMO4CFG.js.map
-//# sourceMappingURL=chunk-2ZMO4CFG.js.map
+//# sourceMappingURL=chunk-VK24PIAB.js.map
+//# sourceMappingURL=chunk-VK24PIAB.js.map

package/dist/chunk-VK24PIAB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../cli/src/paths.ts"],"names":[],"mappings":";;;;;;;AAOA,IAAM,WAAW,IAAA,CAAK,OAAA,CAAQ,aAAA,CAAc,MAAA,CAAA,IAAA,CAAY,GAAG,CAAC,CAAA;AAW5D,SAAS,iBAAiB,IAAA,EAA6B;AACrD,EAAA,IAAI,GAAA,GAAM,IAAA;AACV,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,EAAA,EAAK;AAC1B,IAAA,IAAI,EAAA,CAAG,WAAW,IAAA,CAAK,IAAA,CAAK,KAAK,YAAY,CAAC,GAAG,OAAO,GAAA;AACxD,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,OAAA,CAAQ,GAAG,CAAA;AAC/B,IAAA,IAAI,WAAW,GAAA,EAAK;AACpB,IAAA,GAAA,GAAM,MAAA;AAAA,EACR;AACA,EAAA,OAAO,IAAA;AACT;AAYO,IAAM,aAAA,GAA+B,iBAAiB,QAAQ;AAc9D,IAAM,YAAA,GACX,iBAAA,EAAkB,CAAE,CAAC,CAAA,IAAK,IAAA,CAAK,IAAA,CAAK,EAAA,CAAG,OAAA,EAAQ,EAAG,SAAA,EAAW,WAAW;AAoBnE,SAAS,eAAA,GAA4B;AAC1C,EAAA,MAAM,KAAA,GAAkB,CAAC,GAAG,iBAAA,EAAmB,CAAA;AAG/C,EAAA,KAAA,CAAM,IAAA,CAAK,mBAAmB,CAAA;AAC9B,EAAA,OAAO,CAAC,GAAG,IAAI,GAAA,CAAI,KAAK,CAAC,CAAA,CAAE,MAAA,CAAO,CAAC,CAAA,KAAM,EAAA,CAAG,UAAA,CAAW,CAAC,CAAC,CAAA;AAC3D","file":"chunk-VK24PIAB.js","sourcesContent":["import fs from \"node:fs\";\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport { factoryAssetRoots } from \"@skaile/workspaces/core\";\nimport { resolveLibraryDir } from \"@skaile/workspaces/library\";\n\nconst __ownDir = path.dirname(fileURLToPath(import.meta.url));\n\n/**\n * Walk up from `from` looking for the monorepo marker (`biome.json`, the\n * repo-root shared tooling config). Returns the matching directory or `null`\n * when none is found within eight levels — the latter is the typical case when\n * `@skaile/workspaces` has been installed via `npm i` without a skaile-dev\n * workspace context. Used only to gate dev-only commands (e.g.\n * `serve --compile-test`); first-party content is located via\n * {@link aiResourceRoots}, not this.\n */\nfunction findMonorepoRoot(from: string): string | null {\n  let dir = from;\n  for (let i = 0; i < 8; i++) {\n    if (fs.existsSync(path.join(dir, \"biome.json\"))) return dir;\n    const parent = path.dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n  return null;\n}\n\n/**\n * Absolute path to the monorepo root, or `null` when the CLI is running\n * outside the skaile-dev workspace (typical for `npm i -g` installs).\n *\n * Consumers that only make sense inside the workspace (e.g.\n * `skaile serve --compile-test`) MUST check for `null` and report a\n * \"monorepo-only feature\" error before proceeding.\n *\n * @docLink cli/dev-guide#paths\n */\nexport const MONOREPO_ROOT: string | null = findMonorepoRoot(__ownDir);\n\n/**\n * Default content root used by path display and the `validate` command.\n *\n * The primary first-party `factory-assets/` root resolved through the shared\n * `factoryAssetRoots()` helper — the `SKAILE_FACTORY_ASSETS_DIR` override when\n * set, else the in-repo source during dev / bundled `dist/factory-assets/` after\n * `npm i`. Falls back to `~/.skaile/libraries/` — the user-library directory\n * managed by `skaile library add` — when the package cannot be located.\n * Consumers `fs.existsSync` first and degrade to \"no skills / flows discovered\".\n *\n * @docLink cli/dev-guide#paths\n */\nexport const AI_RESOURCES: string =\n  factoryAssetRoots()[0] ?? path.join(os.homedir(), \".skaile\", \"libraries\");\n\n/**\n * All content roots that skill / flow discovery should walk, in priority order,\n * filtered to those that exist on disk and de-duplicated.\n *\n * - The first-party `factory-assets/` roots from the shared `factoryAssetRoots()`\n *   helper — the `SKAILE_FACTORY_ASSETS_DIR` override layer (when set) ahead of\n *   the bundled tree (in-repo source in dev, `dist/factory-assets/` after\n *   install). No monorepo special-case.\n * - The user-library dir `~/.skaile/libraries/`.\n *\n * Order is significant: `findSkills` / flow discovery dedupe first-root-wins, so\n * the env override shadows the bundled tree on a name clash.\n *\n * This is the discovery surface used by `findSkills`, flow discovery, and the\n * completion resolvers.\n *\n * @docLink cli/dev-guide#paths\n */\nexport function aiResourceRoots(): string[] {\n  const roots: string[] = [...factoryAssetRoots()];\n  // resolveLibraryDir honors SKAILE_LIBRARIES_DIR (the authoring side does too),\n  // so a custom-dir library is visible to discovery instead of being missed.\n  roots.push(resolveLibraryDir());\n  return [...new Set(roots)].filter((r) => fs.existsSync(r));\n}\n"]}

package/dist/{chunk-3CHARYD4.js → chunk-Y3UCU4ZK.js}

@@ -1,16 +1,17 @@
-import { getStoreManifestsDir } from './chunk-FDE7XRQA.js';
-import { deployAll, removeAsset, createScaffold } from './chunk-6NR2BEIY.js';
-import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-HY33RMEA.js';
-import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-ZBZQC5R7.js';
-import { globalSkaileDir, resolveGlobalBackends, globalCacheRoot, migrateLegacyDir, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks, storeManifestSlug } from './chunk-UQKYT4V6.js';
-import { parseRequires } from './chunk-BQCGFPHW.js';
-import { parseAssetRef, assetRefToStr } from './chunk-GEEW6SY2.js';
+import { resolveLibraryDir, getStoreManifestsDir } from './chunk-MWE7DEGC.js';
+import { deployAll, removeAsset, createScaffold } from './chunk-STQOPWPS.js';
+import { writeLock, buildLockFile, readLock, verifyLock, extractForPatch, generatePatch, savePatch, applyPatch } from './chunk-5NZ56R63.js';
+import { resolveRuntimeAssets, factoryAssetRoots } from './chunk-7J7LQP6T.js';
+import { globalSkaileDir, resolveGlobalBackends, globalCacheRoot, migrateLegacyDir, resolveGlobalSkWorkspaceConfig, resolveSkWorkspaceConfig, getGlobalCacheDir, sourceCacheKey, getRepoCommit, coerceVersion, matchPin, resolveAll, buildProvenanceIndex, ensureRepo, sourceShortName, scanRepo, SKAILE_YAML_DEFAULT, checkRepoStatus, resolveAsset, readLinks, storeManifestSlug } from './chunk-ISA7R7PK.js';
+import { scanDirectory, parseRequires } from './chunk-BQCGFPHW.js';
+import { parseAssetRef, slugifyAssetName, assetRefToStr } from './chunk-GEEW6SY2.js';
 import { deployedBase, isDeployed, deployedDir } from './chunk-F3HNW354.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, mkdirSync, writeFileSync, readFileSync } from 'fs';
 import { resolve, join, sep, dirname } from 'path';
+import { gt } from 'semver';
 import { stringify, parse } from 'yaml';
 
 function normalizeRepoUrl(url) {
@@ -372,6 +373,64 @@ var AssetManager = class {
     if (c.homepage != null) entry.homepage = c.homepage;
     return entry;
   }
+  /**
+   * Resolve refs the source/store pass could not against the user's registered
+   * **libraries** (local authoring places). Each library dir is scanned on disk
+   * under its declared publisher (its root `skaile.manifest.yaml`, falling back
+   * to the kebab-cased library name); a matching asset becomes a deployable
+   * {@link CatalogEntry} whose `source` points at the on-disk manifest. This is
+   * the consume side of `library create` — a freshly authored asset is
+   * deployable with `skaile add <kind>:@<publisher>/<name>` without publishing.
+   *
+   * Pure local read (no index, no network) and mirrors how `findSkills`
+   * discovers library content. Library assets are deliberately NOT written to
+   * the lock (a local authoring place is not a reproducible source); they are
+   * re-discovered on every `add`/`install`, so reconcile never treats them as
+   * stale.
+   *
+   * @returns the matched deploy entries plus the set of `missing` refs covered.
+   */
+  resolveLibraryEntries(missing) {
+    const resolved = /* @__PURE__ */ new Set();
+    if (missing.length === 0) return { entries: [], resolved };
+    let librariesRoot;
+    try {
+      librariesRoot = resolveLibraryDir();
+    } catch {
+      return { entries: [], resolved };
+    }
+    if (!existsSync(librariesRoot)) return { entries: [], resolved };
+    const byKey = /* @__PURE__ */ new Map();
+    for (const dirent of readdirSync(librariesRoot, { withFileTypes: true })) {
+      if (!dirent.isDirectory()) continue;
+      const libPath = join(librariesRoot, dirent.name);
+      const publisher = readDeclaredPublisher(libPath) ?? slugifyAssetName(dirent.name);
+      for (const entry of scanDirectory(libPath, publisher)) {
+        const key = `${entry.kind}:@${entry.publisher}/${entry.name}`;
+        const prev = byKey.get(key);
+        if (!prev || gt(coerceVersion(entry.version ?? ""), coerceVersion(prev.version ?? ""))) {
+          byKey.set(key, entry);
+        }
+      }
+    }
+    if (byKey.size === 0) return { entries: [], resolved };
+    const entries = [];
+    for (const ref of missing) {
+      let parsed;
+      try {
+        parsed = parseAssetRef(ref);
+      } catch {
+        continue;
+      }
+      if (!parsed.publisher) continue;
+      const entry = byKey.get(`${parsed.kind}:@${parsed.publisher}/${parsed.name}`);
+      if (!entry) continue;
+      if (parsed.pin && !matchPin(parsed.pin, entry.version ?? "")) continue;
+      entries.push(entry);
+      resolved.add(ref);
+    }
+    return { entries, resolved };
+  }
   // ── Store fetch-then-deploy ────────────────────────────────────────────
   /** A candidate's stable identity key (`<publisher>/<kind>:<name>@<version>`). */
   candidateKey(c) {
@@ -580,8 +639,9 @@ var AssetManager = class {
       overrides,
       stores
     });
+    const lib = this.resolveLibraryEntries(missing);
     const removed = this.reconcileRemovedAssets(resolved);
-    const entries = await this.buildCatalogEntries(resolved, repositories);
+    const entries = [...await this.buildCatalogEntries(resolved, repositories), ...lib.entries];
     const deployed = [
       ...new Set(
         this.targetBackends().flatMap(
@@ -589,10 +649,14 @@ var AssetManager = class {
         )
       )
     ];
-    writeLock(this.lockPath, buildLockFile(resolved, overridesApplied));
+    const lockWritten = resolved.length > 0 || existsSync(this.lockPath);
+    if (lockWritten) {
+      writeLock(this.lockPath, buildLockFile(resolved, overridesApplied));
+    }
     this.recordInstallHistory(deployed, removed);
     const { npmInstalled, npmFailed } = await this.installRuntimeAssetDeps();
-    return { deployed, removed, missing, lockWritten: true, npmInstalled, npmFailed };
+    const stillMissing = missing.filter((m) => !lib.resolved.has(m));
+    return { deployed, removed, missing: stillMissing, lockWritten, npmInstalled, npmFailed };
   }
   /**
    * Ensure all source clones are present/up to date. Returns an early
@@ -734,12 +798,16 @@ var AssetManager = class {
       throw new Error("No lock file found. Run `skaile install` first.");
     }
     const declBySlug = new Map(Object.entries(repositories));
+    const factoryUrl = normalizeRepoUrl(FACTORY_SOURCE_URL);
+    const factoryDir = Object.values(repositories).find((d) => d.factory)?.path ?? null;
     for (const src of lock.sources) {
+      if (factoryDir && normalizeRepoUrl(src.url) === factoryUrl) continue;
       const slug = sourceCacheKey(src.url);
       const decl = declBySlug.get(slug) ?? { url: src.url };
       ensureRepo(decl, slug, this.reposDir, { projectDir: this.projectDir, pin: src.commit });
     }
     const resolveCloneDir = (sourceUrl) => {
+      if (factoryDir && normalizeRepoUrl(sourceUrl) === factoryUrl) return factoryDir;
       const slug = sourceCacheKey(sourceUrl);
       const decl = declBySlug.get(slug) ?? { url: sourceUrl };
       return this.resolveRepoDir(decl, slug);
@@ -813,12 +881,13 @@ var AssetManager = class {
       overrides,
       stores
     });
-    if (resolved.length === 0) {
+    const lib = this.resolveLibraryEntries(missing);
+    if (resolved.length === 0 && lib.entries.length === 0) {
       throw new Error(
         `Asset not found: ${ref}${missing.length ? ` (missing: ${missing.join(", ")})` : ""}`
       );
     }
-    const entries = await this.buildCatalogEntries(resolved, repositories);
+    const entries = [...await this.buildCatalogEntries(resolved, repositories), ...lib.entries];
     const deployed = [
       ...new Set(
         this.targetBackends().flatMap(
@@ -827,20 +896,22 @@ var AssetManager = class {
       )
     ];
     this.addDependencyToConfig(ref);
-    const fresh = buildLockFile(resolved, overridesApplied);
-    const prev = this.tryReadLock();
-    if (prev) {
-      const sources = new Map(prev.sources.map((s) => [s.url, s]));
-      for (const s of fresh.sources) sources.set(s.url, s);
-      writeLock(this.lockPath, {
-        ...fresh,
-        assets: { ...prev.assets, ...fresh.assets },
-        sources: [...sources.values()].sort((a, b) => a.url.localeCompare(b.url)),
-        // buildLockFile never emits a plugins slice — preserve the reconciler's.
-        plugins: prev.plugins
-      });
-    } else {
-      writeLock(this.lockPath, fresh);
+    if (resolved.length > 0) {
+      const fresh = buildLockFile(resolved, overridesApplied);
+      const prev = this.tryReadLock();
+      if (prev) {
+        const sources = new Map(prev.sources.map((s) => [s.url, s]));
+        for (const s of fresh.sources) sources.set(s.url, s);
+        writeLock(this.lockPath, {
+          ...fresh,
+          assets: { ...prev.assets, ...fresh.assets },
+          sources: [...sources.values()].sort((a, b) => a.url.localeCompare(b.url)),
+          // buildLockFile never emits a plugins slice — preserve the reconciler's.
+          plugins: prev.plugins
+        });
+      } else {
+        writeLock(this.lockPath, fresh);
+      }
     }
     for (const d of deployed) {
       appendHistory(this.projectDir, {
@@ -1780,5 +1851,5 @@ var AssetManager = class {
 };
 
 export { AssetManager, FACTORY_SOURCE_URL, MissingManifestError, NON_DEPLOYABLE_KINDS, normalizeRepoUrl, parseCanonicalLockKey, parseRefTolerant, softDepName };
-//# sourceMappingURL=chunk-3CHARYD4.js.map
-//# sourceMappingURL=chunk-3CHARYD4.js.map
+//# sourceMappingURL=chunk-Y3UCU4ZK.js.map
+//# sourceMappingURL=chunk-Y3UCU4ZK.js.map