@visulima/vis 1.0.0-alpha.1 → 1.0.0-alpha.11

package/dist/packem_chunks/handler5.js

@@ -0,0 +1,174 @@
+import { findPackageManagerSync } from '@visulima/package';
+import { render, renderToString, Text } from '@visulima/tui';
+import { c as detectPm, g as printSecurityReport, h as previewPnpmSync, p as pail, i as isInCi, j as scoreColor, a as buildSocketOptions } from './bin.js';
+import React from 'react';
+import { v as validateAnalysisType, r as runAiAnalysis, f as formatAiAnalysis } from '../packem_shared/ai-analysis-CHeB1joD.js';
+import { U as UpdateStore, V as VisUpdateApp, C as CheckProgressApp } from '../packem_shared/VisUpdateApp-D-Yz_wvg.js';
+import { l as loadNpmrc, r as readCatalogs, c as checkOutdated, b as formatSummary, d as formatOutdatedMinimal, h as formatOutdatedTable, t as toFilterArray } from '../packem_shared/catalog-BJTtyi-O.js';
+
+const execute = async ({ argument, logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  if (!wsRoot) {
+    throw new Error("Could not determine workspace root. Run this command inside a monorepo.");
+  }
+  const workspaceRoot = wsRoot;
+  if (options.securityConfig) {
+    const pm = detectPm(workspaceRoot);
+    printSecurityReport(visConfig ?? {}, pm.name);
+    if (options.sync && pm.name === "pnpm") {
+      const synced = previewPnpmSync(visConfig ?? {});
+      if (synced.length > 0) {
+        pail.info("\nSettings that would sync to pnpm-workspace.yaml:");
+        for (const s of synced) {
+          pail.success(`  ${s}`);
+        }
+      } else {
+        pail.info("No security settings to sync.");
+      }
+    } else if (options.sync && pm.name !== "pnpm") {
+      pail.info(`--sync is only available for pnpm projects. Your project uses ${pm.name}.`);
+      pail.info("vis enforces security settings at the vis layer for non-pnpm projects.");
+    }
+    if (!options.security && !argument?.length) {
+      return;
+    }
+  }
+  const { packageManager } = findPackageManagerSync(workspaceRoot);
+  const npmrcConfig = loadNpmrc(workspaceRoot);
+  const configDefaults = visConfig?.update ?? {};
+  const catalogs = readCatalogs(workspaceRoot, packageManager, {
+    dev: options.dev,
+    prod: options.prod
+  });
+  if (catalogs.size === 0) {
+    logger.info("No catalogs found.");
+    return;
+  }
+  const target = options.target ?? configDefaults.target ?? "latest";
+  if (!["latest", "minor", "patch"].includes(target)) {
+    throw new Error(`Invalid target "${target}". Use: latest, minor, or patch.`);
+  }
+  const checkOptions = {
+    exclude: [...toFilterArray(options.exclude), ...toFilterArray(configDefaults.exclude)],
+    ignore: toFilterArray(configDefaults.ignore),
+    include: [...toFilterArray(options.include), ...toFilterArray(configDefaults.include), ...argument],
+    includeLocked: Boolean(options.includeLocked),
+    includePrerelease: options.prerelease || configDefaults.prerelease || false,
+    security: !options.noSecurity,
+    target
+  };
+  let totalDeps = 0;
+  for (const deps of catalogs.values()) {
+    totalDeps += deps.size;
+  }
+  const isTTY = Boolean(process.stdout.isTTY) && !isInCi;
+  let progressInstance;
+  const onProgress = isTTY ? (current, total) => {
+    if (progressInstance) {
+      progressInstance.rerender(React.createElement(CheckProgressApp, { current, total }));
+    } else {
+      progressInstance = render(React.createElement(CheckProgressApp, { current, total }), {
+        interactive: true,
+        patchConsole: false
+      });
+    }
+  } : (current, total) => {
+    logger.info(`Checking ${String(current)}/${String(total)} dependencies...`);
+  };
+  if (!isTTY) {
+    logger.info(`Checking ${String(totalDeps)} catalog dependencies against npm registry...
+`);
+  }
+  const socketOptions = buildSocketOptions(visConfig?.security?.socket);
+  const { failed, outdated } = await checkOutdated(
+    catalogs,
+    checkOptions,
+    npmrcConfig,
+    onProgress,
+    workspaceRoot,
+    socketOptions,
+    visConfig?.security?.socket?.acceptedRisks
+  );
+  if (progressInstance) {
+    progressInstance.clear();
+    progressInstance.unmount();
+  }
+  if (failed.length > 0) {
+    logger.warn(`Failed to fetch: ${failed.join(", ")}`);
+  }
+  if (outdated.length === 0) {
+    logger.info("All catalog dependencies are up to date.");
+    return;
+  }
+  const format = options.format ?? configDefaults.format ?? "table";
+  const analysisType = validateAnalysisType(options.aiType ?? "impact");
+  const aiResult = options.ai ? await runAiAnalysis(outdated, logger, visConfig?.ai, analysisType) : void 0;
+  if (isTTY && format === "table") {
+    const store = new UpdateStore(outdated, aiResult ?? null);
+    const autoExitConfig = visConfig?.tui?.autoExit ?? false;
+    const autoExitSeconds = autoExitConfig === true ? 3 : typeof autoExitConfig === "number" ? autoExitConfig : 0;
+    const instance = render(
+      React.createElement(VisUpdateApp, {
+        autoExitSeconds,
+        isDryRun: true,
+        store
+      }),
+      {
+        alternateScreen: true,
+        exitOnCtrlC: false,
+        interactive: true,
+        patchConsole: true
+      }
+    );
+    await instance.waitUntilExit();
+    const columns = process.stdout.columns || 80;
+    process.stdout.write("\n");
+    for (const entry of outdated) {
+      const hasSecurityIssue = entry.vulnerabilities?.length || entry.socketReport && entry.socketReport.alerts.length > 0;
+      const isAck = Boolean(entry.acceptedRisk);
+      const icon = hasSecurityIssue ? isAck ? "✓" : "⚠" : "✓";
+      const iconColor = isAck ? "gray" : entry.updateType === "major" ? "red" : entry.updateType === "minor" ? "yellow" : "green";
+      const socketOverall = entry.socketReport?.score.overall;
+      const scoreSuffix = socketOverall === void 0 ? "" : ` [${String(Math.round(socketOverall * 100))}%]`;
+      const socketColorName = socketOverall === void 0 ? void 0 : scoreColor(socketOverall);
+      process.stdout.write(
+        `${renderToString(
+          React.createElement(
+            Text,
+            null,
+            "   ",
+            React.createElement(Text, { color: iconColor }, icon),
+            `  ${entry.packageName}  ${entry.currentRange} → ${entry.newRange}`,
+            React.createElement(Text, { dimColor: true }, `  ${entry.updateType}`),
+            socketColorName ? React.createElement(Text, { color: socketColorName }, scoreSuffix) : null
+          ),
+          { columns }
+        )}
+`
+      );
+    }
+    process.stdout.write("\n");
+    logger.info(formatSummary(outdated));
+  } else if (format === "json") {
+    const output = { failed, outdated };
+    if (aiResult) {
+      output.aiAnalysis = aiResult;
+    }
+    process.stdout.write(`${JSON.stringify(output, void 0, 2)}
+`);
+  } else if (format === "minimal") {
+    process.stdout.write(`${formatOutdatedMinimal(outdated)}
+`);
+  } else {
+    formatOutdatedTable(outdated, logger);
+    logger.info(formatSummary(outdated));
+    if (aiResult) {
+      logger.info("");
+      logger.info(formatAiAnalysis(aiResult));
+    }
+  }
+  if (options.exitCode && outdated.length > 0) {
+    process.exitCode = 1;
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler6.js

@@ -0,0 +1,95 @@
+import { r as runToolchainPreflight } from '../packem_shared/toolchain-BdZd9eBi.js';
+
+const detectCiRefs = () => {
+  if (process.env["GITHUB_BASE_REF"]) {
+    return {
+      base: `origin/${process.env["GITHUB_BASE_REF"]}`,
+      head: process.env["GITHUB_SHA"] ?? "HEAD"
+    };
+  }
+  if (process.env["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"]) {
+    return {
+      base: `origin/${process.env["CI_MERGE_REQUEST_TARGET_BRANCH_NAME"]}`,
+      head: process.env["CI_COMMIT_SHA"] ?? "HEAD"
+    };
+  }
+  if (process.env["BUILDKITE_PULL_REQUEST_BASE_BRANCH"]) {
+    return {
+      base: `origin/${process.env["BUILDKITE_PULL_REQUEST_BASE_BRANCH"]}`,
+      head: process.env["BUILDKITE_COMMIT"] ?? "HEAD"
+    };
+  }
+  if (process.env["CIRCLE_BRANCH"] && process.env["CIRCLE_SHA1"]) {
+    return {
+      base: "origin/main",
+      head: process.env["CIRCLE_SHA1"]
+    };
+  }
+  return { base: "origin/main", head: "HEAD" };
+};
+const execute = async ({ argument, logger, options, runtime, visConfig, workspaceRoot: wsRoot }) => {
+  const rawTargets = argument[0];
+  if (!rawTargets) {
+    throw new Error("Missing targets. Usage: vis ci <target>[,<target>…]");
+  }
+  const targets = rawTargets.split(",").map((t) => t.trim()).filter(Boolean);
+  if (targets.length === 0) {
+    throw new Error("Missing targets. Usage: vis ci <target>[,<target>…]");
+  }
+  if (!wsRoot) {
+    throw new Error("Could not determine workspace root. Run this command inside a monorepo.");
+  }
+  const { base: defaultBase, head: defaultHead } = detectCiRefs();
+  const base = options.base ?? defaultBase;
+  const head = options.head ?? defaultHead;
+  if (!options.skipToolchain) {
+    logger.info("▸ Toolchain pre-flight");
+  }
+  await runToolchainPreflight(
+    wsRoot,
+    visConfig?.toolchain,
+    {
+      error: (message) => {
+        logger.error(message);
+      },
+      info: (message) => {
+        logger.info(message);
+      },
+      warn: (message) => {
+        logger.warn(message);
+      }
+    },
+    Boolean(options.skipToolchain)
+  );
+  if (options.install === false) {
+    logger.info("▸ Skipping install (--no-install)");
+  } else {
+    logger.info("▸ Installing dependencies");
+    await runtime.runCommand("install", {
+      argv: ["--frozen-lockfile"]
+    });
+  }
+  for (const target of targets) {
+    logger.info(`▸ Running affected ${target} (base=${base}, head=${head})`);
+    const argv = [
+      target,
+      `--base=${base}`,
+      `--head=${head}`,
+      `--upstream=${String(options.upstream ?? "none")}`,
+      `--downstream=${String(options.downstream ?? "deep")}`
+    ];
+    if (options.parallel !== void 0) {
+      argv.push(`--parallel=${String(options.parallel)}`);
+    }
+    if (options.partition) {
+      argv.push(`--partition=${String(options.partition)}`);
+    }
+    if (options.query) {
+      argv.push(`--query=${String(options.query)}`);
+    }
+    await runtime.runCommand("affected", { argv });
+  }
+  logger.info("▸ CI pipeline complete");
+};
+
+export { execute as default };

package/dist/packem_chunks/handler7.js

@@ -0,0 +1,115 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  readdirSync,
+  lstatSync
+} = __cjs_getBuiltinModule("node:fs");
+import { isAccessibleSync } from '@visulima/fs';
+import { join } from '@visulima/path';
+import { cleanWorkspace } from '#native';
+import { p as pail } from './bin.js';
+
+const findNodeModulesDirectories = (root) => {
+  const results = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      try {
+        const stat = lstatSync(fullPath);
+        if (stat.isSymbolicLink() || !stat.isDirectory()) {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (entry === "node_modules") {
+        results.push(fullPath);
+      } else if (entry !== ".git" && entry !== ".hg") {
+        stack.push(fullPath);
+      }
+    }
+  }
+  return results;
+};
+const LOCKFILE_NAMES = ["pnpm-lock.yaml", "package-lock.json", "npm-shrinkwrap.json", "yarn.lock", "bun.lock", "bun.lockb"];
+const removeLockfiles = (cwd, dryRun, logger) => {
+  let removed = 0;
+  let hadError = false;
+  for (const name of LOCKFILE_NAMES) {
+    const lockfile = join(cwd, name);
+    if (!isAccessibleSync(lockfile)) {
+      continue;
+    }
+    {
+      logger.info(`  ${lockfile}`);
+      removed++;
+      continue;
+    }
+  }
+  return { hadError, removed };
+};
+const execute = async ({ logger, options, workspaceRoot: wsRoot }) => {
+  const cwd = wsRoot ?? process.cwd();
+  const shouldRemoveLockfile = options.lockfile || false;
+  const dryRun = options.dryRun || false;
+  if (dryRun) {
+    const directories = findNodeModulesDirectories(cwd);
+    if (directories.length > 0) {
+      pail.info("Would remove:");
+      for (const dir of directories) {
+        logger.info(`  ${dir}`);
+      }
+    } else {
+      pail.info("No node_modules directories found.");
+    }
+    if (shouldRemoveLockfile) {
+      removeLockfiles(cwd, true, logger);
+    }
+    return;
+  }
+  const result = cleanWorkspace(cwd, shouldRemoveLockfile);
+  for (const dir of result.removed) {
+    pail.success(`Removed ${dir}`);
+  }
+  for (const file of result.lockfilesRemoved) {
+    pail.success(`Removed ${file}`);
+  }
+  for (const error of result.errors) {
+    pail.error(error);
+  }
+  if (result.removed.length === 0 && result.lockfilesRemoved.length === 0) {
+    pail.info("No node_modules directories found.");
+  } else {
+    pail.info(`Cleaned ${result.removed.length} node_modules director${result.removed.length === 1 ? "y" : "ies"}`);
+  }
+  if (result.errors.length > 0) {
+    process.exitCode = 1;
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler8.js

@@ -0,0 +1,12 @@
+import { r as resolveInstaller, k as runDedupe } from './bin.js';
+
+const execute = async ({ logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  const cwd = wsRoot ?? process.cwd();
+  const pm = resolveInstaller(cwd, { configBackend: visConfig?.install?.backend });
+  const code = runDedupe(pm, options.check || false, cwd, logger);
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler9.js

@@ -0,0 +1,29 @@
+import { r as resolveInstaller, l as runDlx } from './bin.js';
+
+const execute = async ({ argument, logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  const args = argument;
+  if (!args || args.length === 0) {
+    throw new Error("No package specified. Usage: vis dlx <package[@version]> [args...]");
+  }
+  const [pkg, ...rest] = args;
+  const cwd = wsRoot ?? process.cwd();
+  const pm = resolveInstaller(cwd, { configBackend: visConfig?.install?.backend });
+  const additionalPackages = options.package ? Array.isArray(options.package) ? options.package : [options.package] : [];
+  const code = runDlx(
+    pm,
+    {
+      additionalPackages,
+      args: rest,
+      package: pkg,
+      shellMode: options.shellMode || false,
+      silent: options.silent || false
+    },
+    cwd,
+    logger
+  );
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+};
+
+export { execute as default };