@halecraft/verify 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,14 +1,76 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/config.ts
 import { existsSync } from "fs";
 import { join, resolve } from "path";
 import { pathToFileURL } from "url";
+import { z } from "zod";
+var ConfigError = class extends Error {
+  constructor(message, configPath) {
+    super(message);
+    this.configPath = configPath;
+    this.name = "ConfigError";
+  }
+};
+var EnvSchema = z.record(z.string(), z.string().nullable()).optional();
+var VerificationCommandSchema = z.object({
+  cmd: z.string(),
+  args: z.array(z.string()),
+  cwd: z.string().optional(),
+  env: EnvSchema,
+  timeout: z.number().positive().optional()
+});
+var VerificationNodeSchema = z.lazy(
+  () => z.object({
+    key: z.string().min(1, "Task key cannot be empty").refine((key) => !key.includes(":"), {
+      message: "Task key cannot contain ':' (reserved for paths)"
+    }),
+    name: z.string().optional(),
+    run: z.union([z.string(), VerificationCommandSchema]).optional(),
+    children: z.array(VerificationNodeSchema).optional(),
+    strategy: z.enum(["parallel", "sequential", "fail-fast"]).optional(),
+    parser: z.string().optional(),
+    successLabel: z.string().optional(),
+    failureLabel: z.string().optional(),
+    reportingDependsOn: z.array(z.string()).optional(),
+    timeout: z.number().positive().optional(),
+    env: EnvSchema
+  })
+);
+var VerifyOptionsSchema = z.object({
+  logs: z.enum(["all", "failed", "none"]).optional(),
+  format: z.enum(["human", "json"]).optional(),
+  filter: z.array(z.string()).optional(),
+  cwd: z.string().optional(),
+  noColor: z.boolean().optional(),
+  topLevelOnly: z.boolean().optional(),
+  noTty: z.boolean().optional(),
+  passthrough: z.array(z.string()).optional()
+});
+var PackageDiscoveryOptionsSchema = z.object({
+  patterns: z.array(z.string()).optional(),
+  filter: z.array(z.string()).optional(),
+  changed: z.boolean().optional()
+});
+var VerifyConfigSchema = z.object({
+  tasks: z.array(VerificationNodeSchema),
+  packages: PackageDiscoveryOptionsSchema.optional(),
+  options: VerifyOptionsSchema.optional(),
+  env: EnvSchema
+});
+function validateConfig(value, configPath) {
+  const result = VerifyConfigSchema.safeParse(value);
+  if (!result.success) {
+    const errors = result.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    throw new ConfigError(
+      `Invalid config:
+  - ${errors.join("\n  - ")}`,
+      configPath
+    );
+  }
+  return result.data;
+}
 function defineConfig(config) {
   return config;
 }
@@ -38,9 +100,9 @@ async function loadConfig(configPath) {
   const fileUrl = pathToFileURL(absolutePath).href;
   const module = await import(fileUrl);
   if (!module.default) {
-    throw new Error(`Config file ${configPath} must have a default export`);
+    throw new ConfigError(`Config file must have a default export`, configPath);
   }
-  return module.default;
+  return validateConfig(module.default, configPath);
 }
 async function loadConfigFromCwd(cwd, configPath) {
   if (configPath) {
@@ -60,13 +122,32 @@ function mergeOptions(configOptions, cliOptions) {
     cwd: cliOptions?.cwd ?? configOptions?.cwd ?? process.cwd(),
     noColor: cliOptions?.noColor ?? configOptions?.noColor ?? false,
     topLevelOnly: cliOptions?.topLevelOnly ?? configOptions?.topLevelOnly ?? false,
-    noTty: cliOptions?.noTty ?? configOptions?.noTty ?? false
+    noTty: cliOptions?.noTty ?? configOptions?.noTty ?? false,
+    passthrough: cliOptions?.passthrough ?? configOptions?.passthrough
   };
 }
 
 // src/discovery.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "fs";
 import { join as join2, relative } from "path";
+
+// src/schemas/package-json.ts
+import { z as z2 } from "zod";
+var PackageJsonSchema = z2.object({
+  name: z2.string().optional(),
+  scripts: z2.record(z2.string(), z2.string()).optional()
+}).passthrough();
+function parsePackageJson(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const result = PackageJsonSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/discovery.ts
 var DEFAULT_PATTERNS = ["packages/*", "apps/*"];
 function findMatchingDirs(rootDir, patterns) {
   const results = [];
@@ -98,8 +179,9 @@ function getPackageName(packageDir) {
     return null;
   }
   try {
-    const content = __require(packageJsonPath);
-    return content.name ?? null;
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const parsed = parsePackageJson(content);
+    return parsed?.name ?? null;
   } catch {
     return null;
   }
@@ -132,8 +214,133 @@ async function hasPackageChanged(_packagePath, _baseBranch = "main") {
   return true;
 }
 
+// src/filter.ts
+import leven from "leven";
+
+// src/tree.ts
+var PATH_SEPARATOR = ":";
+function buildTaskPath(parentPath, key) {
+  return parentPath ? `${parentPath}${PATH_SEPARATOR}${key}` : key;
+}
+function walkNodes(nodes, visitor, parentPath = "", depth = 0) {
+  for (const node of nodes) {
+    const path = buildTaskPath(parentPath, node.key);
+    visitor(node, path, depth);
+    if (node.children) {
+      walkNodes(node.children, visitor, path, depth + 1);
+    }
+  }
+}
+function collectPaths(nodes) {
+  const paths = [];
+  walkNodes(nodes, (_node, path) => {
+    paths.push(path);
+  });
+  return paths;
+}
+
+// src/filter.ts
+var TaskNotFoundError = class extends Error {
+  constructor(filter, suggestion, availableTasks) {
+    super(buildErrorMessage(filter, suggestion, availableTasks));
+    this.filter = filter;
+    this.suggestion = suggestion;
+    this.availableTasks = availableTasks;
+    this.name = "TaskNotFoundError";
+  }
+  exitCode = 2;
+};
+var AmbiguousTaskError = class extends Error {
+  constructor(filter, matches) {
+    super(buildAmbiguousErrorMessage(filter, matches));
+    this.filter = filter;
+    this.matches = matches;
+    this.name = "AmbiguousTaskError";
+  }
+  exitCode = 2;
+};
+function buildErrorMessage(filter, suggestion, availableTasks) {
+  let message = `Task "${filter}" not found.`;
+  if (suggestion) {
+    message += `
+
+Did you mean "${suggestion}"?`;
+  }
+  message += "\n\nAvailable tasks:";
+  for (const task of availableTasks) {
+    message += `
+  ${task}`;
+  }
+  return message;
+}
+function buildAmbiguousErrorMessage(filter, matches) {
+  let message = `Task "${filter}" is ambiguous.`;
+  message += "\n\nMatches multiple tasks:";
+  for (const match of matches) {
+    message += `
+  ${match}`;
+  }
+  return message;
+}
+function findBestSuggestion(availablePaths, invalidFilter) {
+  let bestPath;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  const threshold = Math.max(2, Math.floor(invalidFilter.length / 3));
+  for (const path of availablePaths) {
+    const distance = leven(invalidFilter, path);
+    if (distance < bestDistance && distance <= threshold) {
+      bestDistance = distance;
+      bestPath = path;
+    }
+    const lastSegment = path.split(PATH_SEPARATOR).pop();
+    if (lastSegment && lastSegment !== path) {
+      const segmentDistance = leven(invalidFilter, lastSegment);
+      if (segmentDistance < bestDistance && segmentDistance <= threshold) {
+        bestDistance = segmentDistance;
+        bestPath = path;
+      }
+    }
+  }
+  return bestPath;
+}
+function resolveFilter(filter, availablePaths) {
+  if (availablePaths.includes(filter)) {
+    return { original: filter, resolved: filter, wasShortcut: false };
+  }
+  const prefixMatches = availablePaths.filter(
+    (path) => path === filter || path.startsWith(`${filter}${PATH_SEPARATOR}`)
+  );
+  if (prefixMatches.length > 0) {
+    return { original: filter, resolved: filter, wasShortcut: false };
+  }
+  const childMatches = availablePaths.filter((path) => {
+    const lastSegment = path.split(PATH_SEPARATOR).pop();
+    return lastSegment === filter;
+  });
+  if (childMatches.length === 1) {
+    return {
+      original: filter,
+      resolved: childMatches[0],
+      wasShortcut: true
+    };
+  }
+  if (childMatches.length > 1) {
+    throw new AmbiguousTaskError(filter, childMatches);
+  }
+  const suggestion = findBestSuggestion(availablePaths, filter);
+  throw new TaskNotFoundError(filter, suggestion, availablePaths);
+}
+function resolveFilters(nodes, filters) {
+  const availablePaths = collectPaths(nodes);
+  const resolved = [];
+  for (const filter of filters) {
+    resolved.push(resolveFilter(filter, availablePaths));
+  }
+  return resolved;
+}
+
 // src/init/detect.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join3 } from "path";
 var TOOL_PATTERNS = [
   // Biome
@@ -292,8 +499,8 @@ function readPackageJson(cwd) {
     return null;
   }
   try {
-    const content = readFileSync(packageJsonPath, "utf-8");
-    return JSON.parse(content);
+    const content = readFileSync2(packageJsonPath, "utf-8");
+    return parsePackageJson(content);
   } catch {
     return null;
   }
@@ -306,7 +513,7 @@ function extractOptimizedCommand(cwd, scriptContent) {
     const match = scriptContent.match(tool.pattern);
     if (match && binaryExists(cwd, tool.binary)) {
       const args = tool.getArgs(match, scriptContent);
-      const command = args ? `./node_modules/.bin/${tool.binary} ${args}` : `./node_modules/.bin/${tool.binary}`;
+      const command = args ? `${tool.binary} ${args}` : tool.binary;
       return { command, parser: tool.parser };
     }
   }
@@ -383,7 +590,7 @@ function detectTasks(cwd) {
   const packageManager = detectPackageManager(cwd);
   const tasks = detectFromPackageJson(cwd);
   return tasks.map((task) => {
-    if (task.command.startsWith("./")) {
+    if (!task.command.startsWith("npm run ")) {
       return task;
     }
     return {
@@ -419,12 +626,15 @@ function generateSkeleton(format) {
   return `${importStatement}
 
 export default defineConfig({
+  env: {
+    NO_COLOR: "1",
+  },
   tasks: [
     // Add your verification tasks here
     // Example:
-    // { key: "format", run: "pnpm lint" },
-    // { key: "types", run: "pnpm typecheck" },
-    // { key: "test", run: "pnpm test" },
+    // { key: "format", run: "biome check ." },
+    // { key: "types", run: "tsc --noEmit" },
+    // { key: "test", run: "vitest run" },
   ],
 })
 `;
@@ -439,6 +649,9 @@ function generateConfigContent(tasks, format) {
   return `${importStatement}
 
 export default defineConfig({
+  env: {
+    NO_COLOR: "1",
+  },
   tasks: [
 ${taskLines.join(",\n")},
   ],
@@ -764,6 +977,18 @@ var vitestParser = {
 };
 
 // src/parsers/index.ts
+var parsers = {
+  /** Vitest/Jest test runner output parser */
+  vitest: "vitest",
+  /** TypeScript compiler (tsc/tsgo) output parser */
+  tsc: "tsc",
+  /** Biome/ESLint linter output parser */
+  biome: "biome",
+  /** Go test runner output parser */
+  gotest: "gotest",
+  /** Generic fallback parser */
+  generic: "generic"
+};
 var ParserRegistry = class {
   parsers = /* @__PURE__ */ new Map();
   constructor() {
@@ -791,24 +1016,24 @@ var ParserRegistry = class {
   detectParser(cmd) {
     const cmdLower = cmd.toLowerCase();
     if (cmdLower.includes("vitest") || cmdLower.includes("jest")) {
-      return "vitest";
+      return parsers.vitest;
     }
     if (cmdLower.includes("tsc") || cmdLower.includes("tsgo")) {
-      return "tsc";
+      return parsers.tsc;
     }
     if (cmdLower.includes("biome") || cmdLower.includes("eslint")) {
-      return "biome";
+      return parsers.biome;
     }
     if (cmdLower.includes("go test") || cmdLower.includes("go") && cmdLower.includes("test")) {
-      return "gotest";
+      return parsers.gotest;
     }
-    return "generic";
+    return parsers.generic;
   }
   /**
    * Parse output using the specified or auto-detected parser
    */
   parse(output, exitCode, parserId, cmd) {
-    const id = parserId ?? (cmd ? this.detectParser(cmd) : "generic");
+    const id = parserId ?? (cmd ? this.detectParser(cmd) : parsers.generic);
     const parser = this.parsers.get(id) ?? genericParser;
     const result = parser.parse(output, exitCode);
     if (result) {
@@ -940,16 +1165,12 @@ var BaseReporter = class {
     return this.taskDepths.get(path) ?? 0;
   }
   /**
-   * Recursively collect task depths from verification tree
+   * Collect task depths from verification tree using walkNodes
    */
-  collectTaskDepths(nodes, parentPath, depth) {
-    for (const node of nodes) {
-      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+  collectTaskDepths(nodes) {
+    walkNodes(nodes, (_node, path, depth) => {
       this.taskDepths.set(path, depth);
-      if (node.children) {
-        this.collectTaskDepths(node.children, path, depth + 1);
-      }
-    }
+    });
   }
   /**
    * Extract summary from task result
@@ -1027,16 +1248,15 @@ var LiveDashboardReporter = class extends BaseReporter {
    * Initialize task list from verification nodes
    */
   onStart(tasks) {
-    this.collectTasks(tasks, "", 0);
+    this.collectTasks(tasks);
     this.stream.write(cursor.hide);
     this.spinner.start(() => this.redraw());
   }
   /**
-   * Recursively collect tasks from verification tree
+   * Collect tasks from verification tree using walkNodes
    */
-  collectTasks(nodes, parentPath, depth) {
-    for (const node of nodes) {
-      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+  collectTasks(nodes) {
+    walkNodes(nodes, (node, path, depth) => {
       this.tasks.set(path, {
         key: node.key,
         path,
@@ -1045,10 +1265,7 @@ var LiveDashboardReporter = class extends BaseReporter {
       });
       this.taskOrder.push(path);
       this.taskDepths.set(path, depth);
-      if (node.children) {
-        this.collectTasks(node.children, path, depth + 1);
-      }
-    }
+    });
   }
   /**
    * Get display key - shows :key for nested, key for root
@@ -1084,9 +1301,9 @@ var LiveDashboardReporter = class extends BaseReporter {
       }
       const summary = this.extractSummary(task.result);
       if (task.result.ok) {
-        return ` ${indent}${this.okMark()} verified ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+        return `${indent}${this.okMark()}   verified ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
       }
-      return `${indent}${this.failMark()}    failed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+      return `${indent}${this.failMark()}     failed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
     }
     return "";
   }
@@ -1141,7 +1358,7 @@ var SequentialReporter = class extends BaseReporter {
     this.topLevelOnly = options.topLevelOnly ?? false;
   }
   onStart(tasks) {
-    this.collectTaskDepths(tasks, "", 0);
+    this.collectTaskDepths(tasks);
   }
   /**
    * Check if task should be displayed based on topLevelOnly flag
@@ -1166,13 +1383,18 @@ var SequentialReporter = class extends BaseReporter {
       );
       return;
     }
-    const mark = result.ok ? this.okMark() : this.failMark();
-    const verb = result.ok ? "verified" : "failed";
     const summary = this.extractSummary(result);
-    this.stream.write(
-      `${mark} ${verb} ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
+    if (result.ok) {
+      this.stream.write(
+        `${this.okMark()}   verified ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
 `
-    );
+      );
+    } else {
+      this.stream.write(
+        `${this.failMark()}     failed ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
+`
+      );
+    }
   }
   onFinish() {
   }
@@ -1242,23 +1464,11 @@ function createReporter(options) {
 
 // src/runner.ts
 import { spawn } from "child_process";
+import { dirname, join as join4, resolve as resolve3 } from "path";
+import treeKill2 from "tree-kill";
+
+// src/dependency-tracker.ts
 import treeKill from "tree-kill";
-function normalizeCommand(run) {
-  if (typeof run === "string") {
-    const parts = run.split(/\s+/);
-    return {
-      cmd: parts[0],
-      args: parts.slice(1)
-    };
-  }
-  if (Array.isArray(run)) {
-    return {
-      cmd: run[0],
-      args: run[1]
-    };
-  }
-  return run;
-}
 var ReportingDependencyTracker = class {
   /** Map of task path/key to their results */
   results = /* @__PURE__ */ new Map();
@@ -1276,26 +1486,22 @@ var ReportingDependencyTracker = class {
   processes = /* @__PURE__ */ new Map();
   /** Set of task paths that have been killed */
   killedPaths = /* @__PURE__ */ new Set();
+  /** Set of task paths that will actually run (based on filter) */
+  activePaths = /* @__PURE__ */ new Set();
   /**
    * Initialize the tracker with all tasks from the verification tree.
    * Also validates for circular dependencies and builds reverse dependency map.
    */
-  initialize(nodes, parentPath = "") {
-    for (const node of nodes) {
-      const path = parentPath ? `${parentPath}:${node.key}` : node.key;
+  initialize(nodes) {
+    walkNodes(nodes, (node, path) => {
       this.pathToKey.set(path, node.key);
       this.keyToPath.set(node.key, path);
       if (node.reportingDependsOn && node.reportingDependsOn.length > 0) {
         this.dependencies.set(path, node.reportingDependsOn);
       }
-      if (node.children) {
-        this.initialize(node.children, path);
-      }
-    }
-    if (parentPath === "") {
-      this.validateNoCycles();
-      this.buildReverseDeps();
-    }
+    });
+    this.validateNoCycles();
+    this.buildReverseDeps();
   }
   /**
    * Build reverse dependency map (task → tasks that depend on it)
@@ -1398,15 +1604,35 @@ var ReportingDependencyTracker = class {
       this.waiters.delete(key);
     }
   }
+  /**
+   * Mark a task as active (will actually run).
+   * Called before running each task to track which tasks are in the execution set.
+   */
+  markActive(path) {
+    this.activePaths.add(path);
+  }
+  /**
+   * Check if a dependency is active (will run).
+   * If not active, we shouldn't wait for it.
+   */
+  isDependencyActive(dep) {
+    const resolvedPath = this.resolveDependency(dep);
+    if (!resolvedPath) {
+      return false;
+    }
+    return this.activePaths.has(resolvedPath);
+  }
   /**
    * Wait for all dependencies of a task to complete.
+   * Only waits for dependencies that are actually active (will run).
    */
   async waitForDependencies(path) {
     const deps = this.dependencies.get(path);
     if (!deps || deps.length === 0) {
       return;
     }
-    const waitPromises = deps.map((dep) => this.waitForResult(dep));
+    const activeDeps = deps.filter((dep) => this.isDependencyActive(dep));
+    const waitPromises = activeDeps.map((dep) => this.waitForResult(dep));
     await Promise.all(waitPromises);
   }
   /**
@@ -1420,9 +1646,9 @@ var ReportingDependencyTracker = class {
     if (this.results.has(pathOrKey)) {
       return Promise.resolve();
     }
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const waiters = this.waiters.get(pathOrKey) ?? [];
-      waiters.push(resolve3);
+      waiters.push(resolve4);
       this.waiters.set(pathOrKey, waiters);
     });
   }
@@ -1488,18 +1714,116 @@ var ReportingDependencyTracker = class {
     }
   }
 };
+
+// src/runner.ts
+function mergeEnv(base, overlay) {
+  if (!overlay) return { ...base };
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === null) {
+      result[key] = null;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function buildFinalEnv(processEnv, path, overlay) {
+  const result = {};
+  for (const [key, value] of Object.entries(processEnv)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  result.PATH = path;
+  if (overlay) {
+    for (const [key, value] of Object.entries(overlay)) {
+      if (value === null) {
+        delete result[key];
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function shellEscape(arg) {
+  if (/[\s"'`$\\!&|;<>(){}[\]*?#~]/.test(arg)) {
+    return `"${arg.replace(/"/g, '\\"')}"`;
+  }
+  return arg;
+}
+function buildNodeModulesPath(cwd) {
+  const pathSeparator = process.platform === "win32" ? ";" : ":";
+  const existingPath = process.env.PATH ?? "";
+  const binPaths = [];
+  let current = resolve3(cwd);
+  while (true) {
+    binPaths.push(join4(current, "node_modules", ".bin"));
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return [...binPaths, existingPath].join(pathSeparator);
+}
+function normalizeCommand(run, nodeTimeout, passthrough, inheritedEnv) {
+  if (typeof run === "string") {
+    let cmd = run;
+    if (passthrough && passthrough.length > 0) {
+      const escapedArgs = passthrough.map(shellEscape).join(" ");
+      cmd = `${run} ${escapedArgs}`;
+    }
+    return {
+      cmd,
+      args: [],
+      shell: true,
+      timeout: nodeTimeout,
+      env: inheritedEnv
+    };
+  }
+  const args = passthrough ? [...run.args, ...passthrough] : run.args;
+  const env = mergeEnv(inheritedEnv ?? {}, run.env);
+  return {
+    cmd: run.cmd,
+    args,
+    cwd: run.cwd,
+    env: Object.keys(env).length > 0 ? env : void 0,
+    shell: false,
+    // Command-level timeout takes precedence over node-level timeout
+    timeout: run.timeout ?? nodeTimeout
+  };
+}
 async function executeCommand(command, cwd, tracker, path) {
   const start = Date.now();
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
+    const useShell = command.shell || process.platform === "win32";
+    const effectiveCwd = command.cwd ?? cwd;
+    const finalEnv = buildFinalEnv(
+      process.env,
+      buildNodeModulesPath(effectiveCwd),
+      command.env
+    );
     const proc = spawn(command.cmd, command.args, {
-      shell: process.platform === "win32",
-      cwd: command.cwd ?? cwd,
-      env: { ...process.env, NO_COLOR: "1", ...command.env }
+      shell: useShell,
+      cwd: effectiveCwd,
+      env: finalEnv
     });
     if (tracker && path) {
       tracker.registerProcess(path, proc);
     }
     let output = "";
+    let timedOut = false;
+    let timeoutId;
+    if (command.timeout && proc.pid) {
+      const pid = proc.pid;
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        treeKill2(pid, "SIGTERM", (err) => {
+          if (err) {
+          }
+        });
+      }, command.timeout);
+    }
     proc.stdout.on("data", (data) => {
       output += data.toString();
     });
@@ -1507,35 +1831,41 @@ async function executeCommand(command, cwd, tracker, path) {
       output += data.toString();
     });
     proc.on("close", (code, signal) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       if (tracker && path) {
         tracker.unregisterProcess(path);
       }
       const durationMs = Date.now() - start;
       const killed = signal === "SIGTERM" || code === 143 || (tracker?.wasKilled(path ?? "") ?? false);
-      resolve3({
+      resolve4({
         code: code ?? 1,
         output,
         durationMs,
-        killed
+        killed: killed && !timedOut,
+        // Don't mark as killed if it was a timeout
+        timedOut
       });
     });
     proc.on("error", (err) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       if (tracker && path) {
         tracker.unregisterProcess(path);
       }
       const durationMs = Date.now() - start;
-      resolve3({
+      resolve4({
         code: 1,
         output: `Failed to execute command: ${err.message}`,
         durationMs,
-        killed: false
+        killed: false,
+        timedOut: false
       });
     });
   });
 }
-function buildPath(parentPath, key) {
-  return parentPath ? `${parentPath}:${key}` : key;
-}
 function matchesFilter(path, filters) {
   if (!filters || filters.length === 0) {
     return true;
@@ -1545,7 +1875,7 @@ function matchesFilter(path, filters) {
   });
 }
 function hasMatchingDescendant(node, parentPath, filters) {
-  const path = buildPath(parentPath, node.key);
+  const path = buildTaskPath(parentPath, node.key);
   if (matchesFilter(path, filters)) {
     return true;
   }
@@ -1561,11 +1891,13 @@ var VerificationRunner = class {
   options;
   callbacks;
   dependencyTracker;
-  constructor(options = {}, registry = defaultRegistry, callbacks = {}) {
+  configEnv;
+  constructor(options = {}, registry = defaultRegistry, callbacks = {}, configEnv = {}) {
     this.options = options;
     this.registry = registry;
     this.callbacks = callbacks;
     this.dependencyTracker = new ReportingDependencyTracker();
+    this.configEnv = configEnv;
   }
   /**
    * Run all verification tasks
@@ -1574,7 +1906,8 @@ var VerificationRunner = class {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const wallStart = Date.now();
     this.dependencyTracker.initialize(tasks);
-    const results = await this.runNodes(tasks, "");
+    const baseEnv = mergeEnv({}, this.configEnv);
+    const results = await this.runNodes(tasks, "", "parallel", baseEnv);
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     const durationMs = Date.now() - wallStart;
     const allOk = results.every((r) => r.ok);
@@ -1589,7 +1922,7 @@ var VerificationRunner = class {
   /**
    * Run a list of nodes with the appropriate strategy
    */
-  async runNodes(nodes, parentPath, strategy = "parallel") {
+  async runNodes(nodes, parentPath, strategy = "parallel", inheritedEnv = {}) {
     const filteredNodes = nodes.filter(
       (node) => hasMatchingDescendant(node, parentPath, this.options.filter)
     );
@@ -1599,19 +1932,21 @@ var VerificationRunner = class {
     switch (strategy) {
       case "parallel":
         return Promise.all(
-          filteredNodes.map((node) => this.runNode(node, parentPath))
+          filteredNodes.map(
+            (node) => this.runNode(node, parentPath, inheritedEnv)
+          )
         );
       case "sequential": {
         const results = [];
         for (const node of filteredNodes) {
-          results.push(await this.runNode(node, parentPath));
+          results.push(await this.runNode(node, parentPath, inheritedEnv));
         }
         return results;
       }
       case "fail-fast": {
         const results = [];
         for (const node of filteredNodes) {
-          const result = await this.runNode(node, parentPath);
+          const result = await this.runNode(node, parentPath, inheritedEnv);
           results.push(result);
           if (!result.ok) {
             break;
@@ -1624,15 +1959,18 @@ var VerificationRunner = class {
   /**
    * Run a single node (leaf or group)
    */
-  async runNode(node, parentPath) {
-    const path = buildPath(parentPath, node.key);
+  async runNode(node, parentPath, inheritedEnv = {}) {
+    const path = buildTaskPath(parentPath, node.key);
+    const nodeEnv = mergeEnv(inheritedEnv, node.env);
+    this.dependencyTracker.markActive(path);
     this.callbacks.onTaskStart?.(path, node.key);
     if (node.children && node.children.length > 0) {
       const start = Date.now();
       const childResults = await this.runNodes(
         node.children,
         path,
-        node.strategy ?? "parallel"
+        node.strategy ?? "parallel",
+        nodeEnv
       );
       const durationMs2 = Date.now() - start;
       const allOk = childResults.every((r) => r.ok || r.suppressed);
@@ -1671,15 +2009,36 @@ var VerificationRunner = class {
       this.callbacks.onTaskComplete?.(result2);
       return result2;
     }
-    const command = normalizeCommand(node.run);
+    const passthrough = this.options.passthrough;
+    const command = normalizeCommand(
+      node.run,
+      node.timeout,
+      passthrough,
+      nodeEnv
+    );
     const cwd = this.options.cwd ?? process.cwd();
-    const { code, output, durationMs, killed } = await executeCommand(
+    const { code, output, durationMs, killed, timedOut } = await executeCommand(
       command,
       cwd,
       this.dependencyTracker,
       path
     );
     const ok = code === 0;
+    if (timedOut) {
+      const result2 = {
+        key: node.key,
+        path,
+        ok: false,
+        code,
+        durationMs,
+        output,
+        summaryLine: `${node.key}: timed out after ${command.timeout}ms`,
+        timedOut: true
+      };
+      this.dependencyTracker.recordResult(result2);
+      this.callbacks.onTaskComplete?.(result2);
+      return result2;
+    }
     if (killed) {
       await this.dependencyTracker.waitForDependencies(path);
       const failedDep = this.dependencyTracker.getFailedDependency(path);
@@ -1698,7 +2057,7 @@ var VerificationRunner = class {
       this.callbacks.onTaskComplete?.(result2);
       return result2;
     }
-    const cmdString = `${command.cmd} ${command.args.join(" ")}`;
+    const cmdString = command.shell ? command.cmd : `${command.cmd} ${command.args.join(" ")}`;
     const parsed = this.registry.parse(
       output,
       code,
@@ -1743,12 +2102,26 @@ var VerificationRunner = class {
 // src/index.ts
 async function verify(config, cliOptions) {
   const options = mergeOptions(config.options, cliOptions);
+  if (options.filter && options.filter.length > 0) {
+    const resolved = resolveFilters(config.tasks, options.filter);
+    for (const r of resolved) {
+      if (r.wasShortcut) {
+        console.error(`\u2192 Resolving "${r.original}" to "${r.resolved}"`);
+      }
+    }
+    options.filter = resolved.map((r) => r.resolved);
+  }
   const reporter = createReporter(options);
   reporter.onStart?.(config.tasks);
-  const runner = new VerificationRunner(options, void 0, {
-    onTaskStart: (path, key) => reporter.onTaskStart(path, key),
-    onTaskComplete: (result2) => reporter.onTaskComplete(result2)
-  });
+  const runner = new VerificationRunner(
+    options,
+    void 0,
+    {
+      onTaskStart: (path, key) => reporter.onTaskStart(path, key),
+      onTaskComplete: (result2) => reporter.onTaskComplete(result2)
+    },
+    config.env
+  );
   const result = await runner.run(config.tasks);
   reporter.onFinish?.();
   reporter.outputLogs(result.tasks, options.logs ?? "failed");
@@ -1765,20 +2138,27 @@ async function verifyFromConfig(cwd = process.cwd(), cliOptions) {
   return verify(config, { ...cliOptions, cwd });
 }
 export {
+  AmbiguousTaskError,
+  ConfigError,
   JSONReporter,
   LiveDashboardReporter,
+  PATH_SEPARATOR,
   ParserRegistry,
   QuietReporter,
   SequentialReporter,
   SequentialReporter as TTYReporter,
+  TaskNotFoundError,
   VerificationRunner,
   biomeParser,
+  buildTaskPath,
+  collectPaths,
   createReporter,
   defaultRegistry,
   defineConfig,
   defineTask,
   detectTasks,
   discoverPackages,
+  findBestSuggestion,
   findConfigFile,
   generateConfigContent,
   genericParser,
@@ -1787,10 +2167,14 @@ export {
   loadConfig,
   loadConfigFromCwd,
   mergeOptions,
+  parsers,
+  resolveFilters,
   runInit,
   tscParser,
+  validateConfig,
   verify,
   verifyFromConfig,
-  vitestParser
+  vitestParser,
+  walkNodes
 };
 //# sourceMappingURL=index.js.map