Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

test/vitest/vitest.unit.config.ts

@@ -0,0 +1,188 @@
+// Vitest unit config wires the unit test shard.
+import fs from "node:fs";
+import path from "node:path";
+import { defineConfig } from "vitest/config";
+import { loadPatternListFromEnv, narrowIncludePatternsForCli } from "./vitest.pattern-file.ts";
+import {
+  resolveVitestIsolation,
+  shouldPassWithNoTestsForCliIncludes,
+} from "./vitest.scoped-config.ts";
+import {
+  nonIsolatedRunnerPath,
+  repoRoot,
+  resolveRepoRootPath,
+  sharedVitestConfig,
+} from "./vitest.shared.config.ts";
+import { getUnitFastTestFiles } from "./vitest.unit-fast-paths.mjs";
+import {
+  isBundledPluginDependentUnitTestFile,
+  isUnitConfigTestFile,
+  unitTestAdditionalExcludePatterns,
+  unitTestIncludePatterns,
+} from "./vitest.unit-paths.mjs";
+
+const sharedTest = sharedVitestConfig.test ?? {};
+const exclude = sharedTest.exclude ?? [];
+
+export function loadIncludePatternsFromEnv(
+  env: Record<string, string | undefined> = process.env,
+): string[] | null {
+  return loadPatternListFromEnv("OPENCLAW_VITEST_INCLUDE_FILE", env);
+}
+
+export function loadExtraExcludePatternsFromEnv(
+  env: Record<string, string | undefined> = process.env,
+): string[] {
+  return loadPatternListFromEnv("OPENCLAW_VITEST_EXTRA_EXCLUDE_FILE", env) ?? [];
+}
+
+const defaultUnitCoverageRoots = ["src", "packages", "test"] as const;
+
+function toRepoPath(filePath: string): string {
+  return path.relative(repoRoot, filePath).split(path.sep).join("/");
+}
+
+function collectTestFiles(dir: string): string[] {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage") {
+      continue;
+    }
+    const entryPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectTestFiles(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
+      files.push(toRepoPath(entryPath));
+    }
+  }
+  return files;
+}
+
+function resolveSiblingSourceFile(testFile: string): string | null {
+  if (!testFile.endsWith(".test.ts")) {
+    return null;
+  }
+  const sourceFile = testFile.replace(/\.test\.ts$/u, ".ts");
+  return fs.existsSync(resolveRepoRootPath(sourceFile)) ? sourceFile : null;
+}
+
+export function resolveDefaultUnitCoverageIncludePatterns(
+  unitFastTestFiles = getUnitFastTestFiles(),
+): string[] {
+  const fastTestFiles = new Set(unitFastTestFiles);
+  const sourceFiles = new Set<string>();
+  for (const root of defaultUnitCoverageRoots) {
+    for (const testFile of collectTestFiles(resolveRepoRootPath(root))) {
+      if (!isUnitConfigTestFile(testFile) || fastTestFiles.has(testFile)) {
+        continue;
+      }
+      const sourceFile = resolveSiblingSourceFile(testFile);
+      if (sourceFile !== null) {
+        sourceFiles.add(sourceFile);
+      }
+    }
+  }
+  return [...sourceFiles].toSorted((left, right) => left.localeCompare(right));
+}
+
+function isEnabledFlagValue(value: string): boolean {
+  return !["0", "false", "no", "off"].includes(value.trim().toLowerCase());
+}
+
+function isCoverageEnabledFromArgv(argv: string[] = process.argv): boolean {
+  return argv.some((arg) => {
+    if (arg === "--coverage" || arg === "--coverage.enabled") {
+      return true;
+    }
+    const match = arg.match(/^--coverage(?:\.enabled)?=(.*)$/u);
+    return match ? isEnabledFlagValue(match[1] ?? "") : false;
+  });
+}
+
+export function createUnitVitestConfigWithOptions(
+  env: Record<string, string | undefined> = process.env,
+  options: {
+    includePatterns?: string[];
+    extraExcludePatterns?: string[];
+    name?: string;
+    argv?: string[];
+    passWithNoTests?: boolean;
+  } = {},
+) {
+  const isolate = resolveVitestIsolation(env);
+  const argv = options.argv ?? process.argv;
+  const unitFastTestFiles = getUnitFastTestFiles();
+  const envIncludePatterns = loadIncludePatternsFromEnv(env);
+  const defaultIncludePatterns = options.includePatterns ?? unitTestIncludePatterns;
+  const cliIncludePatterns = narrowIncludePatternsForCli(defaultIncludePatterns, argv);
+  const coverageIncludePatterns =
+    isCoverageEnabledFromArgv(argv) &&
+    options.includePatterns === undefined &&
+    envIncludePatterns === null &&
+    cliIncludePatterns === null
+      ? resolveDefaultUnitCoverageIncludePatterns(unitFastTestFiles)
+      : null;
+  const protectedIncludeFiles = new Set(
+    defaultIncludePatterns.filter((pattern) => isBundledPluginDependentUnitTestFile(pattern)),
+  );
+  const baseExcludePatterns = unitTestAdditionalExcludePatterns.filter((pattern) => {
+    if (protectedIncludeFiles.size === 0) {
+      return true;
+    }
+    return ![...protectedIncludeFiles].some((file) => pattern === file || pattern.endsWith("/**"));
+  });
+  const extraExcludePatterns = options.extraExcludePatterns ?? [];
+  const resolvedExcludePatterns = [
+    ...new Set([
+      ...exclude,
+      ...baseExcludePatterns,
+      ...unitFastTestFiles,
+      ...extraExcludePatterns,
+      ...loadExtraExcludePatternsFromEnv(env),
+    ]),
+  ];
+  return defineConfig({
+    ...sharedVitestConfig,
+    test: {
+      ...sharedTest,
+      name: options.name ?? "unit",
+      isolate,
+      ...(isolate ? { runner: undefined } : { runner: nonIsolatedRunnerPath }),
+      setupFiles: [
+        ...new Set(
+          [...(sharedTest.setupFiles ?? []), "test/setup-openclaw-runtime.ts"].map(
+            resolveRepoRootPath,
+          ),
+        ),
+      ],
+      include: envIncludePatterns ?? cliIncludePatterns ?? defaultIncludePatterns,
+      exclude: resolvedExcludePatterns,
+      coverage: {
+        ...sharedTest.coverage,
+        ...(coverageIncludePatterns !== null && coverageIncludePatterns.length > 0
+          ? { include: coverageIncludePatterns }
+          : {}),
+        exclude: [
+          ...new Set([
+            ...(sharedTest.coverage?.exclude ?? []),
+            ...baseExcludePatterns,
+            ...extraExcludePatterns,
+          ]),
+        ],
+      },
+      ...(options.passWithNoTests ||
+      shouldPassWithNoTestsForCliIncludes(cliIncludePatterns, resolvedExcludePatterns)
+        ? { passWithNoTests: true }
+        : {}),
+    },
+  });
+}
+
+export function createUnitVitestConfig(env: Record<string, string | undefined> = process.env) {
+  return createUnitVitestConfigWithOptions(env);
+}
+
+export default createUnitVitestConfigWithOptions();