devflow-kit 1.6.1 → 1.8.0

package/dist/hud/config.js

@@ -0,0 +1,55 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * All 14 HUD components in display order.
+ */
+export const HUD_COMPONENTS = [
+    'directory',
+    'gitBranch',
+    'gitAheadBehind',
+    'diffStats',
+    'releaseInfo',
+    'worktreeCount',
+    'model',
+    'contextUsage',
+    'versionBadge',
+    'sessionDuration',
+    'sessionCost',
+    'usageQuota',
+    'todoProgress',
+    'configCounts',
+];
+export function getConfigPath() {
+    const devflowDir = process.env.DEVFLOW_DIR || path.join(process.env.HOME || homedir(), '.devflow');
+    return path.join(devflowDir, 'hud.json');
+}
+export function loadConfig() {
+    const configPath = getConfigPath();
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            enabled: parsed.enabled !== false,
+            detail: parsed.detail === true,
+        };
+    }
+    catch {
+        return { enabled: true, detail: false };
+    }
+}
+export function saveConfig(config) {
+    const configPath = getConfigPath();
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+export function resolveComponents(config) {
+    if (config.enabled)
+        return [...HUD_COMPONENTS];
+    // Version badge always renders so users see upgrade notifications
+    return ['versionBadge'];
+}
+//# sourceMappingURL=config.js.map

package/dist/hud/credentials.d.ts

@@ -0,0 +1,17 @@
+export interface OAuthCredentials {
+    accessToken: string;
+    subscriptionType?: string;
+}
+/** Resolve the Claude config directory, respecting CLAUDE_CONFIG_DIR. */
+export declare function getClaudeDir(): string;
+/** Read OAuth credentials from ~/.claude/.credentials.json. Injectable claudeDir for tests. */
+export declare function readCredentialsFile(claudeDir?: string): OAuthCredentials | null;
+/** Read OAuth token from macOS Keychain. Returns null on non-darwin or failure. */
+export declare function readKeychainToken(): Promise<string | null>;
+/**
+ * Get OAuth credentials using platform-appropriate strategy.
+ * macOS: Keychain first, then file fallback. Other platforms: file only.
+ * Hybrid: if Keychain has token but no subscriptionType, merge from file.
+ */
+export declare function getCredentials(): Promise<OAuthCredentials | null>;
+//# sourceMappingURL=credentials.d.ts.map

package/dist/hud/credentials.js

@@ -0,0 +1,99 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { execFile } from 'node:child_process';
+const KEYCHAIN_TIMEOUT = 3000; // 3s
+const DEBUG = !!process.env.DEVFLOW_HUD_DEBUG;
+function debugLog(msg, data) {
+    if (!DEBUG)
+        return;
+    const entry = { ts: new Date().toISOString(), source: 'credentials', msg, ...data };
+    fs.appendFileSync('/tmp/hud-debug.log', JSON.stringify(entry) + '\n');
+}
+/** Resolve the Claude config directory, respecting CLAUDE_CONFIG_DIR. */
+export function getClaudeDir() {
+    return (process.env.CLAUDE_CONFIG_DIR ||
+        path.join(process.env.HOME || homedir(), '.claude'));
+}
+/** Read OAuth credentials from ~/.claude/.credentials.json. Injectable claudeDir for tests. */
+export function readCredentialsFile(claudeDir) {
+    try {
+        const dir = claudeDir ?? getClaudeDir();
+        const filePath = path.join(dir, '.credentials.json');
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const creds = JSON.parse(raw);
+        const oauth = creds.claudeAiOauth;
+        const accessToken = oauth?.accessToken;
+        if (typeof accessToken !== 'string' || !accessToken)
+            return null;
+        const subscriptionType = typeof oauth?.subscriptionType === 'string' ? oauth.subscriptionType : undefined;
+        debugLog('credentials file read', { filePath, hasSubscriptionType: !!subscriptionType });
+        return { accessToken, subscriptionType };
+    }
+    catch {
+        return null;
+    }
+}
+/** Read OAuth token from macOS Keychain. Returns null on non-darwin or failure. */
+export function readKeychainToken() {
+    if (process.platform !== 'darwin')
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        execFile('/usr/bin/security', ['find-generic-password', '-s', 'Claude Code-credentials', '-w'], { timeout: KEYCHAIN_TIMEOUT }, (err, stdout) => {
+            if (err || !stdout.trim()) {
+                debugLog('keychain read failed', { error: err?.message });
+                resolve(null);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdout.trim());
+                const oauth = parsed.claudeAiOauth;
+                const token = oauth?.accessToken;
+                if (typeof token === 'string' && token) {
+                    debugLog('keychain token found');
+                    resolve(token);
+                }
+                else {
+                    debugLog('keychain: no accessToken in parsed data');
+                    resolve(null);
+                }
+            }
+            catch {
+                // Keychain value might be the raw token string
+                const trimmed = stdout.trim();
+                if (trimmed.length > 20) {
+                    debugLog('keychain: raw token string');
+                    resolve(trimmed);
+                }
+                else {
+                    debugLog('keychain: unparseable value');
+                    resolve(null);
+                }
+            }
+        });
+    });
+}
+/**
+ * Get OAuth credentials using platform-appropriate strategy.
+ * macOS: Keychain first, then file fallback. Other platforms: file only.
+ * Hybrid: if Keychain has token but no subscriptionType, merge from file.
+ */
+export async function getCredentials() {
+    const fileCreds = readCredentialsFile();
+    if (process.platform !== 'darwin') {
+        debugLog('non-darwin: file credentials only', { found: !!fileCreds });
+        return fileCreds;
+    }
+    // macOS: try Keychain first
+    const keychainToken = await readKeychainToken();
+    if (keychainToken) {
+        // Merge subscriptionType from file if Keychain doesn't have it
+        const subscriptionType = fileCreds?.subscriptionType;
+        debugLog('using keychain token', { hasSubscriptionType: !!subscriptionType });
+        return { accessToken: keychainToken, subscriptionType };
+    }
+    // Fallback to file
+    debugLog('keychain failed, falling back to file', { found: !!fileCreds });
+    return fileCreds;
+}
+//# sourceMappingURL=credentials.js.map

package/dist/hud/git.d.ts

@@ -0,0 +1,7 @@
+import type { GitStatus } from './types.js';
+/**
+ * Gather git status for the given working directory.
+ * Returns null if not in a git repo or on error.
+ */
+export declare function gatherGitStatus(cwd: string): Promise<GitStatus | null>;
+//# sourceMappingURL=git.d.ts.map

package/dist/hud/git.js

@@ -0,0 +1,153 @@
+import { execFile } from 'node:child_process';
+const GIT_TIMEOUT = 1000; // 1s per command
+function shellExec(cmd, args, cwd) {
+    return new Promise((resolve) => {
+        execFile(cmd, args, { cwd, timeout: GIT_TIMEOUT }, (err, stdout) => {
+            resolve(err ? '' : stdout.trim());
+        });
+    });
+}
+function gitExec(args, cwd) {
+    return shellExec('git', args, cwd);
+}
+/**
+ * Gather git status for the given working directory.
+ * Returns null if not in a git repo or on error.
+ */
+export async function gatherGitStatus(cwd) {
+    // Check if in a git repo
+    const topLevel = await gitExec(['rev-parse', '--show-toplevel'], cwd);
+    if (!topLevel)
+        return null;
+    // Branch name
+    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);
+    let dirty = false;
+    let staged = false;
+    for (const line of statusOutput.split('\n')) {
+        if (line.length < 2)
+            continue;
+        const index = line[0];
+        const worktree = line[1];
+        // Index column: staged change (A/M/D/R/C)
+        if (index !== ' ' && index !== '?')
+            staged = true;
+        // Worktree column: unstaged change (M/D), or untracked (??)
+        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;
+    }
+    // Tag and worktree info (parallel)
+    const [tagOutput, worktreeOutput] = await Promise.all([
+        gitExec(['describe', '--tags', '--abbrev=0'], cwd),
+        gitExec(['worktree', 'list'], cwd),
+    ]);
+    const lastTag = tagOutput || null;
+    let commitsSinceTag = 0;
+    if (lastTag) {
+        const countOutput = await gitExec(['rev-list', `${lastTag}..HEAD`, '--count'], cwd);
+        commitsSinceTag = parseInt(countOutput, 10) || 0;
+    }
+    const worktreeCount = worktreeOutput
+        ? worktreeOutput.split('\n').filter(l => l.trim().length > 0).length
+        : 1;
+    return {
+        branch,
+        dirty,
+        staged,
+        ahead,
+        behind,
+        filesChanged,
+        additions,
+        deletions,
+        lastTag,
+        commitsSinceTag,
+        worktreeCount,
+    };
+}
+/**
+ * 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
+ */
+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;
+        }
+    }
+    // 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;
+        }
+    }
+    // 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)
+            return candidate;
+    }
+    return null;
+}
+//# sourceMappingURL=git.js.map

package/dist/hud/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/hud/index.js

@@ -0,0 +1,81 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+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 { gatherConfigCounts } from './components/config-counts.js';
+import { render } from './render.js';
+const OVERALL_TIMEOUT = 2000; // 2 second overall timeout
+async function main() {
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), OVERALL_TIMEOUT));
+    try {
+        const result = await Promise.race([run(), timeoutPromise]);
+        process.stdout.write(result);
+    }
+    catch {
+        // Timeout or error — output nothing (graceful degradation)
+    }
+}
+async function run() {
+    const stdin = await readStdin();
+    // Debug: dump raw stdin to file when DEVFLOW_HUD_DEBUG is set
+    if (process.env.DEVFLOW_HUD_DEBUG) {
+        fs.writeFileSync(process.env.DEVFLOW_HUD_DEBUG, JSON.stringify(stdin, null, 2));
+    }
+    const config = loadConfig();
+    const resolved = resolveComponents(config);
+    const components = new Set(resolved);
+    const cwd = stdin.cwd || process.cwd();
+    const devflowDir = process.env.DEVFLOW_DIR ||
+        path.join(process.env.HOME || homedir(), '.devflow');
+    // Determine what data to gather based on enabled components
+    const needsGit = components.has('gitBranch') ||
+        components.has('gitAheadBehind') ||
+        components.has('diffStats') ||
+        components.has('releaseInfo') ||
+        components.has('worktreeCount');
+    const needsTranscript = components.has('todoProgress') ||
+        components.has('configCounts');
+    const needsUsage = components.has('usageQuota');
+    const needsConfigCounts = components.has('configCounts');
+    // Parallel data gathering — only fetch what's needed
+    const [git, transcript, usage] = 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),
+    ]);
+    // Session start time from transcript file creation time
+    let sessionStartTime = null;
+    if (stdin.transcript_path) {
+        try {
+            const stat = fs.statSync(stdin.transcript_path);
+            sessionStartTime = stat.birthtime.getTime();
+        }
+        catch { /* file may not exist yet */ }
+    }
+    // Config counts (fast, synchronous filesystem reads)
+    const configCountsData = needsConfigCounts
+        ? gatherConfigCounts(cwd)
+        : null;
+    // Terminal width via stderr (stdout is piped to Claude Code)
+    const terminalWidth = process.stderr.columns || 120;
+    const ctx = {
+        stdin,
+        git,
+        transcript,
+        usage,
+        configCounts: configCountsData,
+        config: { ...config, components: resolved },
+        devflowDir,
+        sessionStartTime,
+        terminalWidth,
+    };
+    return render(ctx);
+}
+main();
+//# sourceMappingURL=index.js.map

package/dist/hud/render.d.ts

@@ -0,0 +1,7 @@
+import type { GatherContext } from './types.js';
+/**
+ * Render all enabled components into a multi-line HUD string.
+ * Components that return null are excluded. Empty lines are skipped.
+ */
+export declare function render(ctx: GatherContext): Promise<string>;
+//# sourceMappingURL=render.d.ts.map

package/dist/hud/render.js

@@ -0,0 +1,111 @@
+import { dim } from './colors.js';
+import directory from './components/directory.js';
+import gitBranch from './components/git-branch.js';
+import gitAheadBehind from './components/git-ahead-behind.js';
+import diffStats from './components/diff-stats.js';
+import model from './components/model.js';
+import contextUsage from './components/context-usage.js';
+import versionBadge from './components/version-badge.js';
+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 sessionCost from './components/session-cost.js';
+import releaseInfo from './components/release-info.js';
+import worktreeCount from './components/worktree-count.js';
+const COMPONENT_MAP = {
+    directory,
+    gitBranch,
+    gitAheadBehind,
+    diffStats,
+    model,
+    contextUsage,
+    versionBadge,
+    sessionDuration,
+    usageQuota,
+    todoProgress,
+    configCounts,
+    sessionCost,
+    releaseInfo,
+    worktreeCount,
+};
+/**
+ * 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'],
+    ['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.
+ */
+export async function render(ctx) {
+    const enabled = new Set(ctx.config.components);
+    // Render all enabled components in parallel
+    const results = new Map();
+    const promises = [];
+    for (const id of enabled) {
+        const fn = COMPONENT_MAP[id];
+        if (!fn)
+            continue;
+        promises.push(fn(ctx)
+            .then((result) => {
+            if (result)
+                results.set(id, result);
+        })
+            .catch(() => {
+            /* Component failure is non-fatal */
+        }));
+    }
+    await Promise.all(promises);
+    // Assemble lines using smart layout with section breaks
+    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) {
+                if (r.text.includes('\n')) {
+                    // Flush any accumulated single-line parts first
+                    if (singleLine.length > 0) {
+                        lines.push(singleLine.join(SEPARATOR));
+                        singleLine.length = 0;
+                    }
+                    lines.push(r.text);
+                }
+                else {
+                    singleLine.push(r.text);
+                }
+            }
+            if (singleLine.length > 0) {
+                lines.push(singleLine.join(SEPARATOR));
+            }
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=render.js.map

package/dist/hud/stdin.d.ts

@@ -0,0 +1,6 @@
+import type { StdinData } from './types.js';
+/**
+ * Read and parse JSON from stdin. Returns empty object on parse failure.
+ */
+export declare function readStdin(): Promise<StdinData>;
+//# sourceMappingURL=stdin.d.ts.map

package/dist/hud/stdin.js

@@ -0,0 +1,25 @@
+/**
+ * Read and parse JSON from stdin. Returns empty object on parse failure.
+ */
+export function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                resolve({});
+            }
+        });
+        process.stdin.on('error', () => {
+            resolve({});
+        });
+        process.stdin.resume();
+    });
+}
+//# sourceMappingURL=stdin.js.map

package/dist/hud/transcript.d.ts

@@ -0,0 +1,7 @@
+import type { TranscriptData } from './types.js';
+/**
+ * Parse a Claude Code session transcript (JSONL) to extract tool/agent activity and todo progress.
+ * Returns null if the file doesn't exist or can't be parsed.
+ */
+export declare function parseTranscript(transcriptPath: string): Promise<TranscriptData | null>;
+//# sourceMappingURL=transcript.d.ts.map