@jskit-ai/jskit-cli 0.2.26 → 0.2.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.26",
+  "version": "0.2.27",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -20,7 +20,7 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.26"
+    "@jskit-ai/jskit-catalog": "0.1.27"
   },
   "engines": {
     "node": "20.x"

package/src/server/cliRuntime.js

@@ -60,6 +60,8 @@ const WORKSPACE_VISIBILITY_LEVELS = Object.freeze(["workspace", "workspace_user"
 const WORKSPACE_VISIBILITY_SET = new Set(WORKSPACE_VISIBILITY_LEVELS);
 const MATERIALIZED_PACKAGE_ROOTS = new Map();
 const MATERIALIZED_PACKAGE_TEMP_DIRECTORIES = new Set();
+const LOCAL_WORKSPACE_PACKAGE_ROOTS = new Map();
+let LOCAL_WORKSPACE_PACKAGE_ID_INDEX = null;
 const BUILTIN_CAPABILITY_PROVIDERS = Object.freeze({
   "runtime.actions": Object.freeze(["@jskit-ai/kernel"])
 });
@@ -3483,11 +3485,110 @@ async function materializePackageRootFromRegistry({ packageEntry, appRoot }) {
   return packageRoot;
 }
 
+async function resolvePackageRootFromNodeModules({ appRoot, packageId }) {
+  const normalizedAppRoot = path.resolve(String(appRoot || "").trim());
+  const normalizedPackageId = String(packageId || "").trim();
+  if (!normalizedAppRoot || !normalizedPackageId) {
+    return "";
+  }
+
+  const candidateRoot = path.resolve(normalizedAppRoot, "node_modules", ...normalizedPackageId.split("/"));
+  const candidateDescriptorPath = path.join(candidateRoot, "package.descriptor.mjs");
+  if (!(await fileExists(candidateDescriptorPath))) {
+    return "";
+  }
+
+  return candidateRoot;
+}
+
+async function loadLocalWorkspacePackageIdIndex() {
+  if (LOCAL_WORKSPACE_PACKAGE_ID_INDEX instanceof Map) {
+    return LOCAL_WORKSPACE_PACKAGE_ID_INDEX;
+  }
+
+  const repoRoot = path.resolve(CLI_PACKAGE_ROOT, "..", "..");
+  const parentDirectories = [
+    path.join(repoRoot, "packages"),
+    path.join(repoRoot, "tooling")
+  ];
+  const packageIdIndex = new Map();
+
+  for (const parentDirectory of parentDirectories) {
+    if (!(await fileExists(parentDirectory))) {
+      continue;
+    }
+
+    const entries = await readdir(parentDirectory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) {
+        continue;
+      }
+
+      const candidateRoot = path.join(parentDirectory, entry.name);
+      const packageJsonPath = path.join(candidateRoot, "package.json");
+      const descriptorPath = path.join(candidateRoot, "package.descriptor.mjs");
+      if (!(await fileExists(packageJsonPath)) || !(await fileExists(descriptorPath))) {
+        continue;
+      }
+
+      let packageJson = {};
+      try {
+        packageJson = await readJsonFile(packageJsonPath);
+      } catch {
+        continue;
+      }
+
+      const packageId = String(packageJson?.name || "").trim();
+      if (!packageId.startsWith("@jskit-ai/")) {
+        continue;
+      }
+      if (packageIdIndex.has(packageId)) {
+        continue;
+      }
+      packageIdIndex.set(packageId, candidateRoot);
+    }
+  }
+
+  LOCAL_WORKSPACE_PACKAGE_ID_INDEX = packageIdIndex;
+  return packageIdIndex;
+}
+
+async function resolvePackageRootFromLocalWorkspace({ packageId }) {
+  const normalizedPackageId = String(packageId || "").trim();
+  if (!normalizedPackageId.startsWith("@jskit-ai/")) {
+    return "";
+  }
+  if (LOCAL_WORKSPACE_PACKAGE_ROOTS.has(normalizedPackageId)) {
+    return LOCAL_WORKSPACE_PACKAGE_ROOTS.get(normalizedPackageId);
+  }
+
+  const packageIdIndex = await loadLocalWorkspacePackageIdIndex();
+  const packageRoot = String(packageIdIndex.get(normalizedPackageId) || "").trim();
+  LOCAL_WORKSPACE_PACKAGE_ROOTS.set(normalizedPackageId, packageRoot);
+  return packageRoot;
+}
+
 async function resolvePackageTemplateRoot({ packageEntry, appRoot }) {
   const packageRoot = String(packageEntry?.rootDir || "").trim();
   if (packageRoot) {
     return packageRoot;
   }
+
+  const installedPackageRoot = await resolvePackageRootFromNodeModules({
+    appRoot,
+    packageId: packageEntry?.packageId
+  });
+  if (installedPackageRoot) {
+    return installedPackageRoot;
+  }
+
+  const localWorkspacePackageRoot = await resolvePackageRootFromLocalWorkspace({
+    packageId: packageEntry?.packageId
+  });
+  if (localWorkspacePackageRoot) {
+    return localWorkspacePackageRoot;
+  }
+
   return await materializePackageRootFromRegistry({ packageEntry, appRoot });
 }
 
@@ -3497,6 +3598,8 @@ async function cleanupMaterializedPackageRoots() {
   }
   MATERIALIZED_PACKAGE_TEMP_DIRECTORIES.clear();
   MATERIALIZED_PACKAGE_ROOTS.clear();
+  LOCAL_WORKSPACE_PACKAGE_ROOTS.clear();
+  LOCAL_WORKSPACE_PACKAGE_ID_INDEX = null;
 }
 
 function interpolateFileMutationRecord(mutation, options, packageId) {