agenthud 0.6.1 → 0.6.3

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import React3 from "react";
 import { render } from "ink";
-import { existsSync } from "fs";
+import { existsSync as existsSync8 } from "fs";
 
 // src/ui/App.tsx
 import React2, { useState as useState4, useEffect as useEffect4, useCallback as useCallback4, useMemo as useMemo3, useRef as useRef3 } from "react";
@@ -1346,18 +1346,17 @@ function useHotkeys({
 }
 
 // src/data/git.ts
-import { execSync as nodeExecSync, exec as nodeExec } from "child_process";
+import { execSync, exec } from "child_process";
 import { promisify } from "util";
-var execAsync = promisify(nodeExec);
+var execAsync = promisify(exec);
 function cleanOutput(str) {
   let result = str.replace(/^\uFEFF/, "");
   result = result.replace(/^"|"$/g, "");
   return result.trim();
 }
-var execFn = (command, options2) => nodeExecSync(command, options2);
 function getUncommittedCount() {
   try {
-    const result = execFn("git status --porcelain", {
+    const result = execSync("git status --porcelain", {
       encoding: "utf-8"
     });
     const lines = result.trim().split("\n").filter(Boolean);
@@ -1408,21 +1407,21 @@ function getGitData(config) {
   };
   let branch = null;
   try {
-    const result = execFn(commands.branch, { encoding: "utf-8" });
+    const result = execSync(commands.branch, { encoding: "utf-8" });
     branch = result.trim();
   } catch {
     branch = null;
   }
   let commits = [];
   try {
-    const result = execFn(commands.commits, { encoding: "utf-8" });
+    const result = execSync(commands.commits, { encoding: "utf-8" });
     commits = parseCommitsOutput(result);
   } catch {
     commits = [];
   }
   let stats = { added: 0, deleted: 0, files: 0 };
   try {
-    const result = execFn(commands.stats, { encoding: "utf-8" });
+    const result = execSync(commands.stats, { encoding: "utf-8" });
     stats = parseStatsOutput(result);
   } catch {
     stats = { added: 0, deleted: 0, files: 0 };
@@ -1462,29 +1461,249 @@ async function getGitDataAsync(config) {
 }
 
 // src/data/tests.ts
-import { readFileSync as nodeReadFileSync } from "fs";
-import { execSync as nodeExecSync2 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { execSync as execSync3 } from "child_process";
 import { join } from "path";
-var AGENT_DIR = ".agenthud";
-var TEST_RESULTS_FILE = "test-results.json";
-var readFileFn = (path) => nodeReadFileSync(path, "utf-8");
-var getHeadHashFn = () => {
-  return nodeExecSync2("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+
+// src/runner/command.ts
+import { execSync as execSync2 } from "child_process";
+import {
+  existsSync as existsSync2,
+  unlinkSync,
+  readFileSync as readFileSync2
+} from "fs";
+
+// src/data/detectTestFramework.ts
+import {
+  existsSync,
+  readFileSync
+} from "fs";
+var TEST_RESULTS_FILE = ".agenthud/test-results.xml";
+var FRAMEWORK_COMMANDS = {
+  vitest: `npx vitest run --reporter=junit --outputFile=${TEST_RESULTS_FILE}`,
+  jest: `JEST_JUNIT_OUTPUT_FILE=${TEST_RESULTS_FILE} npx jest --reporters=jest-junit`,
+  mocha: `npx mocha --reporter mocha-junit-reporter --reporter-options mochaFile=${TEST_RESULTS_FILE}`,
+  pytest: `uv run pytest --junitxml=${TEST_RESULTS_FILE}`
 };
-var getCommitCountFn = (fromHash) => {
-  const result = nodeExecSync2(`git rev-list ${fromHash}..HEAD --count`, {
+var JS_FRAMEWORKS = ["vitest", "jest", "mocha"];
+function detectTestFramework() {
+  const jsFramework = detectJsFramework();
+  if (jsFramework) {
+    return jsFramework;
+  }
+  const pythonFramework = detectPythonFramework();
+  if (pythonFramework) {
+    return pythonFramework;
+  }
+  return null;
+}
+function detectJsFramework() {
+  if (!existsSync("package.json")) {
+    return null;
+  }
+  let packageJson;
+  try {
+    const content = readFileSync("package.json", "utf-8");
+    packageJson = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  for (const framework of JS_FRAMEWORKS) {
+    if (allDeps[framework]) {
+      return {
+        framework,
+        command: FRAMEWORK_COMMANDS[framework]
+      };
+    }
+  }
+  return null;
+}
+function detectPythonFramework() {
+  const pytestIndicators = ["pytest.ini", "conftest.py"];
+  for (const file of pytestIndicators) {
+    if (existsSync(file)) {
+      return {
+        framework: "pytest",
+        command: FRAMEWORK_COMMANDS.pytest
+      };
+    }
+  }
+  if (existsSync("pyproject.toml")) {
+    try {
+      const content = readFileSync("pyproject.toml", "utf-8");
+      if (content.includes("[tool.pytest") || content.includes("[tool.pytest.ini_options]")) {
+        return {
+          framework: "pytest",
+          command: FRAMEWORK_COMMANDS.pytest
+        };
+      }
+    } catch {
+    }
+  }
+  const requirementsFiles = ["requirements.txt", "requirements-dev.txt"];
+  for (const file of requirementsFiles) {
+    if (existsSync(file)) {
+      try {
+        const content = readFileSync(file, "utf-8");
+        if (content.includes("pytest")) {
+          return {
+            framework: "pytest",
+            command: FRAMEWORK_COMMANDS.pytest
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// src/runner/command.ts
+function parseJUnitXml(xml) {
+  try {
+    if (!xml.includes("<testsuite") && !xml.includes("<testsuites")) {
+      return null;
+    }
+    let totalTests = 0;
+    let totalErrors = 0;
+    let totalFailures = 0;
+    let totalSkipped = 0;
+    const failures = [];
+    const testsuiteMatches = xml.match(/<testsuite\b[^>]*(?:\/>|>[\s\S]*?<\/testsuite>)/g) || [];
+    const testsuites = testsuiteMatches.length > 0 ? testsuiteMatches : [xml];
+    for (const suite of testsuites) {
+      const suiteTag = suite.match(/<testsuite[^>]*>/)?.[0] || "";
+      const testsMatch = suiteTag.match(/tests="(\d+)"/);
+      const errorsMatch = suiteTag.match(/errors="(\d+)"/);
+      const failuresMatch = suiteTag.match(/failures="(\d+)"/);
+      const skippedMatch = suiteTag.match(/skipped="(\d+)"/);
+      totalTests += testsMatch ? parseInt(testsMatch[1], 10) : 0;
+      totalErrors += errorsMatch ? parseInt(errorsMatch[1], 10) : 0;
+      totalFailures += failuresMatch ? parseInt(failuresMatch[1], 10) : 0;
+      totalSkipped += skippedMatch ? parseInt(skippedMatch[1], 10) : 0;
+      const testcaseRegex = /<testcase[^>]*classname="([^"]*)"[^>]*name="([^"]*)"[^/>]*(?:\/>|>[\s\S]*?<\/testcase>)/g;
+      let testcaseMatch;
+      while ((testcaseMatch = testcaseRegex.exec(suite)) !== null) {
+        const testcaseContent = testcaseMatch[0];
+        const classname = testcaseMatch[1];
+        const name = testcaseMatch[2];
+        if (testcaseContent.includes("<failure") || testcaseContent.includes("<error")) {
+          failures.push({
+            file: classname,
+            name
+          });
+        }
+      }
+    }
+    if (totalTests === 0 && testsuiteMatches.length === 0) {
+      return null;
+    }
+    const failed = totalFailures + totalErrors;
+    const passed = totalTests - failed - totalSkipped;
+    return {
+      passed,
+      failed,
+      skipped: totalSkipped,
+      failures
+    };
+  } catch {
+    return null;
+  }
+}
+function getHeadHash() {
+  try {
+    return execSync2("git rev-parse --short HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function runTestCommand(command, source = TEST_RESULTS_FILE) {
+  try {
+    if (existsSync2(source)) {
+      unlinkSync(source);
+    }
+  } catch {
+  }
+  try {
+    execSync2(command, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  if (!existsSync2(source)) {
+    return {
+      results: null,
+      isOutdated: false,
+      commitsBehind: 0,
+      error: "Test command failed to produce output file"
+    };
+  }
+  let content;
+  try {
+    content = readFileSync2(source, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      results: null,
+      isOutdated: false,
+      commitsBehind: 0,
+      error: `Failed to read result file: ${message}`
+    };
+  }
+  const parsed = parseJUnitXml(content);
+  if (!parsed) {
+    return {
+      results: null,
+      isOutdated: false,
+      commitsBehind: 0,
+      error: "Failed to parse test results XML"
+    };
+  }
+  const hash = getHeadHash();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const results = {
+    hash,
+    timestamp,
+    passed: parsed.passed,
+    failed: parsed.failed,
+    skipped: parsed.skipped,
+    failures: parsed.failures
+  };
+  return {
+    results,
+    isOutdated: false,
+    commitsBehind: 0
+  };
+}
+
+// src/data/tests.ts
+var AGENT_DIR = ".agenthud";
+var TEST_RESULTS_FILE2 = "test-results.json";
+function getHeadHash2() {
+  return execSync3("git rev-parse --short HEAD", { encoding: "utf-8" }).trim();
+}
+function getCommitCount(fromHash) {
+  const result = execSync3(`git rev-list ${fromHash}..HEAD --count`, {
     encoding: "utf-8"
   }).trim();
   return parseInt(result, 10) || 0;
-};
+}
 function getTestData(dir = process.cwd()) {
-  const testResultsPath = join(dir, AGENT_DIR, TEST_RESULTS_FILE);
+  const testResultsPath = join(dir, AGENT_DIR, TEST_RESULTS_FILE2);
   let results = null;
   let isOutdated = false;
   let commitsBehind = 0;
   let error;
   try {
-    const content = readFileFn(testResultsPath);
+    const content = readFileSync3(testResultsPath, "utf-8");
     results = JSON.parse(content);
   } catch (e) {
     if (e instanceof SyntaxError) {
@@ -1495,10 +1714,10 @@ function getTestData(dir = process.cwd()) {
     return { results: null, isOutdated: false, commitsBehind: 0, error };
   }
   try {
-    const currentHash = getHeadHashFn();
+    const currentHash = getHeadHash2();
     if (results.hash !== currentHash) {
       isOutdated = true;
-      commitsBehind = getCommitCountFn(results.hash);
+      commitsBehind = getCommitCount(results.hash);
     }
   } catch {
     isOutdated = false;
@@ -1508,16 +1727,12 @@ function getTestData(dir = process.cwd()) {
 }
 
 // src/data/project.ts
-import { execSync as nodeExecSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import {
-  existsSync as nodeExistsSync,
-  readFileSync as nodeReadFileSync2,
-  readdirSync as nodeReaddirSync
+  existsSync as existsSync3,
+  readFileSync as readFileSync4
 } from "fs";
 import { basename } from "path";
-var fileExistsFn = nodeExistsSync;
-var readFileFn2 = (path) => nodeReadFileSync2(path, "utf-8");
-var execFn2 = (cmd, opts) => nodeExecSync3(cmd, opts);
 var LANGUAGE_INDICATORS = [
   { file: "tsconfig.json", language: "TypeScript" },
   { file: "package.json", language: "JavaScript" },
@@ -1587,7 +1802,7 @@ var SOURCE_DIRS = ["src", "lib", "app"];
 var EXCLUDE_DIRS = ["node_modules", "dist", "build", ".git", "__pycache__", "venv", ".venv", "target"];
 function detectLanguage() {
   for (const { file, language } of LANGUAGE_INDICATORS) {
-    if (fileExistsFn(file)) {
+    if (existsSync3(file)) {
       return language;
     }
   }
@@ -1716,29 +1931,29 @@ function parseSetupPy(content) {
 }
 function getFolderName() {
   try {
-    return execFn2('basename "$PWD"', { encoding: "utf-8" }).trim();
+    return execSync4('basename "$PWD"', { encoding: "utf-8" }).trim();
   } catch {
     return basename(process.cwd());
   }
 }
 function getProjectInfo() {
-  if (fileExistsFn("package.json")) {
+  if (existsSync3("package.json")) {
     try {
-      const content = readFileFn2("package.json");
+      const content = readFileSync4("package.json", "utf-8");
       return parsePackageJson(content);
     } catch {
     }
   }
-  if (fileExistsFn("pyproject.toml")) {
+  if (existsSync3("pyproject.toml")) {
     try {
-      const content = readFileFn2("pyproject.toml");
+      const content = readFileSync4("pyproject.toml", "utf-8");
       return parsePyprojectToml(content);
     } catch {
     }
   }
-  if (fileExistsFn("setup.py")) {
+  if (existsSync3("setup.py")) {
     try {
-      const content = readFileFn2("setup.py");
+      const content = readFileSync4("setup.py", "utf-8");
       return parseSetupPy(content);
     } catch {
     }
@@ -1769,7 +1984,7 @@ function detectStack(deps) {
 }
 function findSourceDir() {
   for (const dir of SOURCE_DIRS) {
-    if (fileExistsFn(dir)) {
+    if (existsSync3(dir)) {
       return dir;
     }
   }
@@ -1788,7 +2003,7 @@ function countFiles(language) {
     const excludes = EXCLUDE_DIRS.map((d) => `-path "*/${d}/*"`).join(" -o ");
     const namePatterns = config.patterns.map((p) => `-name "${p}"`).join(" -o ");
     const cmd = `find ${sourceDir} \\( ${excludes} \\) -prune -o -type f \\( ${namePatterns} \\) -print | wc -l`;
-    const result = execFn2(cmd, { encoding: "utf-8" });
+    const result = execSync4(cmd, { encoding: "utf-8" });
     const count = parseInt(result.trim(), 10) || 0;
     return { count, extension: config.ext };
   } catch {
@@ -1808,7 +2023,7 @@ function countLines(language) {
     const excludes = EXCLUDE_DIRS.map((d) => `-path "*/${d}/*"`).join(" -o ");
     const namePatterns = config.patterns.map((p) => `-name "${p}"`).join(" -o ");
     const cmd = `find ${sourceDir} \\( ${excludes} \\) -prune -o -type f \\( ${namePatterns} \\) -print0 | xargs -0 wc -l 2>/dev/null | tail -1 | awk '{print $1}'`;
-    const result = execFn2(cmd, { encoding: "utf-8" });
+    const result = execSync4(cmd, { encoding: "utf-8" });
     return parseInt(result.trim(), 10) || 0;
   } catch {
     return 0;
@@ -1851,10 +2066,10 @@ function getProjectData() {
 
 // src/data/claude.ts
 import {
-  existsSync as nodeExistsSync2,
-  readFileSync as nodeReadFileSync3,
-  readdirSync as nodeReaddirSync2,
-  statSync as nodeStatSync
+  existsSync as existsSync4,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
+  statSync
 } from "fs";
 import { homedir } from "os";
 import { join as join2, basename as basename2 } from "path";
@@ -1881,12 +2096,6 @@ var ICONS = {
 };
 
 // src/data/claude.ts
-var fs = {
-  existsSync: nodeExistsSync2,
-  readFileSync: (path) => nodeReadFileSync3(path, "utf-8"),
-  readdirSync: (path) => nodeReaddirSync2(path),
-  statSync: nodeStatSync
-};
 var MAX_LINES_TO_SCAN = 200;
 var DEFAULT_MAX_ACTIVITIES = 10;
 function getClaudeSessionPath(projectPath) {
@@ -1894,10 +2103,10 @@ function getClaudeSessionPath(projectPath) {
   return join2(homedir(), ".claude", "projects", encoded);
 }
 function findActiveSession(sessionDir, sessionTimeout) {
-  if (!fs.existsSync(sessionDir)) {
+  if (!existsSync4(sessionDir)) {
     return null;
   }
-  const files = fs.readdirSync(sessionDir);
+  const files = readdirSync2(sessionDir);
   const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
   if (jsonlFiles.length === 0) {
     return null;
@@ -1907,7 +2116,7 @@ function findActiveSession(sessionDir, sessionTimeout) {
   let latestSize = 0;
   for (const file of jsonlFiles) {
     const filePath = join2(sessionDir, file);
-    const stat = fs.statSync(filePath);
+    const stat = statSync(filePath);
     if (stat.mtimeMs > latestMtime || stat.mtimeMs === latestMtime && stat.size > latestSize) {
       latestMtime = stat.mtimeMs;
       latestSize = stat.size;
@@ -1947,12 +2156,12 @@ function parseSessionState(sessionFile, maxActivities = DEFAULT_MAX_ACTIVITIES)
     sessionStartTime: null,
     todos: null
   };
-  if (!fs.existsSync(sessionFile)) {
+  if (!existsSync4(sessionFile)) {
     return defaultState;
   }
   let content;
   try {
-    content = fs.readFileSync(sessionFile);
+    content = readFileSync5(sessionFile, "utf-8");
   } catch {
     return defaultState;
   }
@@ -2090,13 +2299,13 @@ function parseSessionState(sessionFile, maxActivities = DEFAULT_MAX_ACTIVITIES)
     }
   }
   const subagentsDir = join2(sessionFile.replace(/\.jsonl$/, ""), "subagents");
-  if (fs.existsSync(subagentsDir)) {
+  if (existsSync4(subagentsDir)) {
     try {
-      const subagentFiles = fs.readdirSync(subagentsDir).filter((f) => f.endsWith(".jsonl"));
+      const subagentFiles = readdirSync2(subagentsDir).filter((f) => f.endsWith(".jsonl"));
       for (const file of subagentFiles) {
         const filePath = join2(subagentsDir, file);
         try {
-          const subContent = fs.readFileSync(filePath);
+          const subContent = readFileSync5(filePath, "utf-8");
           const subLines = subContent.trim().split("\n").filter(Boolean);
           for (const line of subLines) {
             try {
@@ -2133,7 +2342,7 @@ function getClaudeData(projectPath, maxActivities, sessionTimeout = DEFAULT_SESS
   };
   try {
     const sessionDir = getClaudeSessionPath(projectPath);
-    const hasSession = fs.existsSync(sessionDir);
+    const hasSession = existsSync4(sessionDir);
     const sessionFile = findActiveSession(sessionDir, sessionTimeout);
     if (!sessionFile) {
       return {
@@ -2161,26 +2370,20 @@ function getClaudeData(projectPath, maxActivities, sessionTimeout = DEFAULT_SESS
 
 // src/data/otherSessions.ts
 import {
-  existsSync as nodeExistsSync3,
-  readFileSync as nodeReadFileSync4,
-  readdirSync as nodeReaddirSync3,
-  statSync as nodeStatSync2
+  existsSync as existsSync5,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync3,
+  statSync as statSync2
 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3, basename as basename3, sep } from "path";
-var fs2 = {
-  existsSync: nodeExistsSync3,
-  readFileSync: (path) => nodeReadFileSync4(path, "utf-8"),
-  readdirSync: (path) => nodeReaddirSync3(path),
-  statSync: nodeStatSync2
-};
 var MAX_LINES_TO_SCAN2 = 100;
 function getProjectsDir() {
   return join3(homedir2(), ".claude", "projects");
 }
 function decodeProjectPath(encoded) {
   const naiveDecoded = encoded.replace(/-/g, sep);
-  if (fs2.existsSync(naiveDecoded)) {
+  if (existsSync5(naiveDecoded)) {
     return naiveDecoded;
   }
   const segments = encoded.split("-").filter(Boolean);
@@ -2195,9 +2398,9 @@ function decodeProjectPath(encoded) {
       const segment = segments.slice(i, j).join("-");
       const testPath = currentPath ? join3(currentPath, segment) : sep + segment;
       try {
-        if (fs2.existsSync(testPath)) {
-          const stat = fs2.statSync(testPath);
-          if (stat.isDirectory?.()) {
+        if (existsSync5(testPath)) {
+          const stat = statSync2(testPath);
+          if (stat.isDirectory()) {
             currentPath = testPath;
             i = j;
             found = true;
@@ -2216,16 +2419,16 @@ function decodeProjectPath(encoded) {
 }
 function getAllProjects() {
   const projectsDir = getProjectsDir();
-  if (!fs2.existsSync(projectsDir)) {
+  if (!existsSync5(projectsDir)) {
     return [];
   }
-  const entries = fs2.readdirSync(projectsDir);
+  const entries = readdirSync3(projectsDir);
   const projects = [];
   for (const entry of entries) {
     const fullPath = join3(projectsDir, entry);
     try {
-      const stat = fs2.statSync(fullPath);
-      if (stat.isDirectory?.()) {
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
         projects.push({
           encodedPath: entry,
           decodedPath: decodeProjectPath(entry)
@@ -2237,12 +2440,12 @@ function getAllProjects() {
   return projects;
 }
 function parseLastAssistantMessage(sessionFile) {
-  if (!fs2.existsSync(sessionFile)) {
+  if (!existsSync5(sessionFile)) {
     return null;
   }
   let content;
   try {
-    content = fs2.readFileSync(sessionFile);
+    content = readFileSync6(sessionFile, "utf-8");
   } catch {
     return null;
   }
@@ -2290,12 +2493,12 @@ function formatRelativeTime2(date) {
   return `${days}d ago`;
 }
 function findMostRecentSession(projectDir) {
-  if (!fs2.existsSync(projectDir)) {
+  if (!existsSync5(projectDir)) {
     return null;
   }
   let files;
   try {
-    files = fs2.readdirSync(projectDir);
+    files = readdirSync3(projectDir);
   } catch {
     return null;
   }
@@ -2308,7 +2511,7 @@ function findMostRecentSession(projectDir) {
   for (const file of jsonlFiles) {
     const filePath = join3(projectDir, file);
     try {
-      const stat = fs2.statSync(filePath);
+      const stat = statSync2(filePath);
       if (stat.mtimeMs && stat.mtimeMs > latestMtime) {
         latestMtime = stat.mtimeMs;
         latestFile = filePath;
@@ -2331,7 +2534,7 @@ function getOtherSessionsData(currentProjectPath, options2 = {}) {
     recentSession: null,
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (!fs2.existsSync(projectsDir)) {
+  if (!existsSync5(projectsDir)) {
     return defaultResult;
   }
   const allProjects = getAllProjects();
@@ -2388,12 +2591,10 @@ function getOtherSessionsData(currentProjectPath, options2 = {}) {
 }
 
 // src/data/custom.ts
-import { execSync as nodeExecSync4, exec as nodeExec2 } from "child_process";
-import { readFileSync as nodeReadFileSync5, promises as fsPromises } from "fs";
+import { execSync as execSync5, exec as exec2 } from "child_process";
+import { readFileSync as readFileSync7, promises as fsPromises } from "fs";
 import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(nodeExec2);
-var execFn3 = (cmd, options2) => nodeExecSync4(cmd, options2);
-var readFileFn3 = (path) => nodeReadFileSync5(path, "utf-8");
+var execAsync2 = promisify2(exec2);
 function capitalizeFirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -2404,7 +2605,7 @@ function getCustomPanelData(name, panelConfig) {
   };
   if (panelConfig.command) {
     try {
-      const output = execFn3(panelConfig.command, { encoding: "utf-8" }).trim();
+      const output = execSync5(panelConfig.command, { encoding: "utf-8" }).trim();
       try {
         const parsed = JSON.parse(output);
         return {
@@ -2438,7 +2639,7 @@ function getCustomPanelData(name, panelConfig) {
   }
   if (panelConfig.source) {
     try {
-      const content = readFileFn3(panelConfig.source);
+      const content = readFileSync7(panelConfig.source, "utf-8");
       const parsed = JSON.parse(content);
       return {
         data: {
@@ -2549,98 +2750,12 @@ async function getCustomPanelDataAsync(name, panelConfig) {
   };
 }
 
-// src/runner/command.ts
-import { execSync as nodeExecSync5 } from "child_process";
-var execFn4 = (command, options2) => nodeExecSync5(command, options2);
-function parseVitestOutput(output) {
-  try {
-    const data = JSON.parse(output);
-    if (typeof data.numPassedTests !== "number" || typeof data.numFailedTests !== "number") {
-      return null;
-    }
-    const failures = [];
-    for (const testResult of data.testResults || []) {
-      for (const assertion of testResult.assertionResults || []) {
-        if (assertion.status === "failed") {
-          failures.push({
-            file: testResult.name,
-            name: assertion.title
-          });
-        }
-      }
-    }
-    return {
-      passed: data.numPassedTests,
-      failed: data.numFailedTests,
-      skipped: data.numPendingTests || 0,
-      failures
-    };
-  } catch {
-    return null;
-  }
-}
-function getHeadHash() {
-  try {
-    return execFn4("git rev-parse --short HEAD", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-function runTestCommand(command) {
-  let output;
-  try {
-    output = execFn4(command, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      results: null,
-      isOutdated: false,
-      commitsBehind: 0,
-      error: message
-    };
-  }
-  const parsed = parseVitestOutput(output);
-  if (!parsed) {
-    return {
-      results: null,
-      isOutdated: false,
-      commitsBehind: 0,
-      error: "Failed to parse test output"
-    };
-  }
-  const hash = getHeadHash();
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const results = {
-    hash,
-    timestamp,
-    passed: parsed.passed,
-    failed: parsed.failed,
-    skipped: parsed.skipped,
-    failures: parsed.failures
-  };
-  return {
-    results,
-    isOutdated: false,
-    commitsBehind: 0
-  };
-}
-
 // src/config/parser.ts
 import {
-  existsSync as nodeExistsSync4,
-  readFileSync as nodeReadFileSync6
+  existsSync as existsSync6,
+  readFileSync as readFileSync8
 } from "fs";
 import { parse as parseYaml } from "yaml";
-var fs3 = {
-  existsSync: nodeExistsSync4,
-  readFileSync: (path) => nodeReadFileSync6(path, "utf-8")
-};
 var DEFAULT_WIDTH = DEFAULT_PANEL_WIDTH;
 var MIN_WIDTH = MIN_TERMINAL_WIDTH;
 var MAX_WIDTH = MAX_TERMINAL_WIDTH;
@@ -2718,12 +2833,12 @@ function parseBasePanelConfig(panelConfig, targetConfig, panelName, warnings) {
 function parseConfig() {
   const warnings = [];
   const defaultConfig = getDefaultConfig();
-  if (!fs3.existsSync(CONFIG_PATH)) {
+  if (!existsSync6(CONFIG_PATH)) {
     return { config: defaultConfig, warnings };
   }
   let rawConfig;
   try {
-    const content = fs3.readFileSync(CONFIG_PATH);
+    const content = readFileSync8(CONFIG_PATH, "utf-8");
     rawConfig = parseYaml(content);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -2838,7 +2953,7 @@ function parseConfig() {
 }
 
 // src/cli.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { dirname, join as join4 } from "path";
 import { fileURLToPath } from "url";
 function getHelp() {
@@ -2857,13 +2972,12 @@ Options:
 function getVersion() {
   const __dirname3 = dirname(fileURLToPath(import.meta.url));
   const packageJson = JSON.parse(
-    readFileSync(join4(__dirname3, "..", "package.json"), "utf-8")
+    readFileSync9(join4(__dirname3, "..", "package.json"), "utf-8")
   );
   return packageJson.version;
 }
-var clearFn = () => console.clear();
 function clearScreen() {
-  clearFn();
+  console.clear();
 }
 function parseArgs(args) {
   const hasOnce = args.includes("--once");
@@ -2985,7 +3099,7 @@ function DashboardApp({ mode }) {
   }, [config.panels.tests.command]);
   const initialTestData = useMemo3(() => getTestDataFromConfig(), [getTestDataFromConfig]);
   const [testsDisabled, setTestsDisabled] = useState4(
-    !!(initialTestData.error && config.panels.tests.command)
+    !!(initialTestData.error && !config.panels.tests.command)
   );
   const [testData, setTestData] = useState4(initialTestData);
   const [customPanelData, setCustomPanelData] = useState4(() => {
@@ -3272,124 +3386,23 @@ function App({ mode, agentDirExists: agentDirExists2 = true }) {
 
 // src/commands/init.ts
 import {
-  existsSync as nodeExistsSync6,
-  mkdirSync as nodeMkdirSync,
-  writeFileSync as nodeWriteFileSync,
-  readFileSync as nodeReadFileSync8,
-  appendFileSync as nodeAppendFileSync
+  existsSync as existsSync7,
+  mkdirSync,
+  writeFileSync,
+  readFileSync as readFileSync10,
+  appendFileSync
 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname2, join as join5 } from "path";
 import { homedir as homedir3 } from "os";
-
-// src/data/detectTestFramework.ts
-import {
-  existsSync as nodeExistsSync5,
-  readFileSync as nodeReadFileSync7
-} from "fs";
-var fs4 = {
-  existsSync: nodeExistsSync5,
-  readFileSync: (path) => nodeReadFileSync7(path, "utf-8")
-};
-var FRAMEWORK_COMMANDS = {
-  vitest: "npx vitest run --reporter=json",
-  jest: "npx jest --json",
-  mocha: "npx mocha --reporter=json",
-  pytest: "pytest --json-report --json-report-file=.agenthud/test-results.json"
-};
-var JS_FRAMEWORKS = ["vitest", "jest", "mocha"];
-function detectTestFramework() {
-  const jsFramework = detectJsFramework();
-  if (jsFramework) {
-    return jsFramework;
-  }
-  const pythonFramework = detectPythonFramework();
-  if (pythonFramework) {
-    return pythonFramework;
-  }
-  return null;
-}
-function detectJsFramework() {
-  if (!fs4.existsSync("package.json")) {
-    return null;
-  }
-  let packageJson;
-  try {
-    const content = fs4.readFileSync("package.json");
-    packageJson = JSON.parse(content);
-  } catch {
-    return null;
-  }
-  const allDeps = {
-    ...packageJson.dependencies,
-    ...packageJson.devDependencies
-  };
-  for (const framework of JS_FRAMEWORKS) {
-    if (allDeps[framework]) {
-      return {
-        framework,
-        command: FRAMEWORK_COMMANDS[framework]
-      };
-    }
-  }
-  return null;
-}
-function detectPythonFramework() {
-  const pytestIndicators = ["pytest.ini", "conftest.py"];
-  for (const file of pytestIndicators) {
-    if (fs4.existsSync(file)) {
-      return {
-        framework: "pytest",
-        command: FRAMEWORK_COMMANDS.pytest
-      };
-    }
-  }
-  if (fs4.existsSync("pyproject.toml")) {
-    try {
-      const content = fs4.readFileSync("pyproject.toml");
-      if (content.includes("[tool.pytest") || content.includes("[tool.pytest.ini_options]")) {
-        return {
-          framework: "pytest",
-          command: FRAMEWORK_COMMANDS.pytest
-        };
-      }
-    } catch {
-    }
-  }
-  const requirementsFiles = ["requirements.txt", "requirements-dev.txt"];
-  for (const file of requirementsFiles) {
-    if (fs4.existsSync(file)) {
-      try {
-        const content = fs4.readFileSync(file);
-        if (content.includes("pytest")) {
-          return {
-            framework: "pytest",
-            command: FRAMEWORK_COMMANDS.pytest
-          };
-        }
-      } catch {
-      }
-    }
-  }
-  return null;
-}
-
-// src/commands/init.ts
-var fs5 = {
-  existsSync: nodeExistsSync6,
-  mkdirSync: nodeMkdirSync,
-  writeFileSync: nodeWriteFileSync,
-  readFileSync: (path) => nodeReadFileSync8(path, "utf-8"),
-  appendFileSync: nodeAppendFileSync
-};
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 function getDefaultConfig2() {
   let templatePath = join5(__dirname2, "templates", "config.yaml");
-  if (!nodeExistsSync6(templatePath)) {
+  if (!existsSync7(templatePath)) {
     templatePath = join5(__dirname2, "..", "templates", "config.yaml");
   }
-  return nodeReadFileSync8(templatePath, "utf-8");
+  return readFileSync10(templatePath, "utf-8");
 }
 function getClaudeSessionPath2(projectPath) {
   const encoded = projectPath.replace(/[/\\]/g, "-");
@@ -3401,14 +3414,14 @@ function runInit(cwd = process.cwd()) {
     skipped: [],
     warnings: []
   };
-  if (!fs5.existsSync(".agenthud")) {
-    fs5.mkdirSync(".agenthud", { recursive: true });
+  if (!existsSync7(".agenthud")) {
+    mkdirSync(".agenthud", { recursive: true });
     result.created.push(".agenthud/");
   } else {
     result.skipped.push(".agenthud/");
   }
-  if (!fs5.existsSync(".agenthud/tests")) {
-    fs5.mkdirSync(".agenthud/tests", { recursive: true });
+  if (!existsSync7(".agenthud/tests")) {
+    mkdirSync(".agenthud/tests", { recursive: true });
     result.created.push(".agenthud/tests/");
   } else {
     result.skipped.push(".agenthud/tests/");
@@ -3417,7 +3430,7 @@ function runInit(cwd = process.cwd()) {
   if (testFramework) {
     result.detectedTestFramework = testFramework.framework;
   }
-  if (!fs5.existsSync(".agenthud/config.yaml")) {
+  if (!existsSync7(".agenthud/config.yaml")) {
     let configContent = getDefaultConfig2();
     if (testFramework) {
       configContent = configContent.replace(
@@ -3430,28 +3443,28 @@ function runInit(cwd = process.cwd()) {
         "# command: (auto-detect failed - configure manually)"
       );
     }
-    fs5.writeFileSync(".agenthud/config.yaml", configContent);
+    writeFileSync(".agenthud/config.yaml", configContent);
     result.created.push(".agenthud/config.yaml");
   } else {
     result.skipped.push(".agenthud/config.yaml");
   }
-  if (!fs5.existsSync(".gitignore")) {
-    fs5.writeFileSync(".gitignore", ".agenthud/\n");
+  if (!existsSync7(".gitignore")) {
+    writeFileSync(".gitignore", ".agenthud/\n");
     result.created.push(".gitignore");
   } else {
-    const content = fs5.readFileSync(".gitignore");
+    const content = readFileSync10(".gitignore", "utf-8");
     if (!content.includes(".agenthud/")) {
-      fs5.appendFileSync(".gitignore", "\n.agenthud/\n");
+      appendFileSync(".gitignore", "\n.agenthud/\n");
       result.created.push(".gitignore");
     } else {
       result.skipped.push(".gitignore");
     }
   }
-  if (!fs5.existsSync(".git")) {
+  if (!existsSync7(".git")) {
     result.warnings.push("Not a git repository - Git panel will show limited info");
   }
   const claudeSessionPath = getClaudeSessionPath2(cwd);
-  if (!fs5.existsSync(claudeSessionPath)) {
+  if (!existsSync7(claudeSessionPath)) {
     result.warnings.push("No Claude session found - start Claude to see activity");
   }
   return result;
@@ -3460,14 +3473,10 @@ function runInit(cwd = process.cwd()) {
 // src/utils/performance.ts
 import { performance } from "perf_hooks";
 var DEFAULT_CLEANUP_INTERVAL = 6e4;
-var perfFunctions = {
-  clearMarks: () => performance.clearMarks(),
-  clearMeasures: () => performance.clearMeasures()
-};
 var cleanupInterval = null;
 function clearPerformanceEntries() {
-  perfFunctions.clearMarks();
-  perfFunctions.clearMeasures();
+  performance.clearMarks();
+  performance.clearMeasures();
 }
 function startPerformanceCleanup(intervalMs = DEFAULT_CLEANUP_INTERVAL) {
   if (cleanupInterval !== null) {
@@ -3513,7 +3522,7 @@ if (options.command === "init") {
   console.log("  Run: npx agenthud\n");
   process.exit(0);
 }
-var agentDirExists = existsSync(".agenthud");
+var agentDirExists = existsSync8(".agenthud");
 if (options.mode === "watch") {
   clearScreen();
 }

package/dist/templates/config.yaml

@@ -21,7 +21,8 @@ panels:
     enabled: true
     interval: manual
     # command is auto-detected from: vitest, jest, mocha, pytest
-    command: npx vitest run --reporter=json
+    # all frameworks output JUnit XML to .agenthud/test-results.xml
+    command: npx vitest run --reporter=junit --outputFile=.agenthud/test-results.xml
 
   project:
     enabled: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenthud",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "CLI tool to monitor agent status in real-time. Works with Claude Code, multi-agent workflows, and any AI agent system.",
   "type": "module",
   "main": "dist/index.js",