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

package/dist/packem_shared/dependency-scan-A0KSklpG.js

@@ -0,0 +1,188 @@
+import { dim, yellow, green, red } from '@visulima/colorize';
+import { Box, Text, Spinner, render } from '@visulima/tui';
+import { i as isInCi, S as SYMBOLS } from '../packem_chunks/bin.js';
+import React from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { D as DASH, W as WARNING, T as TICK, C as CROSS } from './symbols-Ta7g2nU-.js';
+import { readFileSync } from '@visulima/fs';
+import { parseLockFileContent } from '@visulima/package';
+import { join } from '@visulima/path';
+
+const ScanProgressApp = ({ rows }) => jsx(Box, { flexDirection: "column", children: rows.map((row) => {
+  let icon;
+  switch (row.status) {
+    case "error": {
+      icon = jsx(Text, { color: "red", children: CROSS });
+      break;
+    }
+    case "ok": {
+      icon = jsx(Text, { color: "green", children: TICK });
+      break;
+    }
+    case "running": {
+      icon = jsx(Text, { color: "white", children: jsx(Spinner, { type: "dots" }) });
+      break;
+    }
+    case "warn": {
+      icon = jsx(Text, { color: "yellow", children: WARNING });
+      break;
+    }
+    default: {
+      icon = jsx(Text, { dimColor: true, children: DASH });
+      break;
+    }
+  }
+  return jsxs(Box, { children: [
+    jsx(Box, { width: 3, children: icon }),
+    jsx(Box, { flexGrow: 1, children: jsx(Text, { children: row.label }) }),
+    row.summary ? jsx(Box, { children: jsxs(Text, { dimColor: true, children: [
+      DASH,
+      " ",
+      row.summary
+    ] }) }) : null
+  ] }, row.id);
+}) });
+
+const STATIC_GLYPH = {
+  error: red(SYMBOLS.failure),
+  ok: green(SYMBOLS.success),
+  pending: dim(SYMBOLS.dash),
+  skip: dim(SYMBOLS.dash),
+  warn: yellow(SYMBOLS.warning)
+};
+const formatStaticRow = (label, status, summary) => {
+  const text = summary ? `${label} ${dim(`— ${summary}`)}` : label;
+  return `  ${STATIC_GLYPH[status]} ${text}
+`;
+};
+const startScanProgress = (tasks, options = {}) => {
+  const stream = options.stream ?? process.stderr;
+  const isTty = typeof stream.isTTY === "boolean" && stream.isTTY;
+  const liveDefault = isTty && !isInCi;
+  const live = options.live ?? liveDefault;
+  const states = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    states.set(task.id, { id: task.id, label: task.label, status: "pending" });
+  }
+  if (!live || tasks.length === 0) {
+    return {
+      finish: (id, status, summary) => {
+        const state = states.get(id);
+        if (!state) {
+          return;
+        }
+        states.set(id, { ...state, status, summary });
+        stream.write(formatStaticRow(state.label, status, summary));
+      },
+      start: (id) => {
+        const state = states.get(id);
+        if (state) {
+          states.set(id, { ...state, status: "running" });
+        }
+      },
+      stop: () => {
+      }
+    };
+  }
+  const buildRows = () => tasks.map((task) => states.get(task.id));
+  let instance = render(React.createElement(ScanProgressApp, { rows: buildRows() }), {
+    interactive: true,
+    patchConsole: false
+  });
+  const rerender = () => {
+    instance?.rerender(React.createElement(ScanProgressApp, { rows: buildRows() }));
+  };
+  return {
+    finish: (id, status, summary) => {
+      const state = states.get(id);
+      if (!state) {
+        return;
+      }
+      states.set(id, { ...state, status, summary });
+      rerender();
+    },
+    start: (id) => {
+      const state = states.get(id);
+      if (!state) {
+        return;
+      }
+      states.set(id, { ...state, status: "running" });
+      rerender();
+    },
+    stop: () => {
+      if (!instance) {
+        return;
+      }
+      rerender();
+      instance.unmount();
+      instance = void 0;
+    }
+  };
+};
+
+const LOCKFILE_NAMES = {
+  bun: { file: "bun.lock", type: "bun" },
+  npm: { file: "package-lock.json", type: "npm" },
+  pnpm: { file: "pnpm-lock.yaml", type: "pnpm" },
+  yarn: { file: "yarn.lock", type: "yarn" }
+};
+const lockedPackages = (workspaceRoot, pmName) => {
+  const lockInfo = LOCKFILE_NAMES[pmName];
+  if (!lockInfo) {
+    return [];
+  }
+  let lockContent;
+  try {
+    lockContent = readFileSync(join(workspaceRoot, lockInfo.file));
+  } catch {
+    return [];
+  }
+  const entries = parseLockFileContent(lockContent, lockInfo.type);
+  if (entries.length === 0) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const packages = [];
+  for (const entry of entries) {
+    const key = `${entry.name}@${entry.version}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    packages.push({ isDev: false, name: entry.name, version: entry.version });
+  }
+  return packages;
+};
+const findDuplicateDependencies = (workspaceRoot, pmName) => {
+  const lockInfo = LOCKFILE_NAMES[pmName];
+  if (!lockInfo) {
+    return [];
+  }
+  let lockContent;
+  try {
+    lockContent = readFileSync(join(workspaceRoot, lockInfo.file));
+  } catch {
+    return [];
+  }
+  const entries = parseLockFileContent(lockContent, lockInfo.type);
+  if (entries.length === 0) {
+    return [];
+  }
+  const versionMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!versionMap.has(entry.name)) {
+      versionMap.set(entry.name, /* @__PURE__ */ new Set());
+    }
+    versionMap.get(entry.name).add(entry.version);
+  }
+  const duplicates = [];
+  for (const [name, versions] of versionMap) {
+    if (versions.size <= 1) {
+      continue;
+    }
+    duplicates.push({ name, versions: [...versions] });
+  }
+  return duplicates.sort((a, b) => a.name.localeCompare(b.name));
+};
+
+export { findDuplicateDependencies as f, lockedPackages as l, startScanProgress as s };

package/dist/packem_shared/docker-2iZzc280.js

@@ -0,0 +1,181 @@
+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,
+  cpSync,
+  lstatSync,
+  readdirSync
+} = __cjs_getBuiltinModule("node:fs");
+import { writeFileSync, isAccessibleSync, readJsonSync, ensureDirSync } from '@visulima/fs';
+import { join, relative, dirname } from '@visulima/path';
+
+const collectTransitiveProjectDeps = (start, projectGraph) => {
+  const result = /* @__PURE__ */ new Set();
+  const queue = [start];
+  const visited = /* @__PURE__ */ new Set([start]);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const edges = projectGraph.dependencies[current] ?? [];
+    for (const edge of edges) {
+      if (visited.has(edge.target)) {
+        continue;
+      }
+      visited.add(edge.target);
+      result.add(edge.target);
+      queue.push(edge.target);
+    }
+  }
+  return result;
+};
+const DOCKER_MANIFEST_FILENAME = "vis-docker-manifest.json";
+const MANIFEST_FILES = ["package.json", "project.json"];
+const ROOT_MANIFEST_FILES = [
+  "package.json",
+  "pnpm-workspace.yaml",
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  ".npmrc",
+  "vis.config.ts",
+  "vis.config.mts",
+  "vis.config.cts",
+  "vis.config.js",
+  "vis.config.mjs",
+  "vis.config.cjs"
+];
+const resolveFocusProjects = (focus, projectGraph) => {
+  const result = new Set(focus);
+  for (const name of focus) {
+    const transitive = collectTransitiveProjectDeps(name, projectGraph);
+    for (const dep of transitive) {
+      result.add(dep);
+    }
+  }
+  return result;
+};
+const ensureDir = (path) => {
+  ensureDirSync(path);
+};
+const copyFileIfExists = (src, dest) => {
+  try {
+    ensureDir(dirname(dest));
+    cpSync(src, dest);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+const copyTreeExcludingNodeModules = (src, dest) => {
+  let stats;
+  try {
+    stats = lstatSync(src);
+  } catch {
+    return;
+  }
+  if (stats.isSymbolicLink()) {
+    return;
+  }
+  if (stats.isFile()) {
+    ensureDir(dirname(dest));
+    cpSync(src, dest);
+    return;
+  }
+  ensureDir(dest);
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === ".git" || entry.isSymbolicLink()) {
+      continue;
+    }
+    copyTreeExcludingNodeModules(join(src, entry.name), join(dest, entry.name));
+  }
+};
+const scaffoldDockerContext = (options) => {
+  const { focus, includeSources = false, outDir, projectGraph, workspace, workspaceRoot } = options;
+  const unknown = focus.filter((name) => workspace.projects[name] === void 0);
+  if (unknown.length > 0) {
+    throw new Error(`Unknown focus project(s): ${unknown.join(", ")}. Check project names in your workspace.`);
+  }
+  const projects = resolveFocusProjects(focus, projectGraph);
+  const workspaceDir = join(outDir, "workspace");
+  const sourcesDir = join(outDir, "sources");
+  rmSync(workspaceDir, { force: true, recursive: true });
+  rmSync(sourcesDir, { force: true, recursive: true });
+  ensureDir(workspaceDir);
+  for (const manifest of ROOT_MANIFEST_FILES) {
+    copyFileIfExists(join(workspaceRoot, manifest), join(workspaceDir, manifest));
+  }
+  for (const name of projects) {
+    const project = workspace.projects[name];
+    if (!project?.root) {
+      continue;
+    }
+    for (const manifest of MANIFEST_FILES) {
+      copyFileIfExists(join(workspaceRoot, project.root, manifest), join(workspaceDir, project.root, manifest));
+    }
+  }
+  if (includeSources) {
+    ensureDir(sourcesDir);
+    for (const name of focus) {
+      const project = workspace.projects[name];
+      if (!project?.root) {
+        continue;
+      }
+      copyTreeExcludingNodeModules(join(workspaceRoot, project.root), join(sourcesDir, project.root));
+    }
+  }
+  writeFileSync(join(outDir, DOCKER_MANIFEST_FILENAME), `${JSON.stringify({ focus, projects: [...projects].sort() }, null, 2)}
+`);
+  return { projects: [...projects] };
+};
+const pruneDockerContext = (options) => {
+  const { contextRoot, workspace, workspaceRoot } = options;
+  const manifestPath = join(contextRoot, DOCKER_MANIFEST_FILENAME);
+  if (!isAccessibleSync(manifestPath)) {
+    throw new Error(`No ${DOCKER_MANIFEST_FILENAME} at ${contextRoot}. Run \`vis docker scaffold\` first.`);
+  }
+  const manifest = readJsonSync(manifestPath);
+  if (!Array.isArray(manifest.projects)) {
+    throw new TypeError(`Invalid ${DOCKER_MANIFEST_FILENAME}: "projects" must be an array.`);
+  }
+  const keep = new Set(manifest.projects);
+  const removed = [];
+  for (const [name, project] of Object.entries(workspace.projects)) {
+    if (keep.has(name)) {
+      continue;
+    }
+    if (!project.root) {
+      continue;
+    }
+    const absolute = join(workspaceRoot, project.root);
+    const rel = relative(workspaceRoot, absolute);
+    if (rel === "" || rel === "." || rel.startsWith("..")) {
+      continue;
+    }
+    rmSync(absolute, { force: true, recursive: true });
+    removed.push(rel);
+  }
+  return { removed };
+};
+
+export { pruneDockerContext as p, resolveFocusProjects as r, scaffoldDockerContext as s };

package/dist/packem_shared/failure-log-Cz3Z4SKL.js

@@ -0,0 +1,100 @@
+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 {
+  mkdirSync,
+  writeFileSync,
+  readdirSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  readFile
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { join } from '@visulima/path';
+
+const FAILURE_LOG_DIRNAME = "last-failures";
+const getFailureLogDirectory = (workspaceRoot) => join(workspaceRoot, ".task-runner", FAILURE_LOG_DIRNAME);
+const getFailureLogPath = (workspaceRoot, taskId) => join(getFailureLogDirectory(workspaceRoot), `${encodeURIComponent(taskId)}.json`);
+class FailureLogLifeCycle {
+  #workspaceRoot;
+  #runId;
+  constructor(workspaceRoot, runId) {
+    this.#workspaceRoot = workspaceRoot;
+    this.#runId = runId;
+  }
+  printTaskTerminalOutput(task, status, terminalOutput) {
+    if (status !== "failure") {
+      return;
+    }
+    const directory = getFailureLogDirectory(this.#workspaceRoot);
+    try {
+      mkdirSync(directory, { recursive: true });
+    } catch {
+      return;
+    }
+    const command = task.overrides["command"];
+    const cwd = task.projectRoot;
+    const entry = {
+      command,
+      cwd,
+      exitCode: void 0,
+      hash: task.hash,
+      runId: this.#runId,
+      status,
+      taskId: task.id,
+      terminalOutput,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      writeFileSync(getFailureLogPath(this.#workspaceRoot, task.id), `${JSON.stringify(entry, void 0, 2)}
+`, "utf8");
+    } catch {
+    }
+  }
+}
+const loadFailureLog = async (workspaceRoot, taskId) => {
+  const path = getFailureLogPath(workspaceRoot, taskId);
+  try {
+    const content = await readFile(path, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+};
+const listFailureLogs = (workspaceRoot) => {
+  const directory = getFailureLogDirectory(workspaceRoot);
+  let entries;
+  try {
+    entries = readdirSync(directory);
+  } catch {
+    return [];
+  }
+  const taskIds = [];
+  for (const name of entries) {
+    if (!name.endsWith(".json")) {
+      continue;
+    }
+    try {
+      taskIds.push(decodeURIComponent(name.slice(0, -".json".length)));
+    } catch {
+    }
+  }
+  return taskIds;
+};
+
+export { FailureLogLifeCycle as F, loadFailureLog as a, listFailureLogs as l };

package/dist/packem_shared/flakiness-goTxXuCX.js

@@ -0,0 +1,180 @@
+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
+} = __cjs_getBuiltinModule("node:fs");
+import { isAccessibleSync, readJsonSync } from '@visulima/fs';
+import { join } from '@visulima/path';
+
+const formatTimingSummary = (results, durationMs) => {
+  let succeeded = 0;
+  let cached = 0;
+  let failed = 0;
+  for (const [, result] of results) {
+    switch (result.status) {
+      case "failure": {
+        failed += 1;
+        break;
+      }
+      case "local-cache":
+      case "local-cache-kept-existing":
+      case "remote-cache": {
+        cached += 1;
+        break;
+      }
+      case "success": {
+        succeeded += 1;
+        break;
+      }
+    }
+  }
+  const parts = [];
+  if (succeeded > 0) {
+    parts.push(`${String(succeeded)} succeeded`);
+  }
+  if (cached > 0) {
+    parts.push(`${String(cached)} cached`);
+  }
+  if (failed > 0) {
+    parts.push(`${String(failed)} failed`);
+  }
+  const seconds = (durationMs / 1e3).toFixed(1);
+  parts.push(`${seconds}s`);
+  return parts.join(" · ");
+};
+const loadRunSummaries = (workspaceRoot) => {
+  const runsDir = join(workspaceRoot, ".task-runner", "runs");
+  if (!isAccessibleSync(runsDir)) {
+    return [];
+  }
+  const files = readdirSync(runsDir).filter((f) => f.endsWith(".json"));
+  const summaries = [];
+  for (const file of files) {
+    try {
+      summaries.push(readJsonSync(join(runsDir, file)));
+    } catch {
+    }
+  }
+  return summaries;
+};
+const compareDuration = (workspaceRoot, currentDurationMs, summaries) => {
+  const history = summaries ?? loadRunSummaries(workspaceRoot);
+  if (history.length < 2) {
+    return void 0;
+  }
+  let totalDuration = 0;
+  let count = 0;
+  for (const data of history) {
+    if (typeof data.duration === "number" && data.duration > 0) {
+      totalDuration += data.duration;
+      count += 1;
+    }
+  }
+  if (count < 2) {
+    return void 0;
+  }
+  const avgMs = totalDuration / count;
+  const diffMs = avgMs - currentDurationMs;
+  const absDiffSeconds = Math.abs(diffMs / 1e3).toFixed(1);
+  if (Math.abs(diffMs) < 500) {
+    return "(about average)";
+  }
+  return diffMs > 0 ? `(${absDiffSeconds}s faster than avg)` : `(${absDiffSeconds}s slower than avg)`;
+};
+
+const analyzeFlakiness = (workspaceRoot, options = {}, summaries) => {
+  const history = summaries ?? loadRunSummaries(workspaceRoot);
+  if (history.length === 0) {
+    return [];
+  }
+  const stats = /* @__PURE__ */ new Map();
+  for (const summary of history) {
+    if (options.since && (summary.startTime === void 0 || summary.startTime < options.since)) {
+      continue;
+    }
+    if (!Array.isArray(summary.tasks)) {
+      continue;
+    }
+    for (const task of summary.tasks) {
+      if (task.cacheStatus === "HIT" || task.cacheStatus === "REMOTE_HIT" || task.cacheStatus === "SKIPPED") {
+        continue;
+      }
+      const existing = stats.get(task.taskId) ?? {
+        failures: 0,
+        project: task.target.project,
+        successes: 0,
+        target: task.target.target,
+        totalRuns: 0
+      };
+      existing.totalRuns += 1;
+      if (task.exitCode !== void 0 && task.exitCode !== 0) {
+        existing.failures += 1;
+        existing.lastFailure = task.startTime ?? summary.startTime;
+      } else {
+        existing.successes += 1;
+      }
+      stats.set(task.taskId, existing);
+    }
+  }
+  const minRuns = options.minRuns ?? 2;
+  const results = [];
+  for (const [taskId, data] of stats) {
+    if (data.totalRuns < minRuns) {
+      continue;
+    }
+    if (data.failures === 0) {
+      continue;
+    }
+    results.push({
+      failures: data.failures,
+      flakinessRate: data.failures / data.totalRuns,
+      lastFailure: data.lastFailure,
+      project: data.project,
+      successes: data.successes,
+      target: data.target,
+      taskId,
+      totalRuns: data.totalRuns
+    });
+  }
+  results.sort((a, b) => b.flakinessRate - a.flakinessRate);
+  return results;
+};
+const formatFlakinessTable = (stats) => {
+  if (stats.length === 0) {
+    return ["No flaky tasks detected."];
+  }
+  const header = ["Task", "Runs", "Failures", "Rate", "Last Failure"];
+  const rows = stats.map((s) => [s.taskId, String(s.totalRuns), String(s.failures), `${(s.flakinessRate * 100).toFixed(1)}%`, s.lastFailure ?? "—"]);
+  const widths = header.map((h, i) => {
+    const maxDataWidth = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+    return Math.max(h.length, maxDataWidth);
+  });
+  const pad = (str, width) => str.padEnd(width);
+  const separator = widths.map((w) => "─".repeat(w)).join("──");
+  const lines = [];
+  lines.push(header.map((h, i) => pad(h, widths[i])).join("  "));
+  lines.push(separator);
+  for (const row of rows) {
+    lines.push(row.map((cell, i) => pad(cell, widths[i])).join("  "));
+  }
+  return lines;
+};
+
+export { analyzeFlakiness as a, formatTimingSummary as b, compareDuration as c, formatFlakinessTable as f, loadRunSummaries as l };