@jskit-ai/jskit-cli 0.2.26 → 0.2.28

package/src/server/commandHandlers/show/payloads.js

@@ -0,0 +1,92 @@
+import {
+  ensureArray,
+  ensureObject
+} from "../../shared/collectionUtils.js";
+
+async function buildPackageShowPayload({
+  packageRegistry,
+  packageEntry,
+  options,
+  inspectPackageOfferings,
+  buildFileWriteGroups,
+  listDeclaredCapabilities,
+  buildCapabilityDetailsForPackage
+} = {}) {
+  const descriptor = packageEntry.descriptor;
+  const fileWriteGroups = buildFileWriteGroups(
+    ensureArray(ensureObject(descriptor.mutations).files),
+    { packageId: descriptor.packageId }
+  );
+  const fileWriteCount = fileWriteGroups.reduce((total, group) => total + ensureArray(group.files).length, 0);
+  const capabilities = ensureObject(descriptor.capabilities);
+  const runtime = ensureObject(descriptor.runtime);
+  const metadata = ensureObject(descriptor.metadata);
+  const mutations = ensureObject(descriptor.mutations);
+  const packageInsights = await inspectPackageOfferings({ packageEntry });
+
+  const payload = {
+    kind: "package",
+    packageId: descriptor.packageId,
+    version: descriptor.version,
+    description: String(descriptor.description || ""),
+    dependsOn: ensureArray(descriptor.dependsOn).map((value) => String(value)),
+    capabilities,
+    options: ensureObject(descriptor.options),
+    runtime,
+    metadata,
+    mutations,
+    fileWritePlan: {
+      groupCount: fileWriteGroups.length,
+      fileCount: fileWriteCount,
+      groups: fileWriteGroups
+    },
+    descriptorPath: packageEntry.descriptorRelativePath,
+    introspection: {
+      available: Boolean(packageInsights.available),
+      notes: ensureArray(packageInsights.notes)
+    },
+    packageExports: ensureArray(packageInsights.packageExports),
+    containerBindings: ensureObject(packageInsights.containerBindings),
+    exportedSymbols: ensureArray(packageInsights.exportedSymbols)
+  };
+
+  const provides = listDeclaredCapabilities(payload.capabilities, "provides");
+  const requires = listDeclaredCapabilities(payload.capabilities, "requires");
+  const capabilityDetails = options.details
+    ? buildCapabilityDetailsForPackage({
+        packageRegistry,
+        packageId: payload.packageId,
+        dependsOn: payload.dependsOn,
+        provides,
+        requires
+      })
+    : null;
+
+  if (capabilityDetails) {
+    payload.capabilityDetails = capabilityDetails;
+  }
+
+  return {
+    payload,
+    provides,
+    requires,
+    capabilityDetails
+  };
+}
+
+function buildBundleShowPayload(bundle = {}) {
+  return {
+    kind: "bundle",
+    bundleId: bundle.bundleId,
+    version: bundle.version,
+    description: String(bundle.description || ""),
+    provider: Number(bundle.provider) === 1,
+    curated: Number(bundle.curated) === 1,
+    packages: ensureArray(bundle.packages).map((value) => String(value))
+  };
+}
+
+export {
+  buildBundleShowPayload,
+  buildPackageShowPayload
+};

package/src/server/commandHandlers/show/renderBundleText.js

@@ -0,0 +1,16 @@
+function renderBundlePayloadText({ payload, stdout, color, writeField } = {}) {
+  stdout.write(`${color.heading("Information")}\n`);
+  writeField("Bundle", payload.bundleId, color.item);
+  writeField("Version", payload.version, color.installed);
+  if (payload.description) {
+    writeField("Description", payload.description);
+  }
+  stdout.write(`${color.heading(`Packages (${payload.packages.length}):`)}\n`);
+  for (const packageId of payload.packages) {
+    stdout.write(`- ${color.item(packageId)}\n`);
+  }
+}
+
+export {
+  renderBundlePayloadText
+};

package/src/server/commandHandlers/show/renderHelpers.js

@@ -0,0 +1,82 @@
+import {
+  ensureArray,
+  ensureObject
+} from "../../shared/collectionUtils.js";
+
+function createShowRenderHelpers({
+  stdout,
+  color,
+  options,
+  deriveProviderDisplayName
+} = {}) {
+  const writeField = (label, value, formatValue = (raw) => raw) => {
+    stdout.write(`${color.dim(`${label}:`)} ${formatValue(String(value || ""))}\n`);
+  };
+
+  const writeBindingsSection = (side, bindings) => {
+    const sectionSide = String(side || "").trim().toLowerCase();
+    const bindingEntries = ensureArray(bindings);
+    stdout.write(`${color.heading(`Container bindings ${sectionSide} (${bindingEntries.length}):`)}\n`);
+    if (bindingEntries.length < 1) {
+      stdout.write(`- ${color.dim("none detected")}\n`);
+      return;
+    }
+
+    for (const bindingRecord of bindingEntries) {
+      const binding = ensureObject(bindingRecord);
+      const token = String(binding.token || "").trim();
+      const tokenExpression = String(binding.tokenExpression || "").trim();
+      const tokenLabel = binding.tokenResolved === true
+        ? token
+        : token || tokenExpression;
+      const bindingMethod = String(binding.binding || "").trim();
+      const providerName = deriveProviderDisplayName(binding);
+      const lifecycle = String(binding.lifecycle || "").trim();
+      const lifecycleSuffix = lifecycle && lifecycle !== "unknown" ? ` ${color.dim(`(${lifecycle})`)}` : "";
+      const unresolvedSuffix = binding.tokenResolved === true ? "" : color.dim(" [unresolved token]");
+      stdout.write(
+        `- ${color.item(tokenLabel)} ${color.installed(`[${bindingMethod}]`)} ${color.dim("by")} ${color.item(providerName)}${lifecycleSuffix}${unresolvedSuffix}\n`
+      );
+      if (options.details) {
+        const location = String(binding.location || "").trim();
+        if (location) {
+          stdout.write(`  ${color.dim(`source: ${location}`)}\n`);
+        }
+        const providerLabel = String(binding.provider || "").trim();
+        if (providerLabel) {
+          stdout.write(`  ${color.dim(`provider: ${providerLabel}`)}\n`);
+        }
+        if (binding.tokenResolved !== true && tokenExpression) {
+          stdout.write(`  ${color.dim(`token expression: ${tokenExpression}`)}\n`);
+        }
+      }
+    }
+  };
+
+  const writeRuntimeProviders = (side, providers) => {
+    const sectionSide = String(side || "").trim().toLowerCase();
+    const providerEntries = ensureArray(providers);
+    if (providerEntries.length < 1) {
+      return;
+    }
+
+    stdout.write(`${color.heading(`Runtime ${sectionSide} providers (${providerEntries.length}):`)}\n`);
+    for (const provider of providerEntries) {
+      const record = ensureObject(provider);
+      const entrypoint = String(record.entrypoint || "").trim();
+      const exportName = String(record.export || "").trim();
+      const label = exportName ? `${entrypoint}#${exportName}` : entrypoint;
+      stdout.write(`- ${color.item(label)}\n`);
+    }
+  };
+
+  return {
+    writeBindingsSection,
+    writeField,
+    writeRuntimeProviders
+  };
+}
+
+export {
+  createShowRenderHelpers
+};

package/src/server/commandHandlers/show/renderPackageCapabilities.js

@@ -0,0 +1,124 @@
+import { ensureArray } from "../../shared/collectionUtils.js";
+
+function writeCapabilitiesSections({
+  payload,
+  provides,
+  requires,
+  capabilityDetails,
+  stdout,
+  color,
+  wrapWidth,
+  writeWrappedItems
+} = {}) {
+  if (provides.length > 0 || requires.length > 0) {
+    stdout.write(`${color.heading("Capabilities:")}\n`);
+    if (provides.length > 0) {
+      const providesText = provides.map((capabilityId) => color.item(capabilityId)).join(" ");
+      stdout.write(`${color.installed("Provides:")} ${providesText}\n`);
+    }
+    if (requires.length > 0) {
+      const requiresText = requires.map((capabilityId) => color.item(capabilityId)).join(" ");
+      stdout.write(`${color.installed("Requires:")} ${requiresText}\n`);
+    }
+  }
+
+  if (!capabilityDetails || (capabilityDetails.provides.length < 1 && capabilityDetails.requires.length < 1)) {
+    return;
+  }
+
+  stdout.write(`${color.heading("Capability details:")}\n`);
+  writeCapabilityRecord({
+    heading: `Provides detail (${capabilityDetails.provides.length}):`,
+    records: capabilityDetails.provides,
+    includeDependsOnProviders: false,
+    stdout,
+    color,
+    wrapWidth,
+    writeWrappedItems
+  });
+  writeCapabilityRecord({
+    heading: `Requires detail (${capabilityDetails.requires.length}):`,
+    records: capabilityDetails.requires,
+    includeDependsOnProviders: true,
+    stdout,
+    color,
+    wrapWidth,
+    writeWrappedItems
+  });
+}
+
+function writeCapabilityRecord({
+  heading,
+  records,
+  includeDependsOnProviders = false,
+  stdout,
+  color,
+  wrapWidth,
+  writeWrappedItems
+} = {}) {
+  if (records.length < 1) {
+    return;
+  }
+  stdout.write(`${color.heading(heading)}\n`);
+  for (const record of records) {
+    const capabilityId = String(record.capabilityId || "").trim();
+    stdout.write(`- ${color.item(capabilityId)}\n`);
+
+    const providerItems = ensureArray(record.providerDetails).map((detail) => ({
+      text: formatPackageSummary(detail),
+      rendered: color.item(formatPackageSummary(detail))
+    }));
+    if (providerItems.length > 0) {
+      writeWrappedItems({
+        stdout,
+        heading: `  ${color.installed(`providers (${providerItems.length}):`)}`,
+        lineIndent: "    ",
+        wrapWidth,
+        items: providerItems
+      });
+    }
+
+    if (includeDependsOnProviders) {
+      const providersInDependsOn = ensureArray(record.providersInDependsOn).map((packageId) => ({
+        text: String(packageId),
+        rendered: color.item(String(packageId))
+      }));
+      if (providersInDependsOn.length > 0) {
+        writeWrappedItems({
+          stdout,
+          heading: `  ${color.installed(`providers in dependsOn (${providersInDependsOn.length}):`)}`,
+          lineIndent: "    ",
+          wrapWidth,
+          items: providersInDependsOn
+        });
+      }
+    }
+
+    const requirerItems = ensureArray(record.requirerDetails).map((detail) => ({
+      text: formatPackageSummary(detail),
+      rendered: color.item(formatPackageSummary(detail))
+    }));
+    if (requirerItems.length > 0) {
+      writeWrappedItems({
+        stdout,
+        heading: `  ${color.installed(`required by (${requirerItems.length}):`)}`,
+        lineIndent: "    ",
+        wrapWidth,
+        items: requirerItems
+      });
+    }
+  }
+}
+
+function formatPackageSummary(detail) {
+  const packageId = String(detail?.packageId || "").trim();
+  const version = String(detail?.version || "").trim();
+  const descriptorPath = String(detail?.descriptorPath || "").trim();
+  const versionSuffix = version ? `@${version}` : "";
+  const pathSuffix = descriptorPath ? ` [${descriptorPath}]` : "";
+  return `${packageId}${versionSuffix}${pathSuffix}`;
+}
+
+export {
+  writeCapabilitiesSections
+};

package/src/server/commandHandlers/show/renderPackageExports.js

@@ -0,0 +1,203 @@
+import {
+  ensureArray,
+  ensureObject
+} from "../../shared/collectionUtils.js";
+
+function writePackageExportsSection({
+  payload,
+  options,
+  stdout,
+  color,
+  wrapWidth,
+  normalizeRelativePosixPath,
+  shouldShowPackageExportTarget,
+  classifyExportedSymbols,
+  writeWrappedItems
+} = {}) {
+  const introspection = ensureObject(payload.introspection);
+  const introspectionAvailable = introspection.available === true;
+
+  if (!introspectionAvailable) {
+    stdout.write(`${color.heading("Code introspection:")}\n`);
+    stdout.write(`- ${color.dim("Source files unavailable (descriptor metadata only).")}\n`);
+    return;
+  }
+
+  const packageExports = ensureArray(payload.packageExports);
+  const exportedSymbols = ensureArray(payload.exportedSymbols);
+  const exportedSymbolsByFile = new Map(
+    exportedSymbols
+      .map((entry) => ensureObject(entry))
+      .map((entry) => {
+        const file = normalizeRelativePosixPath(String(entry.file || "").trim());
+        return file ? [file, entry] : null;
+      })
+      .filter(Boolean)
+  );
+
+  stdout.write(`${color.heading(`Package exports (${packageExports.length}):`)}\n`);
+  if (packageExports.length < 1) {
+    stdout.write(`- ${color.dim("none declared")}\n`);
+    return;
+  }
+
+  const symbolDetailsShown = new Set();
+  for (const packageExport of packageExports) {
+    const record = ensureObject(packageExport);
+    const subpath = String(record.subpath || ".").trim() || ".";
+    const condition = String(record.condition || "default").trim() || "default";
+    const target = String(record.target || "").trim();
+    const targetType = String(record.targetType || "").trim();
+    const conditionSuffix = condition !== "default" ? ` ${color.installed(`[${condition}]`)}` : "";
+    const status = targetType === "file"
+      ? record.targetExists === true
+        ? color.installed("[ok]")
+        : color.provider("[missing]")
+      : targetType === "pattern"
+        ? color.dim("[pattern]")
+        : color.dim("[external]");
+    const showTarget = shouldShowPackageExportTarget({ subpath, target, targetType });
+    const targetSuffix = showTarget ? ` -> ${color.item(target)}` : "";
+    const subpathLabel = options.details ? color.white(subpath) : color.item(subpath);
+    stdout.write(`- ${subpathLabel}${conditionSuffix}${targetSuffix} ${status}\n`);
+
+    if (!options.details) {
+      continue;
+    }
+    if (targetType !== "file" || !target.startsWith("./")) {
+      continue;
+    }
+
+    const normalizedTarget = normalizeRelativePosixPath(target.slice(2));
+    const summary = ensureObject(exportedSymbolsByFile.get(normalizedTarget));
+    if (!summary || Object.keys(summary).length < 1) {
+      continue;
+    }
+
+    const detailKey = `${subpath}::${normalizedTarget}`;
+    if (symbolDetailsShown.has(detailKey)) {
+      continue;
+    }
+    symbolDetailsShown.add(detailKey);
+
+    const symbols = ensureArray(summary.symbols).map((value) => String(value)).filter(Boolean);
+    const classifiedSymbols = classifyExportedSymbols(symbols);
+    writeClassifiedSymbols({
+      label: "providers",
+      entries: classifiedSymbols.providers,
+      stdout,
+      color,
+      wrapWidth,
+      writeWrappedItems
+    });
+    writeClassifiedSymbols({
+      label: "functions/helpers",
+      entries: classifiedSymbols.functions,
+      stdout,
+      color,
+      wrapWidth,
+      writeWrappedItems
+    });
+    writeClassifiedSymbols({
+      label: "constants",
+      entries: classifiedSymbols.constants,
+      stdout,
+      color,
+      wrapWidth,
+      writeWrappedItems
+    });
+    writeClassifiedSymbols({
+      label: "classes/types",
+      entries: classifiedSymbols.classesOrTypes,
+      stdout,
+      color,
+      wrapWidth,
+      writeWrappedItems
+    });
+    writeClassifiedSymbols({
+      label: "internal/test hooks",
+      entries: classifiedSymbols.internals,
+      stdout,
+      color,
+      wrapWidth,
+      writeWrappedItems
+    });
+    writeClassifiedSymbols({
+      label: "other symbols",
+      entries: classifiedSymbols.others,
+      stdout,
+      color,
+      wrapWidth,
+      writeWrappedItems
+    });
+
+    if (summary.hasDefaultExport === true) {
+      stdout.write(`  ${color.installed("default export: yes")}\n`);
+    }
+    const starReExports = ensureArray(summary.starReExports).map((value) => String(value)).filter(Boolean);
+    const namedReExports = ensureArray(summary.namedReExports).map((value) => String(value)).filter(Boolean);
+    const reExportSummary = [];
+    if (namedReExports.length > 0) {
+      reExportSummary.push(`named from ${namedReExports.length} files`);
+    }
+    if (starReExports.length > 0) {
+      reExportSummary.push(`star from ${starReExports.length} files`);
+    }
+    if (options.debugExports && reExportSummary.length > 0) {
+      stdout.write(`  ${color.dim(`re-export sources: ${reExportSummary.join(", ")}`)}\n`);
+    }
+
+    if (options.debugExports && starReExports.length > 0) {
+      writeWrappedItems({
+        stdout,
+        heading: `  ${color.installed(`star re-exports (${starReExports.length}):`)}`,
+        lineIndent: "    ",
+        wrapWidth,
+        items: starReExports.map((specifier) => ({
+          text: specifier,
+          rendered: color.item(specifier)
+        }))
+      });
+    }
+    if (options.debugExports && namedReExports.length > 0) {
+      writeWrappedItems({
+        stdout,
+        heading: `  ${color.installed(`named re-exports (${namedReExports.length}):`)}`,
+        lineIndent: "    ",
+        wrapWidth,
+        items: namedReExports.map((specifier) => ({
+          text: specifier,
+          rendered: color.item(specifier)
+        }))
+      });
+    }
+  }
+}
+
+function writeClassifiedSymbols({
+  label,
+  entries,
+  stdout,
+  color,
+  wrapWidth,
+  writeWrappedItems
+} = {}) {
+  const items = ensureArray(entries).map((entry) => String(entry || "").trim()).filter(Boolean);
+  if (items.length < 1) {
+    return;
+  }
+  writeWrappedItems({
+    stdout,
+    heading: `  ${color.installed(`${label} (${items.length}):`)}`,
+    lineIndent: "    ",
+    wrapWidth,
+    items: items.map((symbol) => ({
+      text: symbol,
+      rendered: color.item(symbol)
+    }))
+  });
+}
+
+export {
+  writePackageExportsSection
+};