@jskit-ai/jskit-cli 0.2.25 → 0.2.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/jskit-cli",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "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.25"
+    "@jskit-ai/jskit-catalog": "0.1.26"
   },
   "engines": {
     "node": "20.x"

package/src/server/argParser.js

@@ -1,6 +1,7 @@
 const KNOWN_COMMANDS = new Set([
   "help",
   "create",
+  "generate",
   "list",
   "show",
   "view",
@@ -15,7 +16,8 @@ const KNOWN_COMMANDS = new Set([
 
 const COMMAND_ALIASES = Object.freeze({
   view: "show",
-  ls: "list"
+  ls: "list",
+  gen: "generate"
 });
 
 function resolveCommandAlias(rawCommand) {
@@ -44,6 +46,8 @@ function parseArgs(argv, { createCliError } = {}) {
         expanded: false,
         details: false,
         debugExports: false,
+        checkDiLabels: false,
+        verbose: false,
         json: false,
         all: false,
         help: true,
@@ -67,6 +71,8 @@ function parseArgs(argv, { createCliError } = {}) {
     expanded: false,
     details: false,
     debugExports: false,
+    checkDiLabels: false,
+    verbose: false,
     json: false,
     all: false,
     help: false,
@@ -101,6 +107,14 @@ function parseArgs(argv, { createCliError } = {}) {
       options.debugExports = true;
       continue;
     }
+    if (token === "--check-di-labels") {
+      options.checkDiLabels = true;
+      continue;
+    }
+    if (token === "--verbose") {
+      options.verbose = true;
+      continue;
+    }
     if (token === "--json") {
       options.json = true;
       continue;
@@ -159,10 +173,11 @@ function printUsage(stream = process.stderr) {
   stream.write("Usage: jskit <command> [options]\n\n");
   stream.write("Commands:\n");
   stream.write("  create package <name>        Scaffold app-local package under packages/ and install it\n");
-  stream.write("  list [bundles [all]|packages] List available bundles/packages and installed status\n");
+  stream.write("  list [bundles [all]|packages|generators] List available bundles/runtime packages/generators and installed status\n");
   stream.write("  lint-descriptors             Validate bundle/package descriptor files\n");
   stream.write("  add bundle <bundleId>        Add one bundle (bundle is a package shortcut)\n");
-  stream.write("  add package <packageId>      Add one package to current app (catalog/app-local/installed external)\n");
+  stream.write("  add package <packageId>      Add one runtime package to current app (catalog/app-local/installed external)\n");
+  stream.write("  generate <packageId>         Run one generator package\n");
   stream.write("  position element <packageId> Re-apply positioning mutations for one installed package\n");
   stream.write("  show <id>                    Show details for bundle id or package id\n");
   stream.write("  view <id>                    Alias of show <id>\n");
@@ -173,7 +188,7 @@ function printUsage(stream = process.stderr) {
   stream.write("\n");
   stream.write("Options:\n");
   stream.write("  --dry-run                    Print planned changes only\n");
-  stream.write("  --no-install                 Skip npm install during create/add/update/remove\n");
+  stream.write("  --no-install                 Skip npm install during create/add/generate/update/remove\n");
   stream.write("  --scope <scope>              (create package) override generated package scope\n");
   stream.write("  --package-id <id>            (create package) explicit @scope/name package id\n");
   stream.write("  --description <text>         (create package) descriptor description text\n");
@@ -181,6 +196,8 @@ function printUsage(stream = process.stderr) {
   stream.write("  --expanded                   Show expanded/transitive package ids\n");
   stream.write("  --details                    Show extra capability detail in show output\n");
   stream.write("  --debug-exports              Show export provenance/re-export source details in show output\n");
+  stream.write("  --check-di-labels            (lint-descriptors) verify DI labels used by providers match descriptor container tokens\n");
+  stream.write("  --verbose                    Show verbose informational diagnostics\n");
   stream.write("  --<option> <value>           Package option (for packages requiring input)\n");
   stream.write("  --json                       Print structured output\n");
   stream.write("  -h, --help                   Show help\n");

package/src/server/cliRuntime.js

@@ -28,9 +28,7 @@ import {
 import {
   BUNDLES_ROOT,
   CATALOG_PACKAGES_PATH,
-  CLI_PACKAGE_ROOT,
-  MODULES_ROOT,
-  WORKSPACE_ROOT
+  CLI_PACKAGE_ROOT
 } from "./pathResolution.js";
 import {
   appendTextSnippet,
@@ -55,9 +53,9 @@ const VITE_DEV_PROXY_CONFIG_RELATIVE_PATH = ".jskit/vite.dev.proxy.json";
 const VITE_DEV_PROXY_CONFIG_VERSION = 1;
 const PUBLIC_APP_CONFIG_RELATIVE_PATH = "config/public.js";
 const SERVER_APP_CONFIG_RELATIVE_PATH = "config/server.js";
-const PACKAGE_INSTALL_MODE_INSTALLABLE = "installable";
-const PACKAGE_INSTALL_MODE_CLONE_ONLY = "clone-only";
-const PACKAGE_INSTALL_MODES = Object.freeze([PACKAGE_INSTALL_MODE_INSTALLABLE, PACKAGE_INSTALL_MODE_CLONE_ONLY]);
+const PACKAGE_KIND_RUNTIME = "runtime";
+const PACKAGE_KIND_GENERATOR = "generator";
+const PACKAGE_KINDS = Object.freeze([PACKAGE_KIND_RUNTIME, PACKAGE_KIND_GENERATOR]);
 const WORKSPACE_VISIBILITY_LEVELS = Object.freeze(["workspace", "workspace_user"]);
 const WORKSPACE_VISIBILITY_SET = new Set(WORKSPACE_VISIBILITY_LEVELS);
 const MATERIALIZED_PACKAGE_ROOTS = new Map();
@@ -95,6 +93,20 @@ function normalizeMutationExtension(value) {
   return `.${extension}`;
 }
 
+function normalizeTemplateContextRecord(value) {
+  const record = ensureObject(value);
+  const entrypoint = String(record.entrypoint || "").trim();
+  const exportName = String(record.export || "").trim();
+  if (!entrypoint && !exportName) {
+    return null;
+  }
+
+  return Object.freeze({
+    entrypoint,
+    export: exportName || "buildTemplateContext"
+  });
+}
+
 function normalizeFileMutationRecord(value) {
   const record = ensureObject(value);
   const op = String(record.op || "copy-file").trim().toLowerCase() || "copy-file";
@@ -111,6 +123,7 @@ function normalizeFileMutationRecord(value) {
     id: String(record.id || "").trim(),
     category: String(record.category || "").trim(),
     reason: String(record.reason || "").trim(),
+    templateContext: normalizeTemplateContextRecord(record.templateContext),
     when: normalizeMutationWhen(record.when)
   };
 }
@@ -184,6 +197,44 @@ function normalizeWhenSourceValue(value) {
   return "";
 }
 
+function normalizeWhenComparisonValue(value) {
+  const normalizedValue = normalizeWhenSourceValue(value);
+  if (!normalizedValue.includes(",")) {
+    return normalizedValue;
+  }
+
+  return normalizedValue
+    .split(",")
+    .map((entry) => String(entry || "").trim())
+    .filter(Boolean)
+    .join(",");
+}
+
+function splitWhenComparisonTokens(value) {
+  return normalizeWhenComparisonValue(value)
+    .split(",")
+    .map((entry) => String(entry || "").trim())
+    .filter(Boolean);
+}
+
+function matchesWhenComparisonValue(optionValue, optionTokens, expectedValue) {
+  const expected = normalizeWhenComparisonValue(expectedValue);
+  if (!expected) {
+    return false;
+  }
+
+  const expectedTokens = splitWhenComparisonTokens(expected);
+  if (expectedTokens.length > 1) {
+    return optionValue === expected;
+  }
+
+  if (optionTokens.length > 1) {
+    return optionTokens.includes(expectedTokens[0]);
+  }
+
+  return optionValue === expectedTokens[0];
+}
+
 function resolveWhenConfigValue(configContext = {}, configPath = "") {
   const normalizedPath = String(configPath || "").trim();
   if (!normalizedPath) {
@@ -244,11 +295,12 @@ function shouldApplyMutationWhen(
   const sourceValue = optionName
     ? readObjectPath(options, optionName)
     : resolveWhenConfigValue(configContext, configPath);
-  const optionValue = normalizeWhenSourceValue(sourceValue);
-  const equals = String(when.equals || "").trim();
-  const notEquals = String(when.notEquals || "").trim();
-  const includes = ensureArray(when.includes).map((entry) => String(entry || "").trim()).filter(Boolean);
-  const excludes = ensureArray(when.excludes).map((entry) => String(entry || "").trim()).filter(Boolean);
+  const optionValue = normalizeWhenComparisonValue(sourceValue);
+  const optionTokens = splitWhenComparisonTokens(optionValue);
+  const equals = normalizeWhenComparisonValue(when.equals);
+  const notEquals = normalizeWhenComparisonValue(when.notEquals);
+  const includes = ensureArray(when.includes).map((entry) => normalizeWhenComparisonValue(entry)).filter(Boolean);
+  const excludes = ensureArray(when.excludes).map((entry) => normalizeWhenComparisonValue(entry)).filter(Boolean);
 
   if (equals && optionValue !== equals) {
     return false;
@@ -256,10 +308,10 @@ function shouldApplyMutationWhen(
   if (notEquals && optionValue === notEquals) {
     return false;
   }
-  if (includes.length > 0 && !includes.includes(optionValue)) {
+  if (includes.length > 0 && !includes.some((entry) => matchesWhenComparisonValue(optionValue, optionTokens, entry))) {
     return false;
   }
-  if (excludes.length > 0 && excludes.includes(optionValue)) {
+  if (excludes.length > 0 && excludes.some((entry) => matchesWhenComparisonValue(optionValue, optionTokens, entry))) {
     return false;
   }
 
@@ -1113,16 +1165,16 @@ function removeEnvValue(content, key, expectedValue, previous) {
   };
 }
 
-function normalizePackageInstallationMode(rawValue, descriptorPath) {
-  const normalized = String(rawValue || "")
-    .trim()
-    .toLowerCase();
+function normalizePackageKind(rawValue, descriptorPath) {
+  const normalized = String(rawValue || "").trim().toLowerCase();
   if (!normalized) {
-    return PACKAGE_INSTALL_MODE_INSTALLABLE;
+    throw createCliError(
+      `Invalid package descriptor at ${descriptorPath}: missing kind (expected ${PACKAGE_KINDS.join(" | ")}).`
+    );
   }
-  if (!PACKAGE_INSTALL_MODES.includes(normalized)) {
+  if (!PACKAGE_KINDS.includes(normalized)) {
     throw createCliError(
-      `Invalid package descriptor at ${descriptorPath}: installationMode must be one of: ${PACKAGE_INSTALL_MODES.join(", ")}.`
+      `Invalid package descriptor at ${descriptorPath}: kind must be one of: ${PACKAGE_KINDS.join(", ")}.`
     );
   }
   return normalized;
@@ -1177,13 +1229,13 @@ function validatePackageDescriptorShape(descriptor, descriptorPath) {
 
   return {
     ...normalized,
-    installationMode: normalizePackageInstallationMode(normalized.installationMode, descriptorPath)
+    kind: normalizePackageKind(normalized.kind, descriptorPath)
   };
 }
 
-function isCloneOnlyPackageEntry(packageEntry) {
+function isGeneratorPackageEntry(packageEntry) {
   const descriptor = ensureObject(packageEntry?.descriptor);
-  return String(descriptor.installationMode || "").trim().toLowerCase() === PACKAGE_INSTALL_MODE_CLONE_ONLY;
+  return String(descriptor.kind || "").trim().toLowerCase() === PACKAGE_KIND_GENERATOR;
 }
 
 function validateAppLocalPackageDescriptorShape(descriptor, descriptorPath, { expectedPackageId = "", fallbackVersion = "" } = {}) {
@@ -1208,7 +1260,8 @@ function validateAppLocalPackageDescriptorShape(descriptor, descriptorPath, { ex
   return {
     ...normalized,
     packageId,
-    version
+    version,
+    kind: normalizePackageKind(normalized.kind, descriptorPath)
   };
 }
 
@@ -1277,85 +1330,6 @@ function validateBundleDescriptorShape(descriptor, descriptorPath) {
   return normalized;
 }
 
-async function loadWorkspacePackageRegistry() {
-  if (!MODULES_ROOT || !(await fileExists(MODULES_ROOT))) {
-    return new Map();
-  }
-
-  const directories = [];
-  const levelOne = await readdir(MODULES_ROOT, { withFileTypes: true });
-
-  for (const entry of levelOne) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    if (entry.name.startsWith(".") || entry.name.endsWith(".LEGACY")) {
-      continue;
-    }
-
-    const absolute = path.join(MODULES_ROOT, entry.name);
-    const descriptorPath = path.join(absolute, "package.descriptor.mjs");
-    if (await fileExists(descriptorPath)) {
-      directories.push(absolute);
-      continue;
-    }
-
-    const nested = await readdir(absolute, { withFileTypes: true }).catch(() => []);
-    for (const child of nested) {
-      if (!child.isDirectory() || child.name.startsWith(".")) {
-        continue;
-      }
-      const nestedAbsolute = path.join(absolute, child.name);
-      const nestedDescriptor = path.join(nestedAbsolute, "package.descriptor.mjs");
-      if (await fileExists(nestedDescriptor)) {
-        directories.push(nestedAbsolute);
-      }
-    }
-  }
-
-  const uniqueDirectories = sortStrings([...new Set(directories)]);
-  const registry = new Map();
-
-  for (const packageRoot of uniqueDirectories) {
-    const descriptorPath = path.join(packageRoot, "package.descriptor.mjs");
-    const descriptorModule = await import(pathToFileURL(descriptorPath).href);
-    const descriptor = validatePackageDescriptorShape(descriptorModule?.default, descriptorPath);
-
-    const packageJsonPath = path.join(packageRoot, "package.json");
-    if (!(await fileExists(packageJsonPath))) {
-      throw createCliError(`Missing package.json for ${descriptor.packageId} at ${packageRoot}.`);
-    }
-    const packageJson = await readJsonFile(packageJsonPath);
-    const packageName = String(packageJson?.name || "").trim();
-    if (packageName !== descriptor.packageId) {
-      throw createCliError(
-        `Descriptor/package mismatch at ${packageRoot}: package.descriptor.mjs has ${descriptor.packageId} but package.json has ${packageName || "(empty)"}.`
-      );
-    }
-
-    const relativeDir = normalizeRelativePath(WORKSPACE_ROOT || MODULES_ROOT, packageRoot);
-    const descriptorRelativePath = normalizeRelativePath(WORKSPACE_ROOT || MODULES_ROOT, descriptorPath);
-    registry.set(
-      descriptor.packageId,
-      createPackageEntry({
-        packageId: descriptor.packageId,
-        version: descriptor.version,
-        descriptor,
-        rootDir: packageRoot,
-        relativeDir,
-        descriptorRelativePath,
-        packageJson,
-        sourceType: "packages-directory",
-        source: {
-          descriptorPath: descriptorRelativePath
-        }
-      })
-    );
-  }
-
-  return registry;
-}
-
 async function loadAppLocalPackageRegistry(appRoot) {
   const localPackagesRoot = path.join(appRoot, "packages");
   if (!(await fileExists(localPackagesRoot))) {
@@ -1468,17 +1442,14 @@ async function loadCatalogPackageRegistry() {
 }
 
 async function loadPackageRegistry() {
-  const workspaceRegistry = await loadWorkspacePackageRegistry();
   const catalogRegistry = await loadCatalogPackageRegistry();
-  const merged = mergePackageRegistries(catalogRegistry, workspaceRegistry);
-
-  if (merged.size === 0) {
+  if (catalogRegistry.size === 0) {
     throw createCliError(
-      "Unable to load package registry. Provide JSKIT_REPO_ROOT for workspace mode or ensure @jskit-ai/jskit-catalog is installed (or set JSKIT_CATALOG_PACKAGES_PATH)."
+      "Unable to load package registry from @jskit-ai/jskit-catalog. Install it alongside @jskit-ai/jskit-cli or set JSKIT_CATALOG_PACKAGES_PATH."
     );
   }
 
-  return merged;
+  return catalogRegistry;
 }
 
 async function loadInstalledNodeModulePackageEntry({ appRoot, packageId }) {
@@ -1745,6 +1716,7 @@ function createLocalPackageDescriptorTemplate({ packageId, description }) {
   packageVersion: 1,
   packageId: "${packageId}",
   version: "0.1.0",
+  kind: "runtime",
   description: ${JSON.stringify(String(description || ""))},
   dependsOn: [
     // "@jskit-ai/kernel"
@@ -3544,20 +3516,134 @@ function interpolateFileMutationRecord(mutation, options, packageId) {
     extension: interpolate(mutation.extension, "extension"),
     id: interpolate(mutation.id, "id"),
     category: interpolate(mutation.category, "category"),
-    reason: interpolate(mutation.reason, "reason")
+    reason: interpolate(mutation.reason, "reason"),
+    templateContext: mutation.templateContext
+      ? {
+          entrypoint: interpolate(mutation.templateContext.entrypoint, "templateContext.entrypoint"),
+          export: interpolate(mutation.templateContext.export, "templateContext.export")
+        }
+      : null
   };
 }
 
-async function copyTemplateFile(sourcePath, targetPath, options, packageId, interpolationKey) {
+function applyTemplateContextReplacements(sourceContent, replacements) {
+  let output = String(sourceContent || "");
+  for (const [placeholder, value] of Object.entries(ensureObject(replacements))) {
+    const normalizedPlaceholder = String(placeholder || "");
+    if (!normalizedPlaceholder) {
+      continue;
+    }
+    output = output.split(normalizedPlaceholder).join(String(value == null ? "" : value));
+  }
+  return output;
+}
+
+async function copyTemplateFile(
+  sourcePath,
+  targetPath,
+  options,
+  packageId,
+  interpolationKey,
+  templateContextReplacements = null
+) {
   const sourceContent = await readFile(sourcePath, "utf8");
-  const renderedContent = sourceContent.includes("${")
+  let renderedContent = sourceContent.includes("${")
     ? interpolateOptionValue(sourceContent, options, packageId, interpolationKey)
     : sourceContent;
+  if (templateContextReplacements) {
+    renderedContent = applyTemplateContextReplacements(renderedContent, templateContextReplacements);
+  }
 
   await mkdir(path.dirname(targetPath), { recursive: true });
   await writeFile(targetPath, renderedContent, "utf8");
 }
 
+async function resolveTemplateContextReplacementsForMutation({
+  packageEntry,
+  mutation,
+  options,
+  appRoot,
+  sourcePath,
+  targetPaths
+} = {}) {
+  const templateContext = ensureObject(mutation?.templateContext);
+  const hasTemplateContext = Object.keys(templateContext).length > 0;
+  const entrypoint = String(templateContext.entrypoint || "").trim();
+  if (!hasTemplateContext) {
+    return null;
+  }
+  if (!entrypoint) {
+    throw createCliError(
+      `Invalid files mutation in ${packageEntry.packageId}: templateContext.entrypoint is required when templateContext is set.`
+    );
+  }
+  const exportName = String(templateContext.export || "").trim() || "buildTemplateContext";
+  const resolvedEntrypointPath = resolveAppRelativePathWithinRoot(
+    packageEntry.rootDir,
+    entrypoint,
+    `${packageEntry.packageId} files mutation templateContext.entrypoint`
+  );
+  const absoluteEntrypointPath = resolvedEntrypointPath.absolutePath;
+  if (!(await fileExists(absoluteEntrypointPath))) {
+    throw createCliError(
+      `Invalid files mutation in ${packageEntry.packageId}: templateContext.entrypoint not found at ${entrypoint}.`
+    );
+  }
+
+  let moduleNamespace = null;
+  try {
+    moduleNamespace = await import(`${pathToFileURL(absoluteEntrypointPath).href}?t=${Date.now()}_${Math.random()}`);
+  } catch (error) {
+    throw createCliError(
+      `Unable to load templateContext entrypoint ${entrypoint} for ${packageEntry.packageId}: ${String(error?.message || error || "unknown error")}`
+    );
+  }
+
+  const resolver = moduleNamespace?.[exportName];
+  if (typeof resolver !== "function") {
+    throw createCliError(
+      `Invalid files mutation in ${packageEntry.packageId}: templateContext export "${exportName}" is not a function.`
+    );
+  }
+
+  let replacements = null;
+  try {
+    replacements = await resolver({
+      packageId: packageEntry.packageId,
+      packageRoot: packageEntry.rootDir,
+      appRoot,
+      options: Object.freeze({ ...ensureObject(options) }),
+      mutation: Object.freeze({ ...ensureObject(mutation) }),
+      sourcePath,
+      targetPaths: Object.freeze([...ensureArray(targetPaths)])
+    });
+  } catch (error) {
+    throw createCliError(
+      `templateContext export "${exportName}" failed for ${packageEntry.packageId}: ${String(error?.message || error || "unknown error")}`
+    );
+  }
+
+  if (replacements == null) {
+    return null;
+  }
+  if (!replacements || typeof replacements !== "object" || Array.isArray(replacements)) {
+    throw createCliError(
+      `Invalid files mutation in ${packageEntry.packageId}: templateContext export "${exportName}" must return an object map of placeholder replacements.`
+    );
+  }
+
+  const normalizedReplacements = {};
+  for (const [placeholder, value] of Object.entries(replacements)) {
+    const normalizedPlaceholder = String(placeholder || "").trim();
+    if (!normalizedPlaceholder) {
+      continue;
+    }
+    normalizedReplacements[normalizedPlaceholder] = String(value == null ? "" : value);
+  }
+
+  return Object.freeze(normalizedReplacements);
+}
+
 function normalizeSurfaceIdForMutation(value = "") {
   return String(value || "")
     .trim()
@@ -3738,8 +3824,10 @@ async function applyFileMutations(
   managedFiles,
   managedMigrations,
   touchedFiles,
-  warnings = []
+  warnings = [],
+  precomputedTemplateContextByMutationIndex = null
 ) {
+  const mutationList = ensureArray(fileMutations);
   const managedMigrationById = new Map();
   for (const managedMigrationValue of ensureArray(managedMigrations)) {
     const managedMigration = ensureObject(managedMigrationValue);
@@ -3750,7 +3838,7 @@ async function applyFileMutations(
     managedMigrationById.set(migrationId, managedMigration);
   }
 
-  for (const mutationValue of fileMutations) {
+  for (const [mutationIndex, mutationValue] of mutationList.entries()) {
     const normalizedMutation = normalizeFileMutationRecord(mutationValue);
     const requiresConfigContext = Boolean(normalizedMutation.when?.config || normalizedMutation.toSurface);
     const configContext = requiresConfigContext ? await loadMutationWhenConfigContext(appRoot) : {};
@@ -3788,10 +3876,27 @@ async function applyFileMutations(
         throw createCliError(`Missing migration template source ${sourcePath} for ${packageEntry.packageId}.`);
       }
 
+      const hasPrecomputedTemplateContext =
+        precomputedTemplateContextByMutationIndex instanceof Map &&
+        precomputedTemplateContextByMutationIndex.has(mutationIndex);
+      const templateContextReplacements = hasPrecomputedTemplateContext
+        ? precomputedTemplateContextByMutationIndex.get(mutationIndex)
+        : await resolveTemplateContextReplacementsForMutation({
+            packageEntry,
+            mutation,
+            options,
+            appRoot,
+            sourcePath,
+            targetPaths: [path.join(appRoot, toDir)]
+          });
+
       const sourceContent = await readFile(sourcePath, "utf8");
-      const renderedSourceContent = sourceContent.includes("${")
+      let renderedSourceContent = sourceContent.includes("${")
         ? interpolateOptionValue(sourceContent, options, packageEntry.packageId, `${mutation.id || from}.source`)
         : sourceContent;
+      if (templateContextReplacements) {
+        renderedSourceContent = applyTemplateContextReplacements(renderedSourceContent, templateContextReplacements);
+      }
       const sourceExtension = normalizeMigrationExtension(path.extname(from), ".cjs");
       const extension = normalizeMigrationExtension(mutation.extension, sourceExtension);
       const sourceHash = hashBuffer(Buffer.from(renderedSourceContent, "utf8"));
@@ -3956,6 +4061,19 @@ async function applyFileMutations(
           configContext
         })
       : [path.join(appRoot, to)];
+    const hasPrecomputedTemplateContext =
+      precomputedTemplateContextByMutationIndex instanceof Map &&
+      precomputedTemplateContextByMutationIndex.has(mutationIndex);
+    const templateContextReplacements = hasPrecomputedTemplateContext
+      ? precomputedTemplateContextByMutationIndex.get(mutationIndex)
+      : await resolveTemplateContextReplacementsForMutation({
+          packageEntry,
+          mutation,
+          options,
+          appRoot,
+          sourcePath,
+          targetPaths
+        });
     for (const targetPath of targetPaths) {
       const previous = await readFileBufferIfExists(targetPath);
       await copyTemplateFile(
@@ -3963,7 +4081,8 @@ async function applyFileMutations(
         targetPath,
         options,
         packageEntry.packageId,
-        `${mutation.id || to || from}.source`
+        `${mutation.id || to || from}.source`,
+        templateContextReplacements
       );
       const nextBuffer = await readFile(targetPath);
 
@@ -3982,6 +4101,91 @@ async function applyFileMutations(
   }
 }
 
+async function preflightFileMutationTemplateContexts(
+  packageEntry,
+  options,
+  appRoot,
+  fileMutations
+) {
+  const mutationList = ensureArray(fileMutations);
+  const replacementsByMutationIndex = new Map();
+
+  for (const [mutationIndex, mutationValue] of mutationList.entries()) {
+    const normalizedMutation = normalizeFileMutationRecord(mutationValue);
+    const requiresConfigContext = Boolean(normalizedMutation.when?.config || normalizedMutation.toSurface);
+    const configContext = requiresConfigContext ? await loadMutationWhenConfigContext(appRoot) : {};
+    if (
+      !shouldApplyMutationWhen(normalizedMutation.when, {
+        options,
+        configContext,
+        packageId: packageEntry.packageId,
+        mutationContext: "files mutation"
+      })
+    ) {
+      continue;
+    }
+
+    const mutation = interpolateFileMutationRecord(normalizedMutation, options, packageEntry.packageId);
+    const templateContext = ensureObject(mutation.templateContext);
+    if (Object.keys(templateContext).length < 1) {
+      continue;
+    }
+
+    const operation = mutation.op || "copy-file";
+    if (operation !== "copy-file" && operation !== "install-migration") {
+      continue;
+    }
+
+    const from = mutation.from;
+    const to = mutation.to;
+    const toSurface = mutation.toSurface;
+    if (!from) {
+      throw createCliError(
+        `Invalid files mutation in ${packageEntry.packageId}: "from" is required.`
+      );
+    }
+    if (operation === "copy-file") {
+      if (to && toSurface) {
+        throw createCliError(
+          `Invalid files mutation in ${packageEntry.packageId}: "to" and "toSurface" cannot both be set.`
+        );
+      }
+      if (!to && !toSurface) {
+        throw createCliError(
+          `Invalid files mutation in ${packageEntry.packageId}: "from" plus one destination ("to" or "toSurface") are required.`
+        );
+      }
+    }
+
+    const sourcePath = path.join(packageEntry.rootDir, from);
+    if (!(await fileExists(sourcePath))) {
+      throw createCliError(`Missing template source ${sourcePath} for ${packageEntry.packageId}.`);
+    }
+
+    const targetPaths = operation === "copy-file"
+      ? toSurface
+        ? resolveSurfaceTargetPathsForMutation({
+            appRoot,
+            packageId: packageEntry.packageId,
+            mutation,
+            configContext
+          })
+        : [path.join(appRoot, to)]
+      : [path.join(appRoot, mutation.toDir || "migrations")];
+    const replacements = await resolveTemplateContextReplacementsForMutation({
+      packageEntry,
+      mutation,
+      options,
+      appRoot,
+      sourcePath,
+      targetPaths
+    });
+    replacementsByMutationIndex.set(mutationIndex, replacements);
+  }
+
+  return replacementsByMutationIndex;
+}
+
 async function applyTextMutations(packageEntry, appRoot, textMutations, options, managedText, touchedFiles) {
   for (const mutation of textMutations) {
     const when = normalizeMutationWhen(mutation?.when);
@@ -4391,9 +4595,10 @@ async function applyPackageInstall({
 
   const managedRecord = createManagedRecordBase(packageEntry, packageOptions);
   managedRecord.managed.migrations = cloneManagedArray(existingManaged.migrations);
-  const cloneOnlyPackage = isCloneOnlyPackageEntry(packageEntry);
+  const generatorPackage = isGeneratorPackageEntry(packageEntry);
   const mutationWarnings = [];
   const mutations = ensureObject(packageEntry.descriptor.mutations);
+  const fileMutations = ensureArray(mutations.files);
   const templateRoot = await resolvePackageTemplateRoot({ packageEntry, appRoot });
   const packageEntryForMutations =
     templateRoot === packageEntry.rootDir
@@ -4402,6 +4607,14 @@ async function applyPackageInstall({
           ...packageEntry,
           rootDir: templateRoot
         };
+
+  const precomputedTemplateContextByMutationIndex = await preflightFileMutationTemplateContexts(
+    packageEntryForMutations,
+    packageOptions,
+    appRoot,
+    fileMutations
+  );
+
   const mutationDependencies = ensureObject(mutations.dependencies);
   const runtimeDependencies = ensureObject(mutationDependencies.runtime);
   const devDependencies = ensureObject(mutationDependencies.dev);
@@ -4471,7 +4684,7 @@ async function applyPackageInstall({
     }
   }
 
-  if (cloneOnlyPackage) {
+  if (generatorPackage) {
     const removedRuntimeDependency = removePackageJsonField(appPackageJson, "dependencies", packageEntry.packageId);
     const removedDevDependency = removePackageJsonField(appPackageJson, "devDependencies", packageEntry.packageId);
     if (removedRuntimeDependency || removedDevDependency) {
@@ -4507,11 +4720,12 @@ async function applyPackageInstall({
     packageEntryForMutations,
     packageOptions,
     appRoot,
-    ensureArray(mutations.files),
+    fileMutations,
     managedRecord.managed.files,
     managedRecord.managed.migrations,
     touchedFiles,
-    mutationWarnings
+    mutationWarnings,
+    precomputedTemplateContextByMutationIndex
   );
 
   await applyTextMutations(
@@ -4532,7 +4746,7 @@ async function applyPackageInstall({
     touchedFiles
   );
 
-  if (cloneOnlyPackage) {
+  if (generatorPackage) {
     delete lock.installedPackages[packageEntry.packageId];
   } else {
     managedRecord.migrationSyncVersion = packageEntry.version;

package/src/server/commandHandlers.js

@@ -124,6 +124,18 @@ function createCommandHandlers(deps) {
     return sortStrings(dependents);
   }
 
+  function resolvePackageKind(packageEntry) {
+    const descriptor = ensureObject(packageEntry?.descriptor);
+    const normalizedKind = String(descriptor.kind || "").trim().toLowerCase();
+    if (normalizedKind === "runtime" || normalizedKind === "generator") {
+      return normalizedKind;
+    }
+    const packageId = String(packageEntry?.packageId || descriptor.packageId || "unknown-package").trim();
+    throw createCliError(
+      `Invalid package descriptor for ${packageId}: missing/invalid kind (expected runtime or generator).`
+    );
+  }
+
   function resolvePackageOptionNames(packageEntry) {
     const optionSchemas = ensureObject(packageEntry?.descriptor?.options);
     return Object.keys(optionSchemas);
@@ -177,6 +189,155 @@ function createCommandHandlers(deps) {
       : " This bundle does not accept inline options.";
     throw createCliError(`Unknown option(s) for bundle ${bundleId}: ${sortedUnknown.join(", ")}.${suffix}`);
   }
+
+  function collectDescriptorContainerTokens({ packageId, side, values, issues }) {
+    const declaredTokens = new Set();
+    const duplicateTokens = new Set();
+    let invalidCount = 0;
+
+    for (const rawValue of ensureArray(values)) {
+      if (typeof rawValue !== "string") {
+        invalidCount += 1;
+        continue;
+      }
+      const token = rawValue.trim();
+      if (!token) {
+        invalidCount += 1;
+        continue;
+      }
+      if (declaredTokens.has(token)) {
+        duplicateTokens.add(token);
+        continue;
+      }
+      declaredTokens.add(token);
+    }
+
+    if (invalidCount > 0) {
+      issues.push({
+        packageId,
+        side,
+        code: "descriptor-token-invalid",
+        message: `${packageId} (${side}): metadata.apiSummary.containerTokens includes ${invalidCount} non-string or empty token value(s).`
+      });
+    }
+    for (const token of sortStrings([...duplicateTokens])) {
+      issues.push({
+        packageId,
+        side,
+        code: "descriptor-token-duplicate",
+        token,
+        message: `${packageId} (${side}): descriptor token is declared more than once: ${token}.`
+      });
+    }
+
+    return declaredTokens;
+  }
+
+  function collectUsedContainerTokens({ packageId, side, bindings, issues }) {
+    const usedTokens = new Set();
+    for (const rawBinding of ensureArray(bindings)) {
+      const binding = ensureObject(rawBinding);
+      const tokenExpression = String(binding.tokenExpression || "").trim();
+      const token = String(binding.token || "").trim();
+      const location = String(binding.location || "").trim();
+      if (binding.tokenResolved !== true || !token) {
+        const expressionLabel = tokenExpression || "<empty>";
+        const locationSuffix = location ? ` at ${location}` : "";
+        issues.push({
+          packageId,
+          side,
+          code: "binding-token-unresolved",
+          tokenExpression: expressionLabel,
+          location,
+          message: `${packageId} (${side}): unresolved DI token expression "${expressionLabel}"${locationSuffix}.`
+        });
+        continue;
+      }
+      usedTokens.add(token);
+    }
+    return usedTokens;
+  }
+
+  function collectProviderIntrospectionIssues({ packageId, packageInsights, issues }) {
+    const introspection = ensureObject(packageInsights);
+    if (!introspection.available) {
+      issues.push({
+        packageId,
+        side: "",
+        code: "provider-introspection-unavailable",
+        message: `${packageId}: provider source introspection is unavailable, so DI token parity cannot be verified.`
+      });
+      return;
+    }
+
+    const notes = ensureArray(introspection.notes).map((value) => String(value || "").trim()).filter(Boolean);
+    for (const note of notes) {
+      if (
+        note.startsWith("Skipped wildcard provider entrypoint during introspection:") ||
+        note.startsWith("Provider file missing during introspection:") ||
+        note.startsWith("Failed reading provider ")
+      ) {
+        issues.push({
+          packageId,
+          side: "",
+          code: "provider-introspection-incomplete",
+          message: `${packageId}: ${note}`
+        });
+      }
+    }
+  }
+
+  function collectDiLabelParityIssuesForPackage({ packageEntry, packageInsights }) {
+    const packageId = String(packageEntry?.packageId || "").trim();
+    const descriptor = ensureObject(packageEntry?.descriptor);
+    const metadataApiSummary = ensureObject(ensureObject(descriptor.metadata).apiSummary);
+    const descriptorTokenSummary = ensureObject(metadataApiSummary.containerTokens);
+    const bindingSections = ensureObject(ensureObject(packageInsights).containerBindings);
+    const issues = [];
+    const sides = ["server", "client"];
+
+    collectProviderIntrospectionIssues({ packageId, packageInsights, issues });
+
+    for (const side of sides) {
+      const declaredTokens = collectDescriptorContainerTokens({
+        packageId,
+        side,
+        values: descriptorTokenSummary[side],
+        issues
+      });
+      const usedTokens = collectUsedContainerTokens({
+        packageId,
+        side,
+        bindings: bindingSections[side],
+        issues
+      });
+
+      for (const token of sortStrings([...usedTokens])) {
+        if (!declaredTokens.has(token)) {
+          issues.push({
+            packageId,
+            side,
+            code: "binding-token-undeclared",
+            token,
+            message: `${packageId} (${side}): token is used by providers but missing from metadata.apiSummary.containerTokens.${side}: ${token}.`
+          });
+        }
+      }
+      for (const token of sortStrings([...declaredTokens])) {
+        if (!usedTokens.has(token)) {
+          issues.push({
+            packageId,
+            side,
+            code: "descriptor-token-unused",
+            token,
+            message: `${packageId} (${side}): token is declared in metadata.apiSummary.containerTokens.${side} but never bound by providers: ${token}.`
+          });
+        }
+      }
+    }
+
+    return issues;
+  }
   
   async function commandList({ positional, options, cwd, stdout }) {
     const packageRegistry = await loadPackageRegistry();
@@ -207,8 +368,9 @@ function createCommandHandlers(deps) {
     const mode = String(positional[0] || "").trim();
     const shouldListBundles = !mode || mode === "bundles";
     const shouldListPackages = !mode || mode === "packages";
-  
-    if (!shouldListBundles && !shouldListPackages) {
+    const shouldListGenerators = !mode || mode === "generators";
+
+    if (!shouldListBundles && !shouldListPackages && !shouldListGenerators) {
       throw createCliError(`Unknown list mode: ${mode}`, { showUsage: true });
     }
   
@@ -238,8 +400,11 @@ function createCommandHandlers(deps) {
       if (lines.length > 0) {
         lines.push("");
       }
-      lines.push(color.heading("Available packages:"));
-      const packageIds = sortStrings([...packageRegistry.keys()]);
+      lines.push(color.heading("Available runtime packages:"));
+      const packageIds = sortStrings([...packageRegistry.keys()].filter((packageId) => {
+        const packageEntry = packageRegistry.get(packageId);
+        return resolvePackageKind(packageEntry) === "runtime";
+      }));
       for (const packageId of packageIds) {
         const packageEntry = packageRegistry.get(packageId);
         const installedLabel = installedPackages.has(packageId) ? " (installed)" : "";
@@ -281,6 +446,24 @@ function createCommandHandlers(deps) {
         }
       }
     }
+
+    if (shouldListGenerators) {
+      if (lines.length > 0) {
+        lines.push("");
+      }
+      lines.push(color.heading("Available generators:"));
+      const packageIds = sortStrings([...packageRegistry.keys()].filter((packageId) => {
+        const packageEntry = packageRegistry.get(packageId);
+        return resolvePackageKind(packageEntry) === "generator";
+      }));
+      for (const packageId of packageIds) {
+        const packageEntry = packageRegistry.get(packageId);
+        const installedLabel = installedPackages.has(packageId) ? " (installed)" : "";
+        lines.push(
+          `- ${color.item(packageId)} ${color.version(`(${packageEntry.version})`)}${installedLabel ? color.installed(installedLabel) : ""}`
+        );
+      }
+    }
   
     if (options.json) {
       const payload = {
@@ -299,14 +482,42 @@ function createCommandHandlers(deps) {
           })
           : [],
         packages: shouldListPackages
+          ? sortStrings([...packageRegistry.keys()])
+            .filter((packageId) => resolvePackageKind(packageRegistry.get(packageId)) === "runtime")
+            .map((packageId) => {
+              const packageEntry = packageRegistry.get(packageId);
+              return {
+                packageId,
+                version: packageEntry.version,
+                installed: installedPackages.has(packageId)
+              };
+            })
+          : [],
+        runtimePackages: shouldListPackages
           ? sortStrings([...packageRegistry.keys()]).map((packageId) => {
             const packageEntry = packageRegistry.get(packageId);
+            if (resolvePackageKind(packageEntry) !== "runtime") {
+              return null;
+            }
             return {
               packageId,
               version: packageEntry.version,
               installed: installedPackages.has(packageId)
             };
-          })
+          }).filter(Boolean)
+          : [],
+        generators: shouldListGenerators
+          ? sortStrings([...packageRegistry.keys()]).map((packageId) => {
+            const packageEntry = packageRegistry.get(packageId);
+            if (resolvePackageKind(packageEntry) !== "generator") {
+              return null;
+            }
+            return {
+              packageId,
+              version: packageEntry.version,
+              installed: installedPackages.has(packageId)
+            };
+          }).filter(Boolean)
           : [],
         installedLocalPackages: shouldListPackages
           ? installedLocalPackageIds.map((packageId) => {
@@ -1103,10 +1314,16 @@ function createCommandHandlers(deps) {
   }
   
   async function commandAdd({ positional, options, cwd, io }) {
+    const invocationMode = options?.commandMode === "generate" ? "generate" : "add";
     const targetType = String(positional[0] || "").trim();
     const targetId = String(positional[1] || "").trim();
   
     if (!targetType || !targetId) {
+      if (invocationMode === "generate") {
+        throw createCliError("generate requires a package id (generate <packageId>).", {
+          showUsage: true
+        });
+      }
       throw createCliError("add requires target type and id (add bundle <id> | add package <id>).", {
         showUsage: true
       });
@@ -1114,6 +1331,11 @@ function createCommandHandlers(deps) {
     if (targetType !== "bundle" && targetType !== "package") {
       throw createCliError(`Unsupported add target type: ${targetType}`, { showUsage: true });
     }
+    if (invocationMode === "generate" && targetType !== "package") {
+      throw createCliError("generate requires a package id (generate <packageId>).", {
+        showUsage: true
+      });
+    }
   
     const appRoot = await resolveAppRootFromCwd(cwd);
     const packageRegistry = await loadPackageRegistry();
@@ -1123,10 +1345,11 @@ function createCommandHandlers(deps) {
     const { packageJsonPath, packageJson } = await loadAppPackageJson(appRoot);
     const { lockPath, lock } = await loadLockFile(appRoot);
     let resolvedTargetPackageId = targetType === "package" ? resolvePackageIdInput(targetId, combinedPackageRegistry) : "";
-    if (targetType === "package" && !resolvedTargetPackageId) {
+    if (targetType === "package") {
+      const packageIdForNodeModulesLookup = resolvedTargetPackageId || targetId;
       const installedNodeModuleEntry = await resolveInstalledNodeModulePackageEntry({
         appRoot,
-        packageId: targetId
+        packageId: packageIdForNodeModulesLookup
       });
       if (installedNodeModuleEntry) {
         combinedPackageRegistry.set(installedNodeModuleEntry.packageId, installedNodeModuleEntry);
@@ -1157,6 +1380,17 @@ function createCommandHandlers(deps) {
       if (!targetPackageEntry) {
         throw createCliError(`Unknown package: ${targetId}`);
       }
+      const packageKind = resolvePackageKind(targetPackageEntry);
+      if (invocationMode === "add" && packageKind === "generator") {
+        throw createCliError(
+          `Package ${resolvedTargetPackageId} is a generator. Use: jskit generate ${resolvedTargetPackageId}`
+        );
+      }
+      if (invocationMode === "generate" && packageKind !== "generator") {
+        throw createCliError(
+          `Package ${resolvedTargetPackageId} is a runtime package. Use: jskit add package ${resolvedTargetPackageId}`
+        );
+      }
       validateInlineOptionsForPackage(targetPackageEntry, options.inlineOptions);
     }
   
@@ -1164,6 +1398,17 @@ function createCommandHandlers(deps) {
       targetPackageIds,
       combinedPackageRegistry
     );
+    if (invocationMode === "add" && targetType === "bundle") {
+      const bundledGenerators = resolvedPackageIds.filter((packageId) => {
+        const packageEntry = combinedPackageRegistry.get(packageId);
+        return resolvePackageKind(packageEntry) === "generator";
+      });
+      if (bundledGenerators.length > 0) {
+        throw createCliError(
+          `Bundle ${targetId} includes generator package(s): ${bundledGenerators.join(", ")}. Use: jskit generate <packageId>`
+        );
+      }
+    }
     const plannedInstalledPackageIds = sortStrings([
       ...new Set([
         ...Object.keys(ensureObject(lock.installedPackages)).map((value) => String(value || "").trim()).filter(Boolean),
@@ -1173,7 +1418,7 @@ function createCommandHandlers(deps) {
     validatePlannedCapabilityClosure(
       plannedInstalledPackageIds,
       combinedPackageRegistry,
-      `add ${targetType} ${targetId}`
+      `${invocationMode} ${targetType} ${targetId}`
     );
 
     if (targetType === "bundle") {
@@ -1252,14 +1497,18 @@ function createCommandHandlers(deps) {
       validatePlannedCapabilityClosure(
         postInstallPackageIds,
         combinedPackageRegistry,
-        `add ${targetType} ${targetId}`
+        `${invocationMode} ${targetType} ${targetId}`
       );
     }
   
     const finalResolvedPackageIds = sortStrings([...resolvedPackageIds, ...adoptedPackageIds]);
   
     const touchedFileList = sortStrings([...touchedFiles]);
-    const successLabel = targetType === "bundle" ? "Added bundle" : "Added package";
+    const successLabel = invocationMode === "generate"
+      ? "Generated with"
+      : targetType === "bundle"
+        ? "Added bundle"
+        : "Added package";
     const installWarnings = installedPackageRecords
       .flatMap((record) => ensureArray(ensureObject(record).warnings))
       .map((value) => String(value || "").trim())
@@ -1275,7 +1524,7 @@ function createCommandHandlers(deps) {
   
     if (options.json) {
       io.stdout.write(`${JSON.stringify({
-        targetType,
+        targetType: invocationMode === "generate" ? "generator" : targetType,
         targetId,
         resolvedPackages: finalResolvedPackageIds,
         touchedFiles: touchedFileList,
@@ -1310,6 +1559,32 @@ function createCommandHandlers(deps) {
   
     return 0;
   }
+
+  async function commandGenerate({ positional, options, cwd, io }) {
+    const firstToken = String(positional[0] || "").trim();
+    const secondToken = String(positional[1] || "").trim();
+    if (firstToken === "bundle") {
+      throw createCliError("generate supports packages only (generate <packageId>).", {
+        showUsage: true
+      });
+    }
+    const targetId = firstToken === "package" ? secondToken : firstToken;
+    if (!targetId) {
+      throw createCliError("generate requires a package id (generate <packageId>).", {
+        showUsage: true
+      });
+    }
+
+    return commandAdd({
+      positional: ["package", targetId],
+      options: {
+        ...options,
+        commandMode: "generate"
+      },
+      cwd,
+      io
+    });
+  }
   
   async function commandUpdate({ positional, options, cwd, io }) {
     const targetType = String(positional[0] || "").trim();
@@ -1455,7 +1730,7 @@ function createCommandHandlers(deps) {
         io.stdout.write(`- ${touchedFile}\n`);
       }
       io.stdout.write(`Lock file: ${normalizeRelativePath(appRoot, lockPath)}\n`);
-      if (migrationWarnings.length > 0) {
+      if (options.verbose && migrationWarnings.length > 0) {
         io.stdout.write(`Warnings (${migrationWarnings.length}):\n`);
         for (const warning of migrationWarnings) {
           io.stdout.write(`- ${warning}\n`);
@@ -1760,19 +2035,58 @@ function createCommandHandlers(deps) {
   async function commandLintDescriptors({ options, stdout }) {
     const packageRegistry = await loadPackageRegistry();
     const bundleRegistry = await loadBundleRegistry();
+    const shouldCheckDiLabels = options.checkDiLabels === true;
+    let diLabelIssues = [];
+    if (shouldCheckDiLabels) {
+      const issues = [];
+      for (const packageId of sortStrings([...packageRegistry.keys()])) {
+        const packageEntry = packageRegistry.get(packageId);
+        if (!packageEntry) {
+          continue;
+        }
+        const packageInsights = await inspectPackageOfferings({ packageEntry });
+        issues.push(...collectDiLabelParityIssuesForPackage({ packageEntry, packageInsights }));
+      }
+      diLabelIssues = issues;
+    }
     const payload = {
       packageCount: packageRegistry.size,
       bundleCount: bundleRegistry.size,
       packages: sortStrings([...packageRegistry.keys()]),
-      bundles: sortStrings([...bundleRegistry.keys()])
+      bundles: sortStrings([...bundleRegistry.keys()]),
+      diLabelCheck: shouldCheckDiLabels
+        ? {
+            enabled: true,
+            issueCount: diLabelIssues.length,
+            issues: diLabelIssues
+          }
+        : {
+            enabled: false
+          }
     };
 
     if (options.json) {
       stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
     } else {
-      stdout.write(`Descriptor lint passed.\n`);
+      const descriptorStatus = shouldCheckDiLabels && diLabelIssues.length > 0 ? "failed" : "passed";
+      stdout.write(`Descriptor lint ${descriptorStatus}.\n`);
       stdout.write(`Packages: ${payload.packageCount}\n`);
       stdout.write(`Bundles: ${payload.bundleCount}\n`);
+      if (shouldCheckDiLabels) {
+        if (diLabelIssues.length === 0) {
+          stdout.write("DI label parity check passed.\n");
+        } else {
+          stdout.write(`DI label parity check failed (${diLabelIssues.length} issue(s)).\n`);
+          for (const issue of diLabelIssues) {
+            const code = String(issue?.code || "").trim();
+            const codeLabel = code ? `[${code}] ` : "";
+            stdout.write(`- ${codeLabel}${String(issue?.message || "").trim()}\n`);
+          }
+        }
+      }
+    }
+    if (shouldCheckDiLabels && diLabelIssues.length > 0) {
+      return 1;
     }
     return 0;
   }
@@ -1782,6 +2096,7 @@ function createCommandHandlers(deps) {
     commandShow,
     commandCreate,
     commandAdd,
+    commandGenerate,
     commandMigrations,
     commandPosition,
     commandUpdate,

package/src/server/pathResolution.js

@@ -8,66 +8,6 @@ import { createCliError } from "./cliError.js";
 const CLI_PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const require = createRequire(import.meta.url);
 
-function isWorkspaceRoot(candidateRoot) {
-  if (!candidateRoot) {
-    return false;
-  }
-  return (
-    existsSync(path.join(candidateRoot, "packages")) &&
-    existsSync(path.join(candidateRoot, "packages", "kernel")) &&
-    existsSync(path.join(candidateRoot, "tooling", "jskit-cli"))
-  );
-}
-
-function collectAncestorDirectories(startDirectory) {
-  const ancestors = [];
-  let current = path.resolve(startDirectory);
-  while (true) {
-    ancestors.push(current);
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return ancestors;
-}
-
-function resolveWorkspaceRoot() {
-  const candidates = [];
-  const seen = new Set();
-  const appendCandidate = (candidatePath) => {
-    const raw = String(candidatePath || "").trim();
-    if (!raw) {
-      return;
-    }
-    const absolute = path.resolve(raw);
-    if (seen.has(absolute)) {
-      return;
-    }
-    seen.add(absolute);
-    candidates.push(absolute);
-  };
-
-  appendCandidate(process.env.JSKIT_REPO_ROOT);
-  appendCandidate(path.resolve(CLI_PACKAGE_ROOT, "../.."));
-  appendCandidate(CLI_PACKAGE_ROOT);
-
-  const cwdAncestors = collectAncestorDirectories(process.cwd());
-  for (const ancestor of cwdAncestors) {
-    appendCandidate(ancestor);
-    appendCandidate(path.join(ancestor, "jskit-ai"));
-  }
-
-  for (const candidate of candidates) {
-    if (isWorkspaceRoot(candidate)) {
-      return candidate;
-    }
-  }
-
-  return "";
-}
-
 function resolveCatalogPackagesPath() {
   const explicitPath = String(process.env.JSKIT_CATALOG_PACKAGES_PATH || "").trim();
   if (explicitPath) {
@@ -92,15 +32,11 @@ function resolveCatalogPackagesPath() {
   );
 }
 
-const WORKSPACE_ROOT = resolveWorkspaceRoot();
-const MODULES_ROOT = WORKSPACE_ROOT ? path.join(WORKSPACE_ROOT, "packages") : "";
 const BUNDLES_ROOT = path.join(CLI_PACKAGE_ROOT, "bundles");
 const CATALOG_PACKAGES_PATH = resolveCatalogPackagesPath();
 
 export {
   CLI_PACKAGE_ROOT,
-  WORKSPACE_ROOT,
-  MODULES_ROOT,
   BUNDLES_ROOT,
   CATALOG_PACKAGES_PATH
 };

package/src/server/runCli.js

@@ -64,6 +64,14 @@ function createRunCli({
           io: { stdin, stdout, stderr }
         });
       }
+      if (command === "generate") {
+        return await commandHandlers.commandGenerate({
+          positional,
+          options,
+          cwd,
+          io: { stdin, stdout, stderr }
+        });
+      }
       if (command === "position") {
         return await commandHandlers.commandPosition({
           positional,