@jskit-ai/jskit-cli 0.2.65 → 0.2.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.65",
+  "version": "0.2.67",
   "description": "Bundle and package orchestration CLI for JSKIT apps.",
   "type": "module",
   "files": [
@@ -20,9 +20,9 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@jskit-ai/jskit-catalog": "0.1.64",
-    "@jskit-ai/kernel": "0.1.56",
-    "@jskit-ai/shell-web": "0.1.55"
+    "@jskit-ai/jskit-catalog": "0.1.66",
+    "@jskit-ai/kernel": "0.1.58",
+    "@jskit-ai/shell-web": "0.1.57"
   },
   "engines": {
     "node": "20.x"

package/src/server/cliRuntime/mutations/fileMutations.js

@@ -196,7 +196,10 @@ async function applyFileMutations(
   managedMigrations,
   touchedFiles,
   warnings = [],
-  existingManagedFiles = []
+  existingManagedFiles = [],
+  {
+    reapplyManagedAppFiles = false
+  } = {}
 ) {
   const existingManagedFilesByPath = new Map();
   for (const managedFileValue of ensureArray(existingManagedFiles)) {
@@ -242,8 +245,16 @@ async function applyFileMutations(
       const relativeTargetPath = normalizeRelativePath(appRoot, targetPath);
       const previous = await readFileBufferIfExists(targetPath);
       const existingManaged = existingManagedFilesByPath.get(relativeTargetPath);
+      const existingManagedHash = String(existingManaged?.hash || "").trim();
+      const currentContentMatchesManagedVersion =
+        previous.exists &&
+        existingManagedHash &&
+        hashBuffer(previous.buffer) === existingManagedHash;
+      const canSafelyReapplyManagedAppFile =
+        reapplyManagedAppFiles === true &&
+        (!previous.exists || currentContentMatchesManagedVersion);
 
-      if (mutation.ownership === "app" && existingManaged) {
+      if (mutation.ownership === "app" && existingManaged && !canSafelyReapplyManagedAppFile) {
         managedFiles.push({
           ...existingManaged,
           path: relativeTargetPath,

package/src/server/cliRuntime/packageInstallFlow.js

@@ -503,7 +503,10 @@ async function applyPackageInstall({
     managedRecord.managed.migrations,
     touchedFiles,
     mutationWarnings,
-    ensureArray(existingManaged.files)
+    ensureArray(existingManaged.files),
+    {
+      reapplyManagedAppFiles: Object.keys(existingInstall).length > 0
+    }
   );
 
   await applyTextMutations(

package/src/server/commandHandlers/appCommands/linkLocalPackages.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { mkdir, rm, symlink } from "node:fs/promises";
+import { lstat, mkdir, readFile, readlink, rm, symlink } from "node:fs/promises";
 import {
   discoverLocalPackageMap,
   fileExists,
@@ -8,6 +8,117 @@ import {
   resolveSymlinkType
 } from "./shared.js";
 
+const COMPANION_PACKAGES = Object.freeze([
+  Object.freeze({
+    packageName: "json-rest-schema",
+    repoDirName: "json-rest-schema"
+  }),
+  Object.freeze({
+    packageName: "json-rest-stores",
+    repoDirName: "json-rest-stores"
+  })
+]);
+
+function collectDeclaredPackageNames(packageJson = {}) {
+  const names = new Set();
+  const sections = [
+    packageJson?.dependencies,
+    packageJson?.devDependencies,
+    packageJson?.optionalDependencies,
+    packageJson?.peerDependencies
+  ];
+
+  for (const section of sections) {
+    if (!section || typeof section !== "object" || Array.isArray(section)) {
+      continue;
+    }
+
+    for (const packageName of Object.keys(section)) {
+      const normalizedPackageName = String(packageName || "").trim();
+      if (normalizedPackageName) {
+        names.add(normalizedPackageName);
+      }
+    }
+  }
+
+  return names;
+}
+
+async function verifySymlinkTarget(targetPath = "", sourceDir = "", {
+  packageName = ""
+} = {}) {
+  const stats = await lstat(targetPath);
+  if (!stats.isSymbolicLink()) {
+    throw new Error(`[link-local] expected ${packageName || targetPath} to be a symlink after linking.`);
+  }
+
+  const linkedTarget = await readlink(targetPath);
+  if (linkedTarget !== sourceDir) {
+    throw new Error(
+      `[link-local] expected ${packageName || targetPath} to link to ${sourceDir}, got ${linkedTarget}.`
+    );
+  }
+}
+
+async function maybeLinkCompanionPackages({
+  appRoot = "",
+  repoRoot = "",
+  stdout,
+  createCliError
+}) {
+  const companionRoot = path.dirname(repoRoot);
+  const appPackageJsonPath = path.join(appRoot, "package.json");
+  let appPackageJson = {};
+  try {
+    appPackageJson = JSON.parse(await readFile(appPackageJsonPath, "utf8"));
+  } catch {
+    appPackageJson = {};
+  }
+  const declaredPackageNames = collectDeclaredPackageNames(appPackageJson);
+  let linkedCount = 0;
+
+  for (const companion of COMPANION_PACKAGES) {
+    if (!declaredPackageNames.has(companion.packageName)) {
+      continue;
+    }
+
+    const sourceDir = path.join(companionRoot, companion.repoDirName);
+    const packageJsonPath = path.join(sourceDir, "package.json");
+    if (!(await fileExists(packageJsonPath))) {
+      throw createCliError(
+        `[link-local] companion package ${companion.packageName} is declared by the app but local source was not found at ${sourceDir}.`,
+        { exitCode: 1 }
+      );
+    }
+
+    let packageJson = {};
+    try {
+      packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    } catch {
+      continue;
+    }
+
+    if (String(packageJson?.name || "").trim() !== companion.packageName) {
+      throw createCliError(
+        `[link-local] companion source at ${sourceDir} does not match expected package ${companion.packageName}.`,
+        { exitCode: 1 }
+      );
+    }
+
+    const targetPath = path.join(appRoot, "node_modules", companion.packageName);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await rm(targetPath, { recursive: true, force: true });
+    await symlink(sourceDir, targetPath, resolveSymlinkType());
+    await verifySymlinkTarget(targetPath, sourceDir, {
+      packageName: companion.packageName
+    });
+    stdout.write(`[link-local] linked ${companion.packageName} -> ${sourceDir}\n`);
+    linkedCount += 1;
+  }
+
+  return linkedCount;
+}
+
 async function runAppLinkLocalPackagesCommand(ctx = {}, { appRoot = "", options = {}, stdout }) {
   const { createCliError } = ctx;
   const explicitRepoRoot = String(options?.inlineOptions?.["repo-root"] || "").trim();
@@ -51,6 +162,13 @@ async function runAppLinkLocalPackagesCommand(ctx = {}, { appRoot = "", options
     linkedCount += 1;
   }
 
+  linkedCount += await maybeLinkCompanionPackages({
+    appRoot,
+    repoRoot,
+    stdout,
+    createCliError
+  });
+
   if (await fileExists(viteCacheDirectory)) {
     await rm(viteCacheDirectory, { recursive: true, force: true });
     stdout.write(`[link-local] cleared Vite cache at ${viteCacheDirectory}\n`);

package/src/server/commandHandlers/health.js

@@ -75,6 +75,11 @@ function createHealthCommands(ctx = {}) {
     "createCrudListFilters",
     "useCrudListFilters"
   ]);
+  const CRUD_TRANSPORT_RUNTIME_CALLEES = Object.freeze([
+    "useCrudList",
+    "useCrudView",
+    "useCrudAddEdit"
+  ]);
 
   function collectDescriptorContainerTokens({ packageId, side, values, issues }) {
     const declaredTokens = new Set();
@@ -485,6 +490,146 @@ function createHealthCommands(ctx = {}) {
     return bindings;
   }
 
+  function hasTopLevelObjectProperty(sourceText = "", propertyName = "") {
+    const normalizedPropertyName = String(propertyName || "").trim();
+    const normalizedSourceText = String(sourceText || "").trim();
+    if (!normalizedPropertyName || !normalizedSourceText.startsWith("{")) {
+      return false;
+    }
+
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let inLineComment = false;
+    let inBlockComment = false;
+
+    for (let index = 0; index < normalizedSourceText.length; index += 1) {
+      const character = normalizedSourceText[index];
+      const nextCharacter = normalizedSourceText[index + 1] || "";
+
+      if (inLineComment) {
+        if (character === "\n") {
+          inLineComment = false;
+        }
+        continue;
+      }
+
+      if (inBlockComment) {
+        if (character === "*" && nextCharacter === "/") {
+          inBlockComment = false;
+          index += 1;
+        }
+        continue;
+      }
+
+      if (character === "/" && nextCharacter === "/") {
+        inLineComment = true;
+        index += 1;
+        continue;
+      }
+
+      if (character === "/" && nextCharacter === "*") {
+        inBlockComment = true;
+        index += 1;
+        continue;
+      }
+
+      if (character === "'" || character === "\"") {
+        const quote = character;
+        const stringStart = index + 1;
+        let stringEnd = stringStart;
+        for (; stringEnd < normalizedSourceText.length; stringEnd += 1) {
+          if (
+            normalizedSourceText[stringEnd] === quote &&
+            !isEscapedCharacter(normalizedSourceText, stringEnd)
+          ) {
+            break;
+          }
+        }
+
+        const stringValue = normalizedSourceText.slice(stringStart, stringEnd);
+        index = stringEnd;
+        if (braceDepth === 1 && parenDepth === 0 && bracketDepth === 0 && stringValue === normalizedPropertyName) {
+          let cursor = index + 1;
+          while (/\s/u.test(normalizedSourceText[cursor] || "")) {
+            cursor += 1;
+          }
+          if (normalizedSourceText[cursor] === ":") {
+            return true;
+          }
+        }
+        continue;
+      }
+
+      if (character === "`") {
+        for (index += 1; index < normalizedSourceText.length; index += 1) {
+          if (
+            normalizedSourceText[index] === "`" &&
+            !isEscapedCharacter(normalizedSourceText, index)
+          ) {
+            break;
+          }
+        }
+        continue;
+      }
+
+      if (character === "(") {
+        parenDepth += 1;
+        continue;
+      }
+      if (character === ")") {
+        parenDepth -= 1;
+        continue;
+      }
+      if (character === "{") {
+        braceDepth += 1;
+        continue;
+      }
+      if (character === "}") {
+        braceDepth -= 1;
+        continue;
+      }
+      if (character === "[") {
+        bracketDepth += 1;
+        continue;
+      }
+      if (character === "]") {
+        bracketDepth -= 1;
+        continue;
+      }
+
+      if (
+        braceDepth === 1 &&
+        parenDepth === 0 &&
+        bracketDepth === 0 &&
+        /[A-Za-z_$]/u.test(character)
+      ) {
+        const identifierStart = index;
+        for (index += 1; index < normalizedSourceText.length; index += 1) {
+          if (!/[\w$]/u.test(normalizedSourceText[index] || "")) {
+            break;
+          }
+        }
+
+        const identifier = normalizedSourceText.slice(identifierStart, index);
+        index -= 1;
+        if (identifier !== normalizedPropertyName) {
+          continue;
+        }
+
+        let cursor = index + 1;
+        while (/\s/u.test(normalizedSourceText[cursor] || "")) {
+          cursor += 1;
+        }
+        if (normalizedSourceText[cursor] === ":") {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   function isSharedListFiltersImportSource(sourcePath = "") {
     return /(^|\/)shared\/[^/'"]*ListFilters(?:\.[A-Za-z0-9]+)?$/u.test(String(sourcePath || "").trim());
   }
@@ -570,6 +715,26 @@ function createHealthCommands(ctx = {}) {
     }
   }
 
+  function collectCrudTransportOwnershipIssues({
+    sourceText = "",
+    relativePath = "",
+    issues = []
+  }) {
+    for (const calleeName of CRUD_TRANSPORT_RUNTIME_CALLEES) {
+      for (const callSite of findCallSites(sourceText, calleeName)) {
+        const firstArgument = extractFirstArgumentText(callSite.argsText).trim();
+        if (!hasTopLevelObjectProperty(firstArgument, "transport")) {
+          continue;
+        }
+
+        const lineNumber = resolveLineNumberFromIndex(sourceText, callSite.index);
+        issues.push(
+          `${relativePath}:${lineNumber}: [crud:transport-derived] do not pass explicit transport to ${calleeName}(...). Let the shared CRUD resource derive JSON:API transport automatically, or drop to useList/useView/useAddEdit/usersWebHttpClient.request(...) for custom transport behavior.`
+        );
+      }
+    }
+  }
+
   async function collectMdiSvgDoctorIssues({ appRoot, issues }) {
     if (!(await appUsesVuetifyMdiSvg(appRoot))) {
       return;
@@ -609,7 +774,10 @@ function createHealthCommands(ctx = {}) {
       if (
         !sourceText.includes("useCrudListFilters") &&
         !sourceText.includes("createCrudListFilters") &&
-        !sourceText.includes("createQueryValidator")
+        !sourceText.includes("createQueryValidator") &&
+        !sourceText.includes("useCrudList") &&
+        !sourceText.includes("useCrudView") &&
+        !sourceText.includes("useCrudAddEdit")
       ) {
         continue;
       }
@@ -625,6 +793,11 @@ function createHealthCommands(ctx = {}) {
         relativePath,
         issues
       });
+      collectCrudTransportOwnershipIssues({
+        sourceText,
+        relativePath,
+        issues
+      });
     }
   }