devflow-kit 1.8.3 → 2.0.0

package/dist/hud/git.js

@@ -1,8 +1,10 @@
 import { execFile } from 'node:child_process';
+import { isTrunkBranch } from '../core/git.js';
 const GIT_TIMEOUT = 1000; // 1s per command
+const GIT_MAXBUFFER = 16 * 1024 * 1024; // 16 MiB — covers >500k refs at ~30 B/ref
 function shellExec(cmd, args, cwd) {
     return new Promise((resolve) => {
-        execFile(cmd, args, { cwd, timeout: GIT_TIMEOUT }, (err, stdout) => {
+        execFile(cmd, args, { cwd, timeout: GIT_TIMEOUT, maxBuffer: GIT_MAXBUFFER }, (err, stdout) => {
             resolve(err ? '' : stdout.trim());
         });
     });
@@ -19,12 +21,16 @@ export async function gatherGitStatus(cwd) {
     const topLevel = await gitExec(['rev-parse', '--show-toplevel'], cwd);
     if (!topLevel)
         return null;
-    // Branch name
+    // Branch name — 'HEAD' means detached HEAD state
     const branch = await gitExec(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
     if (!branch)
         return null;
-    // Dirty check
-    const statusOutput = await gitExec(['status', '--porcelain', '--no-optional-locks'], cwd);
+    // Dirty check — porcelain v1: two-char XY status prefix per path.
+    // --no-optional-locks is a git-level option and MUST precede the subcommand:
+    // `git status --no-optional-locks` is rejected as an unknown option, which makes
+    // shellExec return '' and silently reports every tree as clean. Keeping the flag
+    // (in the right position) stops the HUD from writing .git/index on every prompt.
+    const statusOutput = await gitExec(['--no-optional-locks', 'status', '--porcelain'], cwd);
     let dirty = false;
     let staged = false;
     for (const line of statusOutput.split('\n')) {
@@ -39,30 +45,41 @@ export async function gatherGitStatus(cwd) {
         if (worktree !== ' ' || index === '?')
             dirty = true;
     }
-    // Ahead/behind — detect base branch with layered fallback (ported from statusline.sh)
-    const baseBranch = await detectBaseBranch(branch, cwd);
     let ahead = 0;
     let behind = 0;
-    if (baseBranch) {
-        const revList = await gitExec(['rev-list', '--left-right', '--count', `${baseBranch}...HEAD`], cwd);
-        const parts = revList.split(/\s+/);
-        if (parts.length === 2) {
-            behind = parseInt(parts[0], 10) || 0;
-            ahead = parseInt(parts[1], 10) || 0;
-        }
-    }
-    // Diff stats against base
     let filesChanged = 0;
     let additions = 0;
     let deletions = 0;
-    if (baseBranch) {
-        const diffStat = await gitExec(['diff', '--shortstat', baseBranch], cwd);
-        const filesMatch = diffStat.match(/(\d+)\s+file/);
-        const addMatch = diffStat.match(/(\d+)\s+insertion/);
-        const delMatch = diffStat.match(/(\d+)\s+deletion/);
-        filesChanged = filesMatch ? parseInt(filesMatch[1], 10) : 0;
-        additions = addMatch ? parseInt(addMatch[1], 10) : 0;
-        deletions = delMatch ? parseInt(delMatch[1], 10) : 0;
+    // Detached HEAD ('HEAD') has no branch reference to compare against — skip ahead/behind and diff.
+    if (branch !== 'HEAD') {
+        const baseRef = await detectBaseBranch(branch, cwd);
+        if (baseRef) {
+            // rev-list and merge-base are independent — run in parallel.
+            // Ahead/behind: three-dot range is merge-base-equivalent (commit count only, no working tree).
+            const [revList, mergeBase] = await Promise.all([
+                gitExec(['rev-list', '--left-right', '--count', `${baseRef}...HEAD`], cwd),
+                gitExec(['merge-base', baseRef, 'HEAD'], cwd),
+            ]);
+            const parts = revList.split(/\s+/);
+            if (parts.length === 2) {
+                behind = parseInt(parts[0], 10) || 0;
+                ahead = parseInt(parts[1], 10) || 0;
+            }
+            // Diff stats: resolve the explicit merge base so the diff covers only this branch's changes
+            // relative to the default branch. git diff --shortstat <mergeBase> compares the working tree
+            // against the merge base, intentionally including uncommitted working-tree changes in the figure.
+            // NOTE: diff includes the working tree; ahead/behind counts commits only. This asymmetry is
+            // deliberate — both reference the same merge base but differ in working-tree inclusion.
+            if (mergeBase) {
+                const diffStat = await gitExec(['diff', '--shortstat', mergeBase], cwd);
+                const filesMatch = diffStat.match(/(\d+)\s+file/);
+                const addMatch = diffStat.match(/(\d+)\s+insertion/);
+                const delMatch = diffStat.match(/(\d+)\s+deletion/);
+                filesChanged = filesMatch ? parseInt(filesMatch[1], 10) : 0;
+                additions = addMatch ? parseInt(addMatch[1], 10) : 0;
+                deletions = delMatch ? parseInt(delMatch[1], 10) : 0;
+            }
+        }
     }
     // Tag and worktree info (parallel)
     const [tagOutput, worktreeOutput] = await Promise.all([
@@ -93,61 +110,85 @@ export async function gatherGitStatus(cwd) {
     };
 }
 /**
- * Detect the base branch for ahead/behind calculations.
- * Uses a 4-layer fallback (ported from statusline.sh):
- *   1. Branch reflog ("Created from")
- *   2. HEAD reflog ("checkout: moving from X to branch")
- *   3. GitHub PR base branch (gh pr view, cached)
- *   4. main/master fallback
+ * Resolve the comparison ref for a given branch, using a pre-built Set of known refs.
+ *
+ * CONTRACT: when the current branch IS the repo's default branch, or is any
+ * canonical trunk branch (per isTrunkBranch), and origin/<branch> exists as a
+ * remote ref, compare against origin/<branch> so the status line shows unpushed
+ * commits rather than a zero diff.
+ *
+ * Do NOT use @{upstream} for all branches — pushed feature branches would
+ * self-compare (rev-list A...A = 0 ahead/behind) and the HUD would render nothing
+ * useful. The trunk-name predicate is the correct discriminant: feature branches
+ * compare against the repo default; trunk branches compare against themselves.
+ *
+ * This function is pure/sync — the refs Set answers existence without spawning.
+ * Called from remote detection layers (a) and (b); layer (c) (local-only fallback)
+ * returns a local branch name directly and does not self-compare against origin/.
+ */
+function resolveComparisonRef(branch, defaultRef, refs) {
+    const defaultShort = defaultRef.replace(/^origin\//, '');
+    if ((branch === defaultShort || isTrunkBranch(branch)) && refs.has(`origin/${branch}`)) {
+        return `origin/${branch}`;
+    }
+    return defaultRef;
+}
+/**
+ * Detect the base (default) branch for this repository using exactly two git spawns.
+ *
+ * Resolution order:
+ *   (a) git symbolic-ref --short refs/remotes/origin/HEAD — authoritative when set by
+ *       `git clone` or `git remote set-head`. Absence is common (only set by those two
+ *       operations) and is treated as a normal fallback, not an error.
+ *   (b) First of origin/main, origin/master, origin/develop, origin/trunk that exists
+ *       as a ref in the fetched Set.
+ *   (c) No remote configured — first of main, master, develop, trunk that exists
+ *       locally (in the fetched Set). Never compare a branch against itself.
+ *   (d) Nothing resolves — return null; caller renders the counter absent rather than
+ *       wrong. Rendering nothing is strictly better than a confidently wrong number.
+ *
+ * Both spawns run in parallel:
+ *   1. git symbolic-ref --short refs/remotes/origin/HEAD
+ *   2. git for-each-ref --format=%(refname:short) refs/heads/ refs/remotes/origin/
+ *      → builds a Set<string> of all known local and remote branch names.
+ *
+ * The Set answers all existence queries (layers a–c) without additional spawns.
+ *
+ * resolveComparisonRef is called from remote layers (a) and (b) so that any canonical
+ * trunk branch (develop, staging, production, release/*) self-compares against
+ * origin/<branch> when that ref exists, not just the detected default branch.
+ * Layer (c) (no remote configured) returns a local branch name without calling this.
+ *
+ * Note on tag-DWIM: for-each-ref limits scope to refs/heads/ and refs/remotes/origin/,
+ * so tag objects never appear in the Set — a name that happens to match a tag is not
+ * mistaken for a branch.
  */
 async function detectBaseBranch(branch, cwd) {
-    // Layer 1: branch reflog — look for "branch: Created from"
-    const branchLog = await gitExec(['reflog', 'show', branch, '--format=%gs', '-n', '1'], cwd);
-    const createdMatch = branchLog.match(/branch: Created from (.+)/);
-    if (createdMatch) {
-        const candidate = createdMatch[1];
-        if (candidate !== 'HEAD' && !candidate.includes('~')) {
-            const exists = await gitExec(['rev-parse', '--verify', candidate], cwd);
-            if (exists)
-                return candidate;
-        }
+    const [originHead, refsOutput] = await Promise.all([
+        gitExec(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], cwd),
+        gitExec(['for-each-ref', '--format=%(refname:short)', 'refs/heads/', 'refs/remotes/origin/'], cwd),
+    ]);
+    const refs = new Set(refsOutput ? refsOutput.split('\n').filter(Boolean) : []);
+    // (a) Authoritative when present: set by git clone or git remote set-head.
+    //     Absence is common — do not treat as exceptional, just fall through.
+    if (originHead && refs.has(originHead)) {
+        return resolveComparisonRef(branch, originHead, refs);
     }
-    // Layer 2: HEAD reflog — look for "checkout: moving from X to branch"
-    const headLog = await gitExec(['reflog', 'show', 'HEAD', '--format=%gs'], cwd);
-    const escapedBranch = branch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const checkoutPattern = new RegExp(`checkout: moving from (\\S+) to ${escapedBranch}`);
-    for (const line of headLog.split('\n')) {
-        const match = line.match(checkoutPattern);
-        if (match) {
-            const candidate = match[1];
-            // Skip raw commit hashes and the current branch
-            if (candidate === branch || /^[0-9a-f]{7,}$/.test(candidate))
-                continue;
-            const exists = await gitExec(['rev-parse', '--verify', candidate], cwd);
-            if (exists)
-                return candidate;
+    // (b) Scan common remote branch names when origin/HEAD is absent.
+    for (const candidate of ['origin/main', 'origin/master', 'origin/develop', 'origin/trunk']) {
+        if (refs.has(candidate)) {
+            return resolveComparisonRef(branch, candidate, refs);
         }
     }
-    // Layer 3: GitHub PR base branch via gh CLI
-    const prBase = await shellExec('gh', ['pr', 'view', '--json', 'baseRefName', '-q', '.baseRefName'], cwd);
-    if (prBase) {
-        const exists = await gitExec(['rev-parse', '--verify', prBase], cwd);
-        if (exists)
-            return prBase;
-    }
-    // Layer 4: main/master fallback (skip if already on that branch — use remote tracking instead)
-    for (const candidate of ['main', 'master']) {
-        if (candidate === branch) {
-            // On main/master itself — compare against remote tracking branch
-            const remote = await gitExec(['rev-parse', '--verify', `origin/${candidate}`], cwd);
-            if (remote)
-                return `origin/${candidate}`;
-            continue;
-        }
-        const exists = await gitExec(['rev-parse', '--verify', candidate], cwd);
-        if (exists)
+    // (c) No remote configured — fall back to local default branches.
+    for (const candidate of ['main', 'master', 'develop', 'trunk']) {
+        if (candidate === branch)
+            continue; // Never compare a branch against itself
+        if (refs.has(candidate)) {
             return candidate;
+        }
     }
+    // (d) Cannot determine base — degrade gracefully; caller renders counter as absent.
     return null;
 }
 //# sourceMappingURL=git.js.map

package/dist/hud/index.js

@@ -5,10 +5,36 @@ import { readStdin } from './stdin.js';
 import { loadConfig, resolveComponents } from './config.js';
 import { gatherGitStatus } from './git.js';
 import { parseTranscript } from './transcript.js';
-import { fetchUsageData } from './usage-api.js';
+import { persistSessionCost, aggregateCosts } from './cost-history.js';
 import { gatherConfigCounts } from './components/config-counts.js';
+import { gatherLearningCounts } from './components/learning-counts.js';
 import { render } from './render.js';
 const OVERALL_TIMEOUT = 2000; // 2 second overall timeout
+/**
+ * Extract usage quota data from stdin rate_limits field.
+ * Returns null if rate_limits is absent.
+ * Percentages are clamped to 0-100.
+ */
+function extractUsageFromStdin(stdin) {
+    if (!stdin.rate_limits)
+        return null;
+    const fiveHour = stdin.rate_limits.five_hour;
+    const sevenDay = stdin.rate_limits.seven_day;
+    const fiveHourPercent = typeof fiveHour?.used_percentage === 'number'
+        ? Math.max(0, Math.min(100, fiveHour.used_percentage))
+        : null;
+    const sevenDayPercent = typeof sevenDay?.used_percentage === 'number'
+        ? Math.max(0, Math.min(100, sevenDay.used_percentage))
+        : null;
+    const fiveHourResetsAt = typeof fiveHour?.resets_at === 'number' ? fiveHour.resets_at : null;
+    const sevenDayResetsAt = typeof sevenDay?.resets_at === 'number' ? sevenDay.resets_at : null;
+    return {
+        fiveHourPercent,
+        sevenDayPercent,
+        fiveHourResetsAt,
+        sevenDayResetsAt,
+    };
+}
 async function main() {
     const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), OVERALL_TIMEOUT));
     try {
@@ -39,16 +65,18 @@ async function run() {
         components.has('worktreeCount');
     const needsTranscript = components.has('todoProgress') ||
         components.has('configCounts');
-    const needsUsage = components.has('usageQuota');
     const needsConfigCounts = components.has('configCounts');
+    const needsLearningCounts = components.has('learningCounts');
+    const needsSessionCost = components.has('sessionCost');
     // Parallel data gathering — only fetch what's needed
-    const [git, transcript, usage] = await Promise.all([
+    const [git, transcript] = await Promise.all([
         needsGit ? gatherGitStatus(cwd) : Promise.resolve(null),
         needsTranscript && stdin.transcript_path
             ? parseTranscript(stdin.transcript_path)
             : Promise.resolve(null),
-        needsUsage ? fetchUsageData() : Promise.resolve(null),
     ]);
+    // Extract usage quota from stdin rate_limits (replaces OAuth fetch)
+    const usage = components.has('usageQuota') ? extractUsageFromStdin(stdin) : null;
     // Session start time from transcript file creation time
     let sessionStartTime = null;
     if (stdin.transcript_path) {
@@ -62,6 +90,19 @@ async function run() {
     const configCountsData = needsConfigCounts
         ? gatherConfigCounts(cwd)
         : null;
+    // Decisions/pitfalls counts (fast, synchronous filesystem read)
+    const learningCountsData = needsLearningCounts
+        ? gatherLearningCounts(cwd)
+        : null;
+    // Cost tracking: persist current session cost, aggregate for weekly/monthly
+    const sessionId = stdin.session_id;
+    const costUsd = stdin.cost?.total_cost_usd ?? 0;
+    if (needsSessionCost && sessionId && costUsd) {
+        persistSessionCost(sessionId, costUsd, cwd);
+    }
+    const costHistory = needsSessionCost && sessionId
+        ? aggregateCosts(sessionId, costUsd)
+        : null;
     // Terminal width via stderr (stdout is piped to Claude Code)
     const terminalWidth = process.stderr.columns || 120;
     const ctx = {
@@ -70,6 +111,8 @@ async function run() {
         transcript,
         usage,
         configCounts: configCountsData,
+        learningCounts: learningCountsData,
+        costHistory,
         config: { ...config, components: resolved },
         devflowDir,
         sessionStartTime,

package/dist/hud/render.js

@@ -10,6 +10,7 @@ import sessionDuration from './components/session-duration.js';
 import usageQuota from './components/usage-quota.js';
 import todoProgress from './components/todo-progress.js';
 import configCounts from './components/config-counts.js';
+import learningCounts from './components/learning-counts.js';
 import sessionCost from './components/session-cost.js';
 import releaseInfo from './components/release-info.js';
 import worktreeCount from './components/worktree-count.js';
@@ -25,6 +26,7 @@ const COMPONENT_MAP = {
     usageQuota,
     todoProgress,
     configCounts,
+    learningCounts,
     sessionCost,
     releaseInfo,
     worktreeCount,
@@ -32,23 +34,19 @@ const COMPONENT_MAP = {
 /**
  * Line groupings for smart layout.
  * Components are assigned to lines and only rendered if enabled.
- * null entries denote section breaks (blank line between sections).
  */
 const LINE_GROUPS = [
-    // Section 1: Info (3 lines)
     ['directory', 'gitBranch', 'gitAheadBehind', 'releaseInfo', 'worktreeCount', 'diffStats'],
-    ['contextUsage', 'usageQuota'],
-    ['model', 'sessionDuration', 'sessionCost', 'configCounts'],
-    // --- section break ---
-    null,
-    // Section 2: Activity
-    ['todoProgress'],
+    ['contextUsage', 'usageQuota', 'todoProgress'],
+    ['model', 'configCounts', 'sessionCost'],
+    ['learningCounts'],
     ['versionBadge'],
 ];
 const SEPARATOR = dim(' \u00B7 ');
 /**
  * Render all enabled components into a multi-line HUD string.
- * Components that return null are excluded. Empty lines are skipped.
+ * Components that return null are excluded. Lines with no rendered
+ * components are skipped.
  */
 export async function render(ctx) {
     const enabled = new Set(ctx.config.components);
@@ -69,23 +67,13 @@ export async function render(ctx) {
         }));
     }
     await Promise.all(promises);
-    // Assemble lines using smart layout with section breaks
+    // Assemble lines using smart layout
     const lines = [];
-    let pendingBreak = false;
     for (const entry of LINE_GROUPS) {
-        if (entry === null) {
-            if (lines.length > 0)
-                pendingBreak = true;
-            continue;
-        }
         const lineResults = entry
             .filter((id) => enabled.has(id) && results.has(id))
             .map((id) => results.get(id));
         if (lineResults.length > 0) {
-            if (pendingBreak) {
-                lines.push('');
-                pendingBreak = false;
-            }
             // Separate multi-line results (containing newlines) from single-line
             const singleLine = [];
             for (const r of lineResults) {

package/dist/hud/transcript.js

@@ -26,9 +26,9 @@ export async function parseTranscript(transcriptPath) {
                 continue;
             try {
                 const entry = JSON.parse(line);
-                // Turn boundary: clear tools and agents on each human message
+                // Turn boundary: clear tools and agents on each user turn
                 // so only the current turn's activity shows in the HUD
-                if (entry.type === 'human') {
+                if (entry.type === 'user') {
                     tools.clear();
                     agents.clear();
                     continue;
@@ -98,10 +98,9 @@ function processEntry(entry, tools, agents, skills) {
             else {
                 // Regular tool — extract file target for Read/Edit/Write
                 const input = block.input;
-                let target;
-                if (input?.file_path && typeof input.file_path === 'string') {
-                    target = path.basename(input.file_path);
-                }
+                const target = input?.file_path && typeof input.file_path === 'string'
+                    ? path.basename(input.file_path)
+                    : undefined;
                 // Extract description: prefer input.description, fallback to first 4 words of command (Bash)
                 let description;
                 if (typeof input?.description === 'string') {

package/dist/targets/claude-code/claude-paths.js

@@ -0,0 +1,106 @@
+import { homedir, platform } from 'os';
+import * as path from 'path';
+import { getGitRoot } from '../../core/git.js';
+/**
+ * Get the OS-specific path for Claude Code managed settings.
+ * Managed settings have highest precedence and cannot be overridden by users.
+ * - macOS: /Library/Application Support/ClaudeCode/managed-settings.json
+ * - Linux: /etc/claude-code/managed-settings.json
+ *
+ * @throws {Error} On unsupported platforms (Windows)
+ */
+export function getManagedSettingsPath() {
+    const os = platform();
+    if (os === 'darwin') {
+        return '/Library/Application Support/ClaudeCode/managed-settings.json';
+    }
+    if (os === 'linux') {
+        return '/etc/claude-code/managed-settings.json';
+    }
+    throw new Error(`Managed settings not supported on platform: ${os}`);
+}
+/**
+ * Get home directory with proper fallback and validation
+ * Priority: process.env.HOME > os.homedir()
+ *
+ * @throws {Error} If unable to determine home directory
+ */
+export function getHomeDirectory() {
+    const home = process.env.HOME || homedir();
+    if (!home) {
+        throw new Error('Unable to determine home directory. Set HOME environment variable.');
+    }
+    return home;
+}
+/**
+ * Get Claude Code directory with environment variable override support
+ * Priority: CLAUDE_CODE_DIR env var > ~/.claude
+ *
+ * @throws {Error} If CLAUDE_CODE_DIR is invalid (not absolute, outside home)
+ */
+export function getClaudeDirectory() {
+    if (process.env.CLAUDE_CODE_DIR) {
+        const customDir = process.env.CLAUDE_CODE_DIR;
+        // Validate path is absolute
+        if (!path.isAbsolute(customDir)) {
+            throw new Error('CLAUDE_CODE_DIR must be an absolute path');
+        }
+        // Warn if outside home directory (security best practice)
+        const home = getHomeDirectory();
+        if (!customDir.startsWith(home)) {
+            console.warn('⚠️  CLAUDE_CODE_DIR is outside home directory. Ensure this is intentional.');
+        }
+        return customDir;
+    }
+    return path.join(getHomeDirectory(), '.claude');
+}
+/**
+ * Get Devflow directory with environment variable override support
+ * Priority: DEVFLOW_DIR env var > ~/.devflow
+ *
+ * @throws {Error} If DEVFLOW_DIR is invalid (not absolute, outside home)
+ */
+export function getDevFlowDirectory() {
+    if (process.env.DEVFLOW_DIR) {
+        const customDir = process.env.DEVFLOW_DIR;
+        // Validate path is absolute
+        if (!path.isAbsolute(customDir)) {
+            throw new Error('DEVFLOW_DIR must be an absolute path');
+        }
+        // Warn if outside home directory (security best practice)
+        const home = getHomeDirectory();
+        if (!customDir.startsWith(home)) {
+            console.warn('⚠️  DEVFLOW_DIR is outside home directory. Ensure this is intentional.');
+        }
+        return customDir;
+    }
+    return path.join(getHomeDirectory(), '.devflow');
+}
+/**
+ * Get installation paths based on scope (async, non-blocking)
+ * @param scope - 'user' or 'local'
+ * @returns Object with claudeDir and devflowDir
+ * @throws {Error} If local scope selected but not in a git repository
+ */
+export async function getInstallationPaths(scope) {
+    if (scope === 'user') {
+        return {
+            claudeDir: getClaudeDirectory(),
+            devflowDir: getDevFlowDirectory(),
+            gitRoot: null,
+        };
+    }
+    else {
+        // Local scope - install to git repository root
+        const gitRoot = await getGitRoot();
+        if (!gitRoot) {
+            throw new Error('Local scope requires a git repository. Run "git init" first or use --scope user');
+        }
+        return {
+            claudeDir: path.join(gitRoot, '.claude'),
+            devflowDir: path.join(gitRoot, '.devflow'),
+            gitRoot,
+        };
+    }
+}
+//# sourceMappingURL=claude-paths.js.map