agenthud 0.2.2 → 0.3.1

package/README.md

@@ -44,14 +44,14 @@ npx agenthud
 ## Features
 
 - **Git**: Branch, commits, line changes
-- **Plan**: Progress, decisions from `.agent/plan.json`
+- **Plan**: Progress, decisions from `.agenthud/plan.json`
 - **Tests**: Results with outdated detection
 
 ## Setup
 
 Add to your `CLAUDE.md`:
 ```markdown
-Maintain `.agent/` directory:
+Maintain `.agenthud/` directory:
 - Update `plan.json` when plan changes
 - Update `decisions.json` for key decisions
 ```

package/dist/index.js

@@ -6,7 +6,7 @@ import { render } from "ink";
 import { existsSync } from "fs";
 
 // src/ui/App.tsx
-import { useState, useEffect, useCallback } from "react";
+import React, { useState, useEffect, useCallback, useMemo } from "react";
 import { Box as Box5, Text as Text5, useApp, useInput } from "ink";
 
 // src/ui/GitPanel.tsx
@@ -15,6 +15,31 @@ import { Box, Text } from "ink";
 // src/ui/constants.ts
 var PANEL_WIDTH = 60;
 var CONTENT_WIDTH = PANEL_WIDTH - 4;
+var INNER_WIDTH = PANEL_WIDTH - 2;
+var BOX = {
+  tl: "\u250C",
+  tr: "\u2510",
+  bl: "\u2514",
+  br: "\u2518",
+  h: "\u2500",
+  v: "\u2502",
+  ml: "\u251C",
+  mr: "\u2524"
+};
+function createTitleLine(label, suffix = "") {
+  const leftPart = BOX.h + " " + label + " ";
+  const rightPart = suffix ? " " + suffix + " " + BOX.h : "";
+  const dashCount = PANEL_WIDTH - 1 - leftPart.length - rightPart.length - 1;
+  const dashes = BOX.h.repeat(Math.max(0, dashCount));
+  return BOX.tl + leftPart + dashes + rightPart + BOX.tr;
+}
+function createBottomLine() {
+  return BOX.bl + BOX.h.repeat(INNER_WIDTH) + BOX.br;
+}
+function padLine(content) {
+  const padding = INNER_WIDTH - content.length;
+  return content + " ".repeat(Math.max(0, padding));
+}
 var SEPARATOR = "\u2500".repeat(CONTENT_WIDTH);
 function truncate(text, maxLength) {
   if (text.length <= maxLength) return text;
@@ -25,11 +50,21 @@ function truncate(text, maxLength) {
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 var MAX_COMMITS = 5;
 var MAX_MESSAGE_LENGTH = CONTENT_WIDTH - 10;
-function GitPanel({ branch, commits, stats, uncommitted = 0 }) {
+function formatCountdown(seconds) {
+  if (seconds == null) return "";
+  return `\u21BB ${seconds}s`;
+}
+function GitPanel({ branch, commits, stats, uncommitted = 0, countdown }) {
+  const countdownSuffix = formatCountdown(countdown);
   if (branch === null) {
-    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, width: PANEL_WIDTH, children: [
-      /* @__PURE__ */ jsx(Box, { marginTop: -1, children: /* @__PURE__ */ jsx(Text, { children: " Git " }) }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Not a git repository" })
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: PANEL_WIDTH, children: [
+      /* @__PURE__ */ jsx(Text, { children: createTitleLine("Git", countdownSuffix) }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        BOX.v,
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: padLine(" Not a git repository") }),
+        BOX.v
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: createBottomLine() })
     ] });
   }
   const displayCommits = commits.slice(0, MAX_COMMITS);
@@ -37,9 +72,19 @@ function GitPanel({ branch, commits, stats, uncommitted = 0 }) {
   const commitWord = commits.length === 1 ? "commit" : "commits";
   const fileWord = stats.files === 1 ? "file" : "files";
   const hasUncommitted = uncommitted > 0;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "single", paddingX: 1, width: PANEL_WIDTH, children: [
-    /* @__PURE__ */ jsx(Box, { marginTop: -1, children: /* @__PURE__ */ jsx(Text, { children: " Git " }) }),
+  let branchLineLength = 1 + branch.length;
+  if (hasCommits) {
+    branchLineLength += ` \xB7 +${stats.added} -${stats.deleted} \xB7 ${commits.length} ${commitWord} \xB7 ${stats.files} ${fileWord}`.length;
+  }
+  if (hasUncommitted) {
+    branchLineLength += ` \xB7 ${uncommitted} dirty`.length;
+  }
+  const branchPadding = Math.max(0, INNER_WIDTH - branchLineLength);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: PANEL_WIDTH, children: [
+    /* @__PURE__ */ jsx(Text, { children: createTitleLine("Git", countdownSuffix) }),
     /* @__PURE__ */ jsxs(Text, { children: [
+      BOX.v,
+      " ",
       /* @__PURE__ */ jsx(Text, { color: "green", children: branch }),
       hasCommits && /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
@@ -69,21 +114,35 @@ function GitPanel({ branch, commits, stats, uncommitted = 0 }) {
           uncommitted,
           " dirty"
         ] })
-      ] })
+      ] }),
+      " ".repeat(branchPadding),
+      BOX.v
     ] }),
-    hasCommits ? /* @__PURE__ */ jsx(Fragment, { children: displayCommits.map((commit) => /* @__PURE__ */ jsxs(Text, { children: [
-      "\u2022 ",
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: commit.hash.slice(0, 7) }),
-      " ",
-      truncate(commit.message, MAX_MESSAGE_LENGTH)
-    ] }, commit.hash)) }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: "No commits today" })
+    hasCommits ? /* @__PURE__ */ jsx(Fragment, { children: displayCommits.map((commit) => {
+      const msg = truncate(commit.message, MAX_MESSAGE_LENGTH);
+      const lineLength = 3 + 7 + 1 + msg.length;
+      const commitPadding = Math.max(0, INNER_WIDTH - lineLength);
+      return /* @__PURE__ */ jsxs(Text, { children: [
+        BOX.v,
+        " \u2022 ",
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: commit.hash.slice(0, 7) }),
+        " ",
+        msg,
+        " ".repeat(commitPadding),
+        BOX.v
+      ] }, commit.hash);
+    }) }) : /* @__PURE__ */ jsxs(Text, { children: [
+      BOX.v,
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: padLine(" No commits today") }),
+      BOX.v
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: createBottomLine() })
   ] });
 }
 
 // src/ui/PlanPanel.tsx
 import { Box as Box2, Text as Text2 } from "ink";
 import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var BOX = { tl: "\u250C", tr: "\u2510", bl: "\u2514", br: "\u2518", h: "\u2500", v: "\u2502" };
 var PROGRESS_BAR_WIDTH = 10;
 var MAX_STEP_LENGTH = CONTENT_WIDTH - 2;
 var MAX_DECISION_LENGTH = CONTENT_WIDTH - 2;
@@ -93,37 +152,37 @@ function createProgressBar(done, total) {
   const empty = PROGRESS_BAR_WIDTH - filled;
   return "\u2588".repeat(filled) + "\u2591".repeat(empty);
 }
-var INNER_WIDTH = PANEL_WIDTH - 2;
-function createTitleLine(done, total) {
+function formatCountdown2(seconds) {
+  if (seconds == null) return "";
+  return `\u21BB ${seconds}s`;
+}
+function createPlanTitleLine(done, total, countdown) {
   const label = " Plan ";
   const count = ` ${done}/${total} `;
   const bar = createProgressBar(done, total);
-  const dashCount = PANEL_WIDTH - 3 - label.length - count.length - bar.length;
+  const countdownStr = formatCountdown2(countdown);
+  const suffix = countdownStr ? ` \xB7 ${countdownStr} ` + BOX.h : "";
+  const dashCount = PANEL_WIDTH - 3 - label.length - count.length - bar.length - suffix.length;
   const dashes = BOX.h.repeat(Math.max(0, dashCount));
-  return BOX.tl + BOX.h + label + dashes + count + bar + BOX.tr;
-}
-function createBottomLine() {
-  return BOX.bl + BOX.h.repeat(INNER_WIDTH) + BOX.br;
+  return BOX.tl + BOX.h + label + dashes + count + bar + suffix + BOX.tr;
 }
-function padLine(content) {
-  const padding = INNER_WIDTH - content.length;
-  return content + " ".repeat(Math.max(0, padding));
+function createSimpleTitleLine(countdown) {
+  const label = " Plan ";
+  const countdownStr = formatCountdown2(countdown);
+  const suffix = countdownStr ? ` ${countdownStr} ` + BOX.h : "";
+  const dashCount = PANEL_WIDTH - 3 - label.length - suffix.length;
+  const dashes = BOX.h.repeat(Math.max(0, dashCount));
+  return BOX.tl + BOX.h + label + dashes + suffix + BOX.tr;
 }
 function createDecisionsHeader() {
   const label = "\u2500 Decisions ";
   const dashCount = PANEL_WIDTH - 1 - label.length - 1;
   return label + "\u2500".repeat(dashCount) + "\u2524";
 }
-function PlanPanel({ plan, decisions, error }) {
+function PlanPanel({ plan, decisions, error, countdown }) {
   if (error || !plan || !plan.goal || !plan.steps) {
     return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: PANEL_WIDTH, children: [
-      /* @__PURE__ */ jsxs2(Text2, { children: [
-        BOX.tl,
-        BOX.h,
-        " Plan ",
-        BOX.h.repeat(INNER_WIDTH - 7),
-        BOX.tr
-      ] }),
+      /* @__PURE__ */ jsx2(Text2, { children: createSimpleTitleLine(countdown) }),
       /* @__PURE__ */ jsxs2(Text2, { children: [
         BOX.v,
         padLine(" " + (error || "No plan found")),
@@ -135,7 +194,7 @@ function PlanPanel({ plan, decisions, error }) {
   const doneCount = plan.steps.filter((s) => s.status === "done").length;
   const totalCount = plan.steps.length;
   return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", width: PANEL_WIDTH, children: [
-    /* @__PURE__ */ jsx2(Text2, { children: createTitleLine(doneCount, totalCount) }),
+    /* @__PURE__ */ jsx2(Text2, { children: createPlanTitleLine(doneCount, totalCount, countdown) }),
     /* @__PURE__ */ jsxs2(Text2, { children: [
       BOX.v,
       padLine(" " + truncate(plan.goal, CONTENT_WIDTH)),
@@ -182,6 +241,9 @@ function formatRelativeTime(timestamp) {
   if (diffHours < 24) return `${diffHours}h ago`;
   return `${diffDays}d ago`;
 }
+function createSeparator() {
+  return BOX.ml + BOX.h.repeat(INNER_WIDTH) + BOX.mr;
+}
 function TestPanel({
   results,
   isOutdated,
@@ -189,23 +251,37 @@ function TestPanel({
   error
 }) {
   if (error || !results) {
-    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "single", paddingX: 1, width: PANEL_WIDTH, children: [
-      /* @__PURE__ */ jsx3(Box3, { marginTop: -1, children: /* @__PURE__ */ jsx3(Text3, { children: " Tests " }) }),
-      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: error || "No test results" })
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: PANEL_WIDTH, children: [
+      /* @__PURE__ */ jsx3(Text3, { children: createTitleLine("Tests", "") }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        BOX.v,
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: padLine(" " + (error || "No test results")) }),
+        BOX.v
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: createBottomLine() })
     ] });
   }
   const hasFailures = results.failures.length > 0;
   const relativeTime = formatRelativeTime(results.timestamp);
-  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "single", paddingX: 1, width: PANEL_WIDTH, children: [
-    /* @__PURE__ */ jsx3(Box3, { marginTop: -1, children: /* @__PURE__ */ jsx3(Text3, { children: " Tests " }) }),
-    isOutdated && /* @__PURE__ */ jsxs3(Text3, { color: "yellow", children: [
-      "\u26A0 Outdated (",
-      commitsBehind,
-      " ",
-      commitsBehind === 1 ? "commit" : "commits",
-      " behind)"
+  let summaryLength = 1 + 2 + String(results.passed).length + " passed".length;
+  if (results.failed > 0) {
+    summaryLength += 2 + 2 + String(results.failed).length + " failed".length;
+  }
+  if (results.skipped > 0) {
+    summaryLength += 2 + 2 + String(results.skipped).length + " skipped".length;
+  }
+  summaryLength += " \xB7 ".length + results.hash.length;
+  const summaryPadding = Math.max(0, INNER_WIDTH - summaryLength);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width: PANEL_WIDTH, children: [
+    /* @__PURE__ */ jsx3(Text3, { children: createTitleLine("Tests", relativeTime) }),
+    isOutdated && /* @__PURE__ */ jsxs3(Text3, { children: [
+      BOX.v,
+      /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: padLine(` \u26A0 Outdated (${commitsBehind} ${commitsBehind === 1 ? "commit" : "commits"} behind)`) }),
+      BOX.v
     ] }),
     /* @__PURE__ */ jsxs3(Text3, { children: [
+      BOX.v,
+      " ",
       /* @__PURE__ */ jsxs3(Text3, { color: "green", children: [
         "\u2713 ",
         results.passed,
@@ -228,27 +304,42 @@ function TestPanel({
         ] })
       ] }),
       /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
-        " ",
-        "\xB7 ",
-        results.hash,
         " \xB7 ",
-        relativeTime
-      ] })
+        results.hash
+      ] }),
+      " ".repeat(summaryPadding),
+      BOX.v
     ] }),
     hasFailures && /* @__PURE__ */ jsxs3(Fragment3, { children: [
-      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: SEPARATOR }),
-      results.failures.map((failure, index) => /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
-          "\u2717 ",
-          truncate(failure.file, CONTENT_WIDTH - 2)
-        ] }),
-        /* @__PURE__ */ jsxs3(Text3, { children: [
-          "  ",
-          "\u2022 ",
-          truncate(failure.name, CONTENT_WIDTH - 4)
-        ] })
-      ] }, index))
-    ] })
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: createSeparator() }),
+      results.failures.map((failure, index) => {
+        const fileName = truncate(failure.file, CONTENT_WIDTH - 3);
+        const filePadding = Math.max(0, INNER_WIDTH - 3 - fileName.length);
+        const testName = truncate(failure.name, CONTENT_WIDTH - 5);
+        const testPadding = Math.max(0, INNER_WIDTH - 5 - testName.length);
+        return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs3(Text3, { children: [
+            BOX.v,
+            " ",
+            /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+              "\u2717 ",
+              fileName
+            ] }),
+            " ".repeat(filePadding),
+            BOX.v
+          ] }),
+          /* @__PURE__ */ jsxs3(Text3, { children: [
+            BOX.v,
+            "   ",
+            "\u2022 ",
+            testName,
+            " ".repeat(testPadding),
+            BOX.v
+          ] })
+        ] }, index);
+      })
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { children: createBottomLine() })
   ] });
 }
 
@@ -259,7 +350,7 @@ function WelcomePanel() {
   return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", borderStyle: "single", paddingX: 1, width: PANEL_WIDTH, children: [
     /* @__PURE__ */ jsx4(Box4, { marginTop: -1, children: /* @__PURE__ */ jsx4(Text4, { children: " Welcome to agenthud " }) }),
     /* @__PURE__ */ jsx4(Text4, { children: " " }),
-    /* @__PURE__ */ jsx4(Text4, { children: "  No .agent/ directory found." }),
+    /* @__PURE__ */ jsx4(Text4, { children: "  No .agenthud/ directory found." }),
     /* @__PURE__ */ jsx4(Text4, { children: " " }),
     /* @__PURE__ */ jsx4(Text4, { children: "  Quick setup:" }),
     /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "     npx agenthud init" }),
@@ -273,23 +364,40 @@ function WelcomePanel() {
 // src/data/git.ts
 import { execSync as nodeExecSync } from "child_process";
 var execFn = (command, options2) => nodeExecSync(command, options2);
-function getCurrentBranch() {
+function getUncommittedCount() {
   try {
-    const result = execFn("git branch --show-current", {
+    const result = execFn("git status --porcelain", {
       encoding: "utf-8"
     });
-    return result.trim();
+    const lines = result.trim().split("\n").filter(Boolean);
+    return lines.length;
   } catch {
-    return null;
+    return 0;
   }
 }
-function getTodayCommits() {
+var DEFAULT_COMMANDS = {
+  branch: "git branch --show-current",
+  commits: 'git log --since=midnight --format="%h|%aI|%s"',
+  stats: 'git log --since=midnight --numstat --format=""'
+};
+function getGitData(config) {
+  const commands = {
+    branch: config.command?.branch || DEFAULT_COMMANDS.branch,
+    commits: config.command?.commits || DEFAULT_COMMANDS.commits,
+    stats: config.command?.stats || DEFAULT_COMMANDS.stats
+  };
+  let branch = null;
   try {
-    const result = execFn('git log --since=midnight --format="%h|%aI|%s"', {
-      encoding: "utf-8"
-    });
+    const result = execFn(commands.branch, { encoding: "utf-8" });
+    branch = result.trim();
+  } catch {
+    branch = null;
+  }
+  let commits = [];
+  try {
+    const result = execFn(commands.commits, { encoding: "utf-8" });
     const lines = result.trim().split("\n").filter(Boolean);
-    return lines.map((line) => {
+    commits = lines.map((line) => {
       const [hash, timestamp, ...messageParts] = line.split("|");
       return {
         hash,
@@ -298,14 +406,11 @@ function getTodayCommits() {
       };
     });
   } catch {
-    return [];
+    commits = [];
   }
-}
-function getTodayStats() {
+  let stats = { added: 0, deleted: 0, files: 0 };
   try {
-    const result = execFn('git log --since=midnight --numstat --format=""', {
-      encoding: "utf-8"
-    });
+    const result = execFn(commands.stats, { encoding: "utf-8" });
     const lines = result.trim().split("\n").filter(Boolean);
     let added = 0;
     let deleted = 0;
@@ -320,34 +425,23 @@ function getTodayStats() {
       deleted += parseInt(deletedStr, 10) || 0;
       if (filename) filesSet.add(filename);
     }
-    return { added, deleted, files: filesSet.size };
-  } catch {
-    return { added: 0, deleted: 0, files: 0 };
-  }
-}
-function getUncommittedCount() {
-  try {
-    const result = execFn("git status --porcelain", {
-      encoding: "utf-8"
-    });
-    const lines = result.trim().split("\n").filter(Boolean);
-    return lines.length;
+    stats = { added, deleted, files: filesSet.size };
   } catch {
-    return 0;
+    stats = { added: 0, deleted: 0, files: 0 };
   }
+  const uncommitted = getUncommittedCount();
+  return { branch, commits, stats, uncommitted };
 }
 
 // src/data/plan.ts
 import { readFileSync as nodeReadFileSync } from "fs";
-import { join } from "path";
-var AGENT_DIR = ".agent";
-var PLAN_FILE = "plan.json";
-var DECISIONS_FILE = "decisions.json";
+import { join, dirname } from "path";
 var MAX_DECISIONS = 3;
 var readFileFn = (path) => nodeReadFileSync(path, "utf-8");
-function getPlanData(dir = process.cwd()) {
-  const planPath = join(dir, AGENT_DIR, PLAN_FILE);
-  const decisionsPath = join(dir, AGENT_DIR, DECISIONS_FILE);
+function getPlanDataWithConfig(config) {
+  const planPath = config.source;
+  const planDir = dirname(planPath);
+  const decisionsPath = join(planDir, "decisions.json");
   let plan = null;
   let decisions = [];
   let error;
@@ -376,7 +470,7 @@ function getPlanData(dir = process.cwd()) {
 import { readFileSync as nodeReadFileSync2 } from "fs";
 import { execSync as nodeExecSync2 } from "child_process";
 import { join as join2 } from "path";
-var AGENT_DIR2 = ".agent";
+var AGENT_DIR = ".agenthud";
 var TEST_RESULTS_FILE = "test-results.json";
 var readFileFn2 = (path) => nodeReadFileSync2(path, "utf-8");
 var getHeadHashFn = () => {
@@ -389,7 +483,7 @@ var getCommitCountFn = (fromHash) => {
   return parseInt(result, 10) || 0;
 };
 function getTestData(dir = process.cwd()) {
-  const testResultsPath = join2(dir, AGENT_DIR2, TEST_RESULTS_FILE);
+  const testResultsPath = join2(dir, AGENT_DIR, TEST_RESULTS_FILE);
   let results = null;
   let isOutdated = false;
   let commitsBehind = 0;
@@ -418,65 +512,320 @@ function getTestData(dir = process.cwd()) {
   return { results, isOutdated, commitsBehind, error };
 }
 
+// src/runner/command.ts
+import { execSync as nodeExecSync3 } from "child_process";
+var execFn2 = (command, options2) => nodeExecSync3(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 execFn2("git rev-parse --short HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+}
+function runTestCommand(command) {
+  let output;
+  try {
+    output = execFn2(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 nodeExistsSync,
+  readFileSync as nodeReadFileSync3
+} from "fs";
+import { parse as parseYaml } from "yaml";
+var fs = {
+  existsSync: nodeExistsSync,
+  readFileSync: (path) => nodeReadFileSync3(path, "utf-8")
+};
+var CONFIG_PATH = ".agenthud/config.yaml";
+function parseInterval(interval) {
+  if (!interval || interval === "manual") {
+    return null;
+  }
+  const match = interval.match(/^(\d+)(s|m)$/);
+  if (!match) {
+    return null;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "s") {
+    return value * 1e3;
+  } else if (unit === "m") {
+    return value * 60 * 1e3;
+  }
+  return null;
+}
+function getDefaultConfig() {
+  return {
+    panels: {
+      git: {
+        enabled: true,
+        interval: 3e4
+        // 30s
+      },
+      plan: {
+        enabled: true,
+        interval: 1e4,
+        // 10s
+        source: ".agenthud/plan.json"
+      },
+      tests: {
+        enabled: true,
+        interval: null
+        // manual
+      }
+    }
+  };
+}
+var VALID_PANELS = ["git", "plan", "tests"];
+function parseConfig() {
+  const warnings = [];
+  const defaultConfig = getDefaultConfig();
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return { config: defaultConfig, warnings };
+  }
+  let rawConfig;
+  try {
+    const content = fs.readFileSync(CONFIG_PATH);
+    rawConfig = parseYaml(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warnings.push(`Failed to parse config: ${message}`);
+    return { config: defaultConfig, warnings };
+  }
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return { config: defaultConfig, warnings };
+  }
+  const parsed = rawConfig;
+  const panels = parsed.panels;
+  if (!panels || typeof panels !== "object") {
+    return { config: defaultConfig, warnings };
+  }
+  const config = getDefaultConfig();
+  for (const panelName of Object.keys(panels)) {
+    if (!VALID_PANELS.includes(panelName)) {
+      warnings.push(`Unknown panel '${panelName}' in config`);
+      continue;
+    }
+    const panelConfig = panels[panelName];
+    if (!panelConfig || typeof panelConfig !== "object") {
+      continue;
+    }
+    if (panelName === "git") {
+      if (typeof panelConfig.enabled === "boolean") {
+        config.panels.git.enabled = panelConfig.enabled;
+      }
+      if (typeof panelConfig.interval === "string") {
+        const interval = parseInterval(panelConfig.interval);
+        if (interval === null && panelConfig.interval !== "manual") {
+          warnings.push(`Invalid interval '${panelConfig.interval}' for git panel, using default`);
+        } else {
+          config.panels.git.interval = interval;
+        }
+      }
+    }
+    if (panelName === "plan") {
+      if (typeof panelConfig.enabled === "boolean") {
+        config.panels.plan.enabled = panelConfig.enabled;
+      }
+      if (typeof panelConfig.interval === "string") {
+        const interval = parseInterval(panelConfig.interval);
+        if (interval === null && panelConfig.interval !== "manual") {
+          warnings.push(`Invalid interval '${panelConfig.interval}' for plan panel, using default`);
+        } else {
+          config.panels.plan.interval = interval;
+        }
+      }
+      if (typeof panelConfig.source === "string") {
+        config.panels.plan.source = panelConfig.source;
+      }
+    }
+    if (panelName === "tests") {
+      if (typeof panelConfig.enabled === "boolean") {
+        config.panels.tests.enabled = panelConfig.enabled;
+      }
+      if (typeof panelConfig.interval === "string") {
+        const interval = parseInterval(panelConfig.interval);
+        if (interval === null && panelConfig.interval !== "manual") {
+          warnings.push(`Invalid interval '${panelConfig.interval}' for tests panel, using default`);
+        } else {
+          config.panels.tests.interval = interval;
+        }
+      }
+      if (typeof panelConfig.command === "string") {
+        config.panels.tests.command = panelConfig.command;
+      }
+    }
+  }
+  return { config, warnings };
+}
+
 // src/ui/App.tsx
 import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
-var REFRESH_INTERVAL = 5e3;
-var REFRESH_SECONDS = REFRESH_INTERVAL / 1e3;
-function useGitData() {
-  const [data, setData] = useState(() => ({
-    branch: getCurrentBranch(),
-    commits: getTodayCommits(),
-    stats: getTodayStats(),
-    uncommitted: getUncommittedCount()
-  }));
-  const refresh = useCallback(() => {
-    setData({
-      branch: getCurrentBranch(),
-      commits: getTodayCommits(),
-      stats: getTodayStats(),
-      uncommitted: getUncommittedCount()
-    });
-  }, []);
-  return [data, refresh];
-}
-function usePlanData() {
-  const [data, setData] = useState(() => getPlanData());
-  const refresh = useCallback(() => {
-    setData(getPlanData());
-  }, []);
-  return [data, refresh];
-}
-function useTestData() {
-  const [data, setData] = useState(() => getTestData());
-  const refresh = useCallback(() => {
-    setData(getTestData());
-  }, []);
-  return [data, refresh];
+function generateHotkeys(config, actions) {
+  const hotkeys = [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  if (config.panels.tests.enabled && config.panels.tests.interval === null && actions.tests) {
+    const name = "tests";
+    for (const char of name.toLowerCase()) {
+      if (!usedKeys.has(char)) {
+        usedKeys.add(char);
+        hotkeys.push({
+          key: char,
+          label: "run tests",
+          action: actions.tests
+        });
+        break;
+      }
+    }
+  }
+  return hotkeys;
 }
 function WelcomeApp() {
   return /* @__PURE__ */ jsx5(WelcomePanel, {});
 }
 function DashboardApp({ mode }) {
   const { exit } = useApp();
-  const [gitData, refreshGit] = useGitData();
-  const [planData, refreshPlan] = usePlanData();
-  const [testData, refreshTest] = useTestData();
-  const [countdown, setCountdown] = useState(REFRESH_SECONDS);
+  const { config, warnings } = useMemo(() => parseConfig(), []);
+  const gitIntervalSeconds = config.panels.git.interval ? config.panels.git.interval / 1e3 : null;
+  const planIntervalSeconds = config.panels.plan.interval ? config.panels.plan.interval / 1e3 : null;
+  const [gitData, setGitData] = useState(() => getGitData(config.panels.git));
+  const refreshGit = useCallback(() => {
+    setGitData(getGitData(config.panels.git));
+  }, [config.panels.git]);
+  const [planData, setPlanData] = useState(() => getPlanDataWithConfig(config.panels.plan));
+  const refreshPlan = useCallback(() => {
+    setPlanData(getPlanDataWithConfig(config.panels.plan));
+  }, [config.panels.plan]);
+  const getTestDataFromConfig = useCallback(() => {
+    if (config.panels.tests.command) {
+      return runTestCommand(config.panels.tests.command);
+    }
+    return getTestData();
+  }, [config.panels.tests.command]);
+  const [testData, setTestData] = useState(() => getTestDataFromConfig());
+  const refreshTest = useCallback(() => {
+    setTestData(getTestDataFromConfig());
+  }, [getTestDataFromConfig]);
+  const [countdowns, setCountdowns] = useState({
+    git: gitIntervalSeconds,
+    plan: planIntervalSeconds
+  });
   const refreshAll = useCallback(() => {
-    refreshGit();
-    refreshPlan();
-    refreshTest();
-    setCountdown(REFRESH_SECONDS);
-  }, [refreshGit, refreshPlan, refreshTest]);
+    if (config.panels.git.enabled) {
+      refreshGit();
+      setCountdowns((prev) => ({ ...prev, git: gitIntervalSeconds }));
+    }
+    if (config.panels.plan.enabled) {
+      refreshPlan();
+      setCountdowns((prev) => ({ ...prev, plan: planIntervalSeconds }));
+    }
+    if (config.panels.tests.enabled) {
+      refreshTest();
+    }
+  }, [refreshGit, refreshPlan, refreshTest, config, gitIntervalSeconds, planIntervalSeconds]);
+  const hotkeys = useMemo(
+    () => generateHotkeys(config, { tests: refreshTest }),
+    [config, refreshTest]
+  );
   useEffect(() => {
     if (mode !== "watch") return;
-    const interval = setInterval(refreshAll, REFRESH_INTERVAL);
-    return () => clearInterval(interval);
-  }, [mode, refreshAll]);
+    const timers = [];
+    if (config.panels.git.enabled && config.panels.git.interval !== null) {
+      timers.push(
+        setInterval(() => {
+          refreshGit();
+          setCountdowns((prev) => ({ ...prev, git: gitIntervalSeconds }));
+        }, config.panels.git.interval)
+      );
+    }
+    if (config.panels.plan.enabled && config.panels.plan.interval !== null) {
+      timers.push(
+        setInterval(() => {
+          refreshPlan();
+          setCountdowns((prev) => ({ ...prev, plan: planIntervalSeconds }));
+        }, config.panels.plan.interval)
+      );
+    }
+    if (config.panels.tests.enabled && config.panels.tests.interval !== null) {
+      timers.push(setInterval(refreshTest, config.panels.tests.interval));
+    }
+    return () => timers.forEach((t) => clearInterval(t));
+  }, [mode, config, refreshGit, refreshPlan, refreshTest, gitIntervalSeconds, planIntervalSeconds]);
   useEffect(() => {
     if (mode !== "watch") return;
     const tick = setInterval(() => {
-      setCountdown((prev) => prev > 1 ? prev - 1 : REFRESH_SECONDS);
+      setCountdowns((prev) => ({
+        git: prev.git !== null && prev.git > 1 ? prev.git - 1 : prev.git,
+        plan: prev.plan !== null && prev.plan > 1 ? prev.plan - 1 : prev.plan
+      }));
     }, 1e3);
     return () => clearInterval(tick);
   }, [mode]);
@@ -488,28 +837,46 @@ function DashboardApp({ mode }) {
       if (input === "r") {
         refreshAll();
       }
+      for (const hotkey of hotkeys) {
+        if (input === hotkey.key) {
+          hotkey.action();
+          break;
+        }
+      }
     },
     { isActive: mode === "watch" }
   );
+  const statusBarItems = [];
+  for (const hotkey of hotkeys) {
+    statusBarItems.push(`${hotkey.key}: ${hotkey.label}`);
+  }
+  statusBarItems.push("r: refresh");
+  statusBarItems.push("q: quit");
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
+    warnings.length > 0 && /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+      "\u26A0 ",
+      warnings.join(", ")
+    ] }) }),
+    config.panels.git.enabled && /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsx5(
       GitPanel,
       {
         branch: gitData.branch,
         commits: gitData.commits,
         stats: gitData.stats,
-        uncommitted: gitData.uncommitted
+        uncommitted: gitData.uncommitted,
+        countdown: mode === "watch" ? countdowns.git : null
       }
     ) }),
-    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(
+    config.panels.plan.enabled && /* @__PURE__ */ jsx5(Box5, { marginTop: config.panels.git.enabled ? 1 : 0, children: /* @__PURE__ */ jsx5(
       PlanPanel,
       {
         plan: planData.plan,
         decisions: planData.decisions,
-        error: planData.error
+        error: planData.error,
+        countdown: mode === "watch" ? countdowns.plan : null
       }
     ) }),
-    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(
+    config.panels.tests.enabled && /* @__PURE__ */ jsx5(Box5, { marginTop: config.panels.git.enabled || config.panels.plan.enabled ? 1 : 0, children: /* @__PURE__ */ jsx5(
       TestPanel,
       {
         results: testData.results,
@@ -518,15 +885,14 @@ function DashboardApp({ mode }) {
         error: testData.error
       }
     ) }),
-    mode === "watch" && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, width: PANEL_WIDTH, children: /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
-      "\u21BB ",
-      countdown,
-      "s \xB7 ",
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "q:" }),
-      " quit \xB7 ",
-      /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "r:" }),
-      " refresh"
-    ] }) })
+    mode === "watch" && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, width: PANEL_WIDTH, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: statusBarItems.map((item, index) => /* @__PURE__ */ jsxs5(React.Fragment, { children: [
+      index > 0 && " \xB7 ",
+      /* @__PURE__ */ jsxs5(Text5, { color: "cyan", children: [
+        item.split(":")[0],
+        ":"
+      ] }),
+      item.split(":").slice(1).join(":")
+    ] }, index)) }) })
   ] });
 }
 function App({ mode, agentDirExists: agentDirExists2 = true }) {
@@ -553,55 +919,93 @@ function parseArgs(args) {
 
 // src/commands/init.ts
 import {
-  existsSync as nodeExistsSync,
+  existsSync as nodeExistsSync2,
   mkdirSync as nodeMkdirSync,
   writeFileSync as nodeWriteFileSync,
-  readFileSync as nodeReadFileSync3,
+  readFileSync as nodeReadFileSync4,
   appendFileSync as nodeAppendFileSync
 } from "fs";
-var fs = {
-  existsSync: nodeExistsSync,
+var fs2 = {
+  existsSync: nodeExistsSync2,
   mkdirSync: nodeMkdirSync,
   writeFileSync: nodeWriteFileSync,
-  readFileSync: (path) => nodeReadFileSync3(path, "utf-8"),
+  readFileSync: (path) => nodeReadFileSync4(path, "utf-8"),
   appendFileSync: nodeAppendFileSync
 };
 var AGENT_STATE_SECTION = `## Agent State
 
-Maintain \`.agent/\` directory:
+Maintain \`.agenthud/\` directory:
 - Update \`plan.json\` when plan changes
 - Append to \`decisions.json\` for key decisions
 `;
+var DEFAULT_CONFIG = `# agenthud configuration
+panels:
+  git:
+    enabled: true
+    interval: 30s
+    command:
+      branch: git branch --show-current
+      commits: git log --since=midnight --pretty=format:"%h|%aI|%s"
+      stats: git log --since=midnight --numstat --pretty=format:""
+
+  plan:
+    enabled: true
+    interval: 10s
+    source: .agenthud/plan.json
+
+  tests:
+    enabled: true
+    interval: manual
+    command: npx vitest run --reporter=json
+`;
 function runInit() {
   const result = {
     created: [],
     skipped: []
   };
-  if (!fs.existsSync(".agent")) {
-    fs.mkdirSync(".agent", { recursive: true });
-    result.created.push(".agent/");
+  if (!fs2.existsSync(".agenthud")) {
+    fs2.mkdirSync(".agenthud", { recursive: true });
+    result.created.push(".agenthud/");
+  } else {
+    result.skipped.push(".agenthud/");
+  }
+  if (!fs2.existsSync(".agenthud/plan.json")) {
+    fs2.writeFileSync(".agenthud/plan.json", "{}\n");
+    result.created.push(".agenthud/plan.json");
+  } else {
+    result.skipped.push(".agenthud/plan.json");
+  }
+  if (!fs2.existsSync(".agenthud/decisions.json")) {
+    fs2.writeFileSync(".agenthud/decisions.json", "[]\n");
+    result.created.push(".agenthud/decisions.json");
   } else {
-    result.skipped.push(".agent/");
+    result.skipped.push(".agenthud/decisions.json");
   }
-  if (!fs.existsSync(".agent/plan.json")) {
-    fs.writeFileSync(".agent/plan.json", "{}\n");
-    result.created.push(".agent/plan.json");
+  if (!fs2.existsSync(".agenthud/config.yaml")) {
+    fs2.writeFileSync(".agenthud/config.yaml", DEFAULT_CONFIG);
+    result.created.push(".agenthud/config.yaml");
   } else {
-    result.skipped.push(".agent/plan.json");
+    result.skipped.push(".agenthud/config.yaml");
   }
-  if (!fs.existsSync(".agent/decisions.json")) {
-    fs.writeFileSync(".agent/decisions.json", "[]\n");
-    result.created.push(".agent/decisions.json");
+  if (!fs2.existsSync(".gitignore")) {
+    fs2.writeFileSync(".gitignore", ".agenthud/\n");
+    result.created.push(".gitignore");
   } else {
-    result.skipped.push(".agent/decisions.json");
+    const content = fs2.readFileSync(".gitignore");
+    if (!content.includes(".agenthud/")) {
+      fs2.appendFileSync(".gitignore", "\n.agenthud/\n");
+      result.created.push(".gitignore");
+    } else {
+      result.skipped.push(".gitignore");
+    }
   }
-  if (!fs.existsSync("CLAUDE.md")) {
-    fs.writeFileSync("CLAUDE.md", AGENT_STATE_SECTION);
+  if (!fs2.existsSync("CLAUDE.md")) {
+    fs2.writeFileSync("CLAUDE.md", AGENT_STATE_SECTION);
     result.created.push("CLAUDE.md");
   } else {
-    const content = fs.readFileSync("CLAUDE.md");
+    const content = fs2.readFileSync("CLAUDE.md");
     if (!content.includes("## Agent State")) {
-      fs.appendFileSync("CLAUDE.md", "\n" + AGENT_STATE_SECTION);
+      fs2.appendFileSync("CLAUDE.md", "\n" + AGENT_STATE_SECTION);
       result.created.push("CLAUDE.md");
     } else {
       result.skipped.push("CLAUDE.md");
@@ -624,11 +1028,11 @@ if (options.command === "init") {
     result.skipped.forEach((file) => console.log(`  ${file}`));
   }
   console.log("\nNext steps:");
-  console.log("  1. Edit .agent/plan.json to add your project plan");
+  console.log("  1. Edit .agenthud/plan.json to add your project plan");
   console.log("  2. Run: npx agenthud\n");
   process.exit(0);
 }
-var agentDirExists = existsSync(".agent");
+var agentDirExists = existsSync(".agenthud");
 if (options.mode === "watch") {
   clearScreen();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenthud",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "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",
@@ -51,6 +51,7 @@
   },
   "dependencies": {
     "ink": "^6.6.0",
-    "react": "^19.2.3"
+    "react": "^19.2.3",
+    "yaml": "^2.8.2"
   }
 }

package/scripts/save-test-results.ts

@@ -7,7 +7,7 @@
  *   npm run test:save
  *
  * Output:
- *   .agent/test-results.json
+ *   .agenthud/test-results.json
  */
 
 import { execSync } from "child_process";
@@ -106,8 +106,8 @@ function main(): void {
     failures: extractFailures(vitestResult),
   };
 
-  // Ensure .agent directory exists
-  const agentDir = join(process.cwd(), ".agent");
+  // Ensure .agenthud directory exists
+  const agentDir = join(process.cwd(), ".agenthud");
   if (!existsSync(agentDir)) {
     mkdirSync(agentDir, { recursive: true });
   }