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

package/dist/packem_chunks/handler15.js

@@ -0,0 +1,206 @@
+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 {
+  execSync
+} = __cjs_getBuiltinModule("node:child_process");
+const {
+  createInterface
+} = __cjs_getBuiltinModule("node:readline");
+import { isAccessibleSync, writeFileSync } from '@visulima/fs';
+import { join } from '@visulima/path';
+import { findVisConfigFile } from './applyDefaults.js';
+import { c as detectPm, p as pail, s as scanUnapprovedBuildScripts, e as syncAllowBuildsToNativeConfig } from './bin.js';
+
+const detectExistingTools = (cwd) => {
+  const found = [];
+  if (isAccessibleSync(join(cwd, "turbo.json"))) {
+    found.push("turborepo");
+  }
+  if (isAccessibleSync(join(cwd, "nx.json"))) {
+    found.push("nx");
+  }
+  if (isAccessibleSync(join(cwd, ".moon"))) {
+    found.push("moon");
+  }
+  return found;
+};
+const ask = (rl, question) => new Promise((resolve) => {
+  rl.question(question, (answer) => {
+    resolve(answer.trim());
+  });
+});
+const confirm = async (rl, question, defaultYes = true) => {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await ask(rl, `${question} ${hint} `);
+  if (answer === "") {
+    return defaultYes;
+  }
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+};
+const generateConfigContent = (_pm, options) => {
+  const sections = [];
+  const allowBuildsEntries = Object.entries(options.allowBuilds).filter(([, v]) => v).map(([k]) => `            "${k}": true,`).join("\n");
+  const allowBuildsBlock = allowBuildsEntries ? `{
+${allowBuildsEntries}
+        }` : "{}";
+  let securityBlock = `        allowBuilds: ${allowBuildsBlock},`;
+  if (options.enableSocket) {
+    securityBlock += `
+        socket: { enabled: true },`;
+  }
+  sections.push(`    security: {
+${securityBlock}
+    },`);
+  if (options.staged) {
+    sections.push(`    staged: {
+        "*.{ts,tsx}": "eslint --fix",
+        "*.{ts,tsx,js,jsx,json,md}": "prettier --write",
+    },`);
+  }
+  return `import { defineConfig } from "@visulima/vis/config";
+
+export default defineConfig({
+${sections.join("\n\n")}
+});
+`;
+};
+const runInteractiveInit = async (cwd, pm, configPath) => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  pail.info("\n  vis init — interactive setup\n");
+  const enableSocket = await confirm(rl, "  Enable Socket.dev security scanning?");
+  if (enableSocket) {
+    pail.success("    Socket.dev enabled — scores, alerts, and supply chain data active.");
+    if (!process.env.VIS_SOCKET_TOKEN) {
+      pail.notice("    Set VIS_SOCKET_TOKEN for a custom API token (optional).");
+    }
+  }
+  pail.info("");
+  const scanBuilds = await confirm(rl, "  Scan for packages with build scripts?");
+  const allowBuilds = {};
+  if (scanBuilds) {
+    pail.info("    Scanning node_modules...");
+    const unapproved = scanUnapprovedBuildScripts(cwd, {});
+    if (unapproved.length > 0) {
+      pail.info(`    Found ${String(unapproved.length)} package${unapproved.length === 1 ? "" : "s"} with build scripts:
+`);
+      for (const pkg of unapproved) {
+        const answer = await confirm(rl, `    Allow ${pkg}?`, false);
+        const pkgName = pkg.split(" (")[0] ?? pkg;
+        allowBuilds[pkgName] = answer;
+        if (answer) {
+          pail.success(`      ✓ ${pkgName} approved`);
+        }
+      }
+    } else {
+      pail.info("    No packages with build scripts found.");
+    }
+  }
+  pail.info("");
+  const setupStaged = await confirm(rl, "  Set up pre-commit hooks (lint-staged)?", false);
+  let syncNative = false;
+  if (pm.name === "pnpm" || pm.name === "yarn" || pm.name === "npm" || pm.name === "bun") {
+    pail.info("");
+    syncNative = await confirm(rl, `  Sync security settings to ${pm.name} config?`);
+  }
+  const existingTools = detectExistingTools(cwd);
+  if (existingTools.length > 0) {
+    pail.info("");
+    pail.info(`  Detected existing tools: ${existingTools.join(", ")}`);
+    const shouldMigrate = await confirm(rl, `  Run \`vis migrate\` for ${existingTools.join(", ")}?`, false);
+    if (shouldMigrate) {
+      rl.close();
+      const execPrefix = pm.name === "pnpm" ? "pnpm exec" : pm.name === "yarn" ? "yarn exec" : pm.name === "bun" ? "bunx" : "npx";
+      for (const tool of existingTools) {
+        pail.info(`    Migrating from ${tool}...`);
+        try {
+          execSync(`${execPrefix} vis migrate ${tool}`, {
+            cwd,
+            stdio: "inherit"
+          });
+        } catch {
+          pail.warn(`    Migration from ${tool} had issues — run \`vis migrate ${tool}\` manually.`);
+        }
+      }
+      if (isAccessibleSync(configPath)) {
+        pail.success(`Migrated config written to ${configPath}`);
+      } else {
+        const content2 = generateConfigContent(pm.name, { allowBuilds, enableSocket, staged: setupStaged });
+        writeFileSync(configPath, content2);
+        pail.success(`Created ${configPath}`);
+      }
+      pail.notice("  Run 'vis doctor' to see your project's full health status.");
+      return;
+    }
+  }
+  rl.close();
+  pail.info("");
+  const content = generateConfigContent(pm.name, { allowBuilds, enableSocket, staged: setupStaged });
+  writeFileSync(configPath, content);
+  pail.success(`Created ${configPath}`);
+  if (syncNative) {
+    const approvedBuilds = Object.fromEntries(Object.entries(allowBuilds).filter(([, v]) => v));
+    const actions = syncAllowBuildsToNativeConfig(pm.name, cwd, approvedBuilds);
+    for (const action of actions) {
+      pail.success(`  ${action}`);
+    }
+  }
+  pail.info("");
+  pail.info("  Setup complete. Your config:");
+  pail.info(`    Security:     ${enableSocket ? "Socket.dev enabled" : "defaults only"}`);
+  pail.info(`    Build scripts: ${Object.values(allowBuilds).filter(Boolean).length} approved`);
+  pail.info(`    Git hooks:    ${setupStaged ? "lint-staged configured" : "not configured"}`);
+  pail.info(`    PM sync:      ${syncNative ? "done" : "skipped"}`);
+  pail.info("");
+  pail.notice("  Run 'vis doctor' to see your project's full health status.");
+  pail.info("");
+};
+const runStaticInit = (cwd, pm, options, configPath) => {
+  const content = generateConfigContent(pm.name, { allowBuilds: {}, enableSocket: false, staged: false });
+  writeFileSync(configPath, content);
+  pail.success(`Created ${configPath}`);
+  pail.info("  Secure defaults applied automatically by defineConfig().");
+  if (options.syncNative) {
+    const actions = syncAllowBuildsToNativeConfig(pm.name, cwd, {});
+    for (const action of actions) {
+      pail.success(`  ${action}`);
+    }
+  }
+  pail.info("");
+  pail.notice("Run 'vis doctor' for a full health check, or 'vis init' in a terminal for guided setup.");
+};
+const execute = async ({ options, workspaceRoot: wsRoot }) => {
+  const cwd = wsRoot ?? process.cwd();
+  const pm = detectPm(cwd);
+  const existingConfig = findVisConfigFile(cwd);
+  if (existingConfig && !options.force) {
+    pail.warn(`Config already exists: ${existingConfig}`);
+    pail.notice("Use --force to overwrite, or edit the existing file.");
+    return;
+  }
+  const configPath = existingConfig ?? join(cwd, "vis.config.ts");
+  const isTTY = Boolean(process.stdin.isTTY) && options.interactive !== false;
+  if (isTTY && !options.noInteractive) {
+    await runInteractiveInit(cwd, pm, configPath);
+  } else {
+    runStaticInit(cwd, pm, options, configPath);
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler16.js

@@ -0,0 +1,124 @@
+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 {
+  rmSync
+} = __cjs_getBuiltinModule("node:fs");
+import { isAccessibleSync } from '@visulima/fs';
+import { join, dirname, parse } from '@visulima/path';
+import { p as pail, c as detectPm, r as resolveInstaller, w as detectLockfileDrift, x as runInstall } from './bin.js';
+import { s as scanDepsForTyposquats } from '../packem_shared/typosquats-C-bCh3PX.js';
+import { t as toStringArray } from '../packem_shared/utils-CthVdBPS.js';
+
+const LOCKFILE_NAMES = ["pnpm-lock.yaml", "yarn.lock", "package-lock.json", "npm-shrinkwrap.json", "bun.lock", "bun.lockb"];
+const hasLockfile = (start) => {
+  let dir = start;
+  while (true) {
+    for (const name of LOCKFILE_NAMES) {
+      if (isAccessibleSync(join(dir, name))) {
+        return true;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir || parse(dir).root === dir) {
+      return false;
+    }
+    dir = parent;
+  }
+};
+const ALLOWED_BACKENDS = /* @__PURE__ */ new Set(["aube", "auto", "bun", "npm", "pnpm", "yarn"]);
+const execute = async ({ logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  const cwd = wsRoot ?? process.cwd();
+  if (!options.noTyposquatCheck) {
+    const shouldContinue = await scanDepsForTyposquats(cwd, visConfig?.security?.typosquatAllowlist);
+    if (!shouldContinue) {
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const flagBackendRaw = options.installer;
+  if (flagBackendRaw && !ALLOWED_BACKENDS.has(flagBackendRaw)) {
+    pail.error(`Invalid --installer value: "${flagBackendRaw}". Expected one of: ${[...ALLOWED_BACKENDS].join(", ")}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const flagBackend = flagBackendRaw;
+  const noAube = options.noAube || false;
+  let pm;
+  try {
+    pm = noAube ? detectPm(cwd) : resolveInstaller(cwd, { backend: flagBackend, configBackend: visConfig?.install?.backend });
+  } catch (error) {
+    pail.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+  const driftWarning = detectLockfileDrift(cwd, pm);
+  if (driftWarning) {
+    pail.warn(driftWarning);
+  }
+  const filters = toStringArray(options.filter);
+  const ciMode = options.ci || false;
+  const explicitFrozen = options.frozenLockfile || ciMode;
+  const optedOutOfFrozen = options.noFrozenLockfile || options.force || options.lockfileOnly;
+  const lockfilePresent = hasLockfile(cwd);
+  const shouldFreeze = explicitFrozen || !optedOutOfFrozen && lockfilePresent;
+  if (!explicitFrozen && shouldFreeze && !options.silent) {
+    pail.info("Defaulting to frozen lockfile (pass --no-frozen-lockfile to allow lockfile updates).");
+  }
+  if (ciMode) {
+    pail.info("Clean install: removing node_modules...");
+    try {
+      rmSync(join(cwd, "node_modules"), { force: true, recursive: true });
+    } catch (error) {
+      pail.error(`Failed to remove node_modules: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+  const code = runInstall(
+    pm,
+    {
+      dev: options.dev || false,
+      filter: filters,
+      force: options.force || false,
+      frozenLockfile: shouldFreeze,
+      // Block-by-default lifecycle scripts (mirrors pnpm v10).
+      // Allowlisted packages from `security.allowBuilds` are executed
+      // post-install by the `security-enforcement` plugin's
+      // afterCommand hook (`runApprovedScripts`). The escape hatch
+      // is `--run-scripts`, which restores the PM's native behavior.
+      ignoreScripts: !options.runScripts,
+      lockfileOnly: options.lockfileOnly || false,
+      noOptional: options.noOptional || false,
+      offline: options.offline || false,
+      prod: options.prod || false,
+      recursive: options.recursive || false,
+      silent: options.silent || false,
+      workspaceRoot: options.workspaceRoot || false
+    },
+    cwd,
+    logger,
+    { preferOffline: options.preferOffline || false }
+  );
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler17.js

@@ -0,0 +1,13 @@
+import { r as resolveInstaller, y as runLink } from './bin.js';
+
+const execute = async ({ argument, logger, visConfig, workspaceRoot: wsRoot }) => {
+  const target = argument?.[0] ?? null;
+  const cwd = wsRoot ?? process.cwd();
+  const pm = resolveInstaller(cwd, { configBackend: visConfig?.install?.backend });
+  const code = runLink(pm, target, cwd, logger);
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler18.js

@@ -0,0 +1,106 @@
+import { d as discoverWorkspace } from './bin.js';
+import { f as filterProjectsByQuery } from '../packem_shared/selectors-SM69TfqC.js';
+
+const execute = async ({ logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  if (!wsRoot) {
+    throw new Error("Could not determine workspace root.");
+  }
+  const { projectOptions, workspace } = discoverWorkspace(wsRoot, visConfig);
+  let projectNames = Object.keys(workspace.projects).sort();
+  if (options.query) {
+    projectNames = filterProjectsByQuery(projectNames, workspace, options.query);
+  }
+  if (projectNames.length === 0) {
+    logger.info("No projects found.");
+    return;
+  }
+  const inferredOnly = options.inferred === true;
+  const showTargets = options.targets === true || inferredOnly;
+  if (options.json) {
+    const data = projectNames.map((name) => {
+      const project = workspace.projects[name];
+      const visTargets = projectOptions.get(name) ?? {};
+      const targets = Object.entries(project.targets ?? {}).map(([targetName]) => {
+        const visTarget = visTargets[targetName];
+        const isInferred = visTarget?.inferred === true;
+        return {
+          aliases: visTarget?.aliases ?? [],
+          command: visTarget?.command,
+          description: visTarget?.description,
+          // Only emit the field when it's true — keeps the JSON
+          // shape additive instead of breaking downstream
+          // consumers that didn't know about `inferred` yet.
+          ...isInferred ? { inferred: true } : {},
+          name: targetName,
+          type: visTarget?.type
+        };
+      }).filter((target) => !inferredOnly || target.inferred === true);
+      return {
+        language: project.language,
+        layer: project.layer,
+        name,
+        root: project.root,
+        stack: project.stack,
+        tags: project.tags ?? [],
+        targets,
+        type: project.projectType ?? "library"
+      };
+    });
+    logger.info(JSON.stringify(data, null, 2));
+    return;
+  }
+  const renderTable = (header2, rows2) => {
+    const widths = header2.map((h, i) => {
+      const maxData = rows2.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+      return Math.max(h.length, maxData);
+    });
+    const pad = (str, w) => str.padEnd(w);
+    logger.info(header2.map((h, i) => pad(h, widths[i])).join("  "));
+    logger.info(widths.map((w) => "─".repeat(w)).join("──"));
+    for (const row of rows2) {
+      logger.info(row.map((cell, i) => pad(cell, widths[i])).join("  "));
+    }
+  };
+  if (showTargets) {
+    const targetRows = [];
+    for (const name of projectNames) {
+      const project = workspace.projects[name];
+      const visTargets = projectOptions.get(name) ?? {};
+      for (const targetName of Object.keys(project.targets ?? {}).sort()) {
+        const visTarget = visTargets[targetName];
+        const isInferred = visTarget?.inferred === true;
+        if (inferredOnly && !isInferred) {
+          continue;
+        }
+        const targetConfig = project.targets?.[targetName];
+        const cache = targetConfig?.cache === false ? "no" : targetConfig?.cache === true ? "yes" : "default";
+        targetRows.push([name, targetName, visTarget?.type ?? "—", cache, isInferred ? "yes" : "no", visTarget?.description ?? "—"]);
+      }
+    }
+    if (targetRows.length === 0) {
+      logger.info(inferredOnly ? "No inferred targets found." : "No targets found.");
+      return;
+    }
+    renderTable(["Project", "Target", "Type", "Cache", "Inferred", "Description"], targetRows);
+    logger.info("");
+    logger.info(`${String(targetRows.length)} target(s) across ${String(projectNames.length)} project(s)`);
+    return;
+  }
+  const header = ["Project", "Type", "Layer", "Tags", "Targets"];
+  const rows = projectNames.map((name) => {
+    const project = workspace.projects[name];
+    const targets = Object.keys(project.targets ?? {});
+    return [
+      name,
+      project.projectType ?? "library",
+      project.layer ?? "—",
+      (project.tags ?? []).join(", ") || "—",
+      targets.length > 4 ? `${targets.slice(0, 4).join(", ")}… (${String(targets.length)})` : targets.join(", ") || "—"
+    ];
+  });
+  renderTable(header, rows);
+  logger.info("");
+  logger.info(`${String(projectNames.length)} project(s)`);
+};
+
+export { execute as default };

package/dist/packem_chunks/handler19.js

@@ -0,0 +1,19 @@
+import { r as resolveInstaller, z as runPmSubcommand } from './bin.js';
+
+const execute = async ({ argument, logger, visConfig, workspaceRoot: wsRoot }) => {
+  const args = argument;
+  if (!args || args.length === 0) {
+    throw new Error(
+      "No subcommand specified. Available: cache, publish, audit, list, view, config, whoami, login, logout, pack, owner, dist-tag, search, fund, ping, token, deprecate, rebuild, prune"
+    );
+  }
+  const [subcommand, ...rest] = args;
+  const cwd = wsRoot ?? process.cwd();
+  const pm = resolveInstaller(cwd, { configBackend: visConfig?.install?.backend });
+  const code = runPmSubcommand(pm, subcommand, rest, cwd, logger);
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler2.js

@@ -0,0 +1,75 @@
+import { getAffectedProjects } from '@visulima/task-runner';
+import { d as discoverWorkspace, b as buildProjectGraph } from './bin.js';
+import { f as filterProjectsByQuery } from '../packem_shared/selectors-SM69TfqC.js';
+
+const execute = async ({ argument, logger, options, runtime, visConfig, workspaceRoot: wsRoot }) => {
+  const target = argument[0];
+  if (!target) {
+    throw new Error("Missing target. Usage: vis affected <target>");
+  }
+  if (!wsRoot) {
+    throw new Error("Could not determine workspace root. Run this command inside a monorepo.");
+  }
+  const workspaceRoot = wsRoot;
+  const { packageJsons, workspace } = discoverWorkspace(workspaceRoot, visConfig);
+  const projectGraph = buildProjectGraph(workspaceRoot, workspace, packageJsons);
+  const validScopes = /* @__PURE__ */ new Set(["deep", "direct", "none"]);
+  const downstreamValue = options.downstream ?? "deep";
+  const upstreamValue = options.upstream ?? "none";
+  if (!validScopes.has(downstreamValue)) {
+    throw new Error(`Invalid --downstream value: "${downstreamValue}". Must be "none", "direct", or "deep".`);
+  }
+  if (!validScopes.has(upstreamValue)) {
+    throw new Error(`Invalid --upstream value: "${upstreamValue}". Must be "none", "direct", or "deep".`);
+  }
+  const affectedOptions = {
+    base: options.base,
+    downstream: downstreamValue,
+    head: options.head,
+    projectGraph,
+    projects: workspace.projects,
+    upstream: upstreamValue,
+    workspaceRoot
+  };
+  const result = await getAffectedProjects(affectedOptions);
+  if (result.changedFiles.length === 0) {
+    logger.info("No files changed. Nothing to run.");
+    return;
+  }
+  if (result.affectedProjects.length === 0) {
+    logger.info("No projects affected by the changes.");
+    return;
+  }
+  let { affectedProjects } = result;
+  if (options.query) {
+    affectedProjects = filterProjectsByQuery(affectedProjects, workspace, options.query);
+    if (affectedProjects.length === 0) {
+      logger.info(`Query "${String(options.query)}" matched no affected projects.`);
+      return;
+    }
+  }
+  logger.info(`Affected projects: ${affectedProjects.join(", ")}`);
+  if (result.changedFiles.length > 0) {
+    process.env["VIS_AFFECTED_FILES"] = result.changedFiles.join("\n");
+  }
+  const argv = [target, `--projects=${affectedProjects.join(",")}`];
+  if (options.parallel !== void 0) {
+    argv.push(`--parallel=${String(options.parallel)}`);
+  }
+  if (!options.cache) {
+    argv.push("--no-cache");
+  }
+  if (options.dryRun) {
+    argv.push("--dry-run");
+  }
+  if (options.partition) {
+    argv.push(`--partition=${String(options.partition)}`);
+  }
+  try {
+    await runtime.runCommand("run", { argv });
+  } finally {
+    delete process.env["VIS_AFFECTED_FILES"];
+  }
+};
+
+export { execute as default };

package/dist/packem_chunks/handler20.js

@@ -0,0 +1,29 @@
+import { r as resolveInstaller, A as runRemove } from './bin.js';
+import { t as toStringArray } from '../packem_shared/utils-CthVdBPS.js';
+
+const execute = async ({ argument, logger, options, visConfig, workspaceRoot: wsRoot }) => {
+  const packages = argument;
+  if (!packages || packages.length === 0) {
+    throw new Error("No packages specified. Usage: vis remove <packages...>");
+  }
+  const cwd = process.cwd();
+  const pm = resolveInstaller(wsRoot ?? cwd, { configBackend: visConfig?.install?.backend });
+  const code = runRemove(
+    pm,
+    {
+      filter: toStringArray(options.filter),
+      global: options.global || false,
+      packages,
+      recursive: options.recursive || false,
+      saveDev: options.saveDev || false,
+      workspaceRoot: options.workspaceRoot || false
+    },
+    cwd,
+    logger
+  );
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+};
+
+export { execute as default };