devflow-kit 1.8.2 → 2.0.0

package/dist/cli/commands/hud.js

@@ -0,0 +1,229 @@
+import { Command } from 'commander';
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
+import { getClaudeDirectory, getDevFlowDirectory } from '../../targets/claude-code/claude-paths.js';
+import { syncManifestFeature } from '../../core/manifest.js';
+import { writeFileAtomicExclusive } from '../../core/fs-atomic.js';
+import { HUD_COMPONENTS, loadConfig, saveConfig, } from '../../hud/config.js';
+/**
+ * Add the HUD statusLine to settings JSON.
+ * Idempotent — returns unchanged JSON if HUD already set.
+ * Upgrades legacy statusline.sh to hud.sh automatically.
+ */
+export function addHudStatusLine(settingsJson, devflowDir) {
+    const settings = JSON.parse(settingsJson);
+    const hudCommand = path.join(devflowDir, 'scripts', 'hud.sh');
+    // Already pointing to this exact HUD — nothing to do
+    if (settings.statusLine?.command === hudCommand) {
+        return settingsJson;
+    }
+    // If there's a non-Devflow statusLine, don't overwrite (caller should check first)
+    if (settings.statusLine && !isDevFlowStatusLine(settings.statusLine)) {
+        return settingsJson;
+    }
+    settings.statusLine = {
+        type: 'command',
+        command: hudCommand,
+    };
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Remove the HUD statusLine from settings JSON.
+ * Idempotent — returns unchanged JSON if statusLine not present or not Devflow.
+ */
+export function removeHudStatusLine(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.statusLine) {
+        return settingsJson;
+    }
+    // Only remove if it's a Devflow HUD/statusline
+    if (!isDevFlowStatusLine(settings.statusLine)) {
+        return settingsJson;
+    }
+    delete settings.statusLine;
+    return JSON.stringify(settings, null, 2) + '\n';
+}
+/**
+ * Check if the statusLine in settings JSON points to the Devflow HUD.
+ */
+export function hasHudStatusLine(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.statusLine)
+        return false;
+    return isDevFlowStatusLine(settings.statusLine);
+}
+/**
+ * Check if an existing statusLine belongs to Devflow (HUD or legacy statusline).
+ * Matches paths containing 'hud.sh', 'statusline.sh', or a '/devflow/' directory segment.
+ */
+function isDevFlowStatusLine(statusLine) {
+    const cmd = statusLine.command ?? '';
+    return (cmd.includes('hud.sh') ||
+        cmd.includes('statusline.sh') ||
+        cmd.includes('/devflow/') ||
+        cmd.includes('\\devflow\\'));
+}
+/**
+ * Check if an existing statusLine belongs to a non-Devflow tool.
+ */
+export function hasNonDevFlowStatusLine(settingsJson) {
+    const settings = JSON.parse(settingsJson);
+    if (!settings.statusLine?.command)
+        return false;
+    return !isDevFlowStatusLine(settings.statusLine);
+}
+/**
+ * Build a fresh Commander Command for the `hud` subcommand.
+ * Exported for tests that need per-test isolation without resorting to
+ * Commander's private `_optionValues` field.
+ */
+export function createHudCommand() {
+    return new Command('hud')
+        .description('Configure the HUD (status line)')
+        .option('--status', 'Show current HUD config')
+        .option('--detail', 'Show tool/agent descriptions in HUD')
+        .option('--no-detail', 'Hide tool/agent descriptions')
+        .option('--enable', 'Enable HUD in settings')
+        .option('--disable', 'Disable HUD (remove statusLine)')
+        .action(async (options) => {
+        const hasFlag = options.status ||
+            options.enable ||
+            options.disable ||
+            options.detail !== undefined;
+        if (!hasFlag) {
+            p.intro(color.bgCyan(color.white(' HUD ')));
+            p.note(`${color.cyan('devflow hud --detail')}      Show tool/agent descriptions\n` +
+                `${color.cyan('devflow hud --no-detail')}   Hide tool/agent descriptions\n` +
+                `${color.cyan('devflow hud --status')}      Show current config\n` +
+                `${color.cyan('devflow hud --enable')}      Enable HUD in settings\n` +
+                `${color.cyan('devflow hud --disable')}     Remove HUD from settings`, 'Usage');
+            p.note(`${HUD_COMPONENTS.length} components: ${HUD_COMPONENTS.join(', ')}`, 'Components');
+            p.outro(color.dim('Toggle with --enable / --disable'));
+            return;
+        }
+        if (options.status) {
+            const config = loadConfig();
+            p.intro(color.bgCyan(color.white(' HUD Status ')));
+            p.note(`${color.dim('Enabled:')}    ${config.enabled ? color.green('yes') : color.dim('no')}\n` +
+                `${color.dim('Detail:')}     ${config.detail ? color.green('on') : color.dim('off')}\n` +
+                `${color.dim('Components:')} ${HUD_COMPONENTS.length}`, 'Current config');
+            // Check settings.json
+            const claudeDir = getClaudeDirectory();
+            const settingsPath = path.join(claudeDir, 'settings.json');
+            try {
+                const content = await fs.readFile(settingsPath, 'utf-8');
+                const enabled = hasHudStatusLine(content);
+                p.log.info(`Status line: ${enabled ? color.green('enabled') : color.dim('disabled')}`);
+            }
+            catch {
+                p.log.info(`Status line: ${color.dim('no settings.json found')}`);
+            }
+            return;
+        }
+        if (options.detail !== undefined) {
+            const config = loadConfig();
+            config.detail = options.detail;
+            saveConfig(config);
+            p.log.success(`HUD detail ${config.detail ? 'enabled' : 'disabled'}`);
+            return;
+        }
+        if (options.enable) {
+            const claudeDir = getClaudeDirectory();
+            const devflowDir = getDevFlowDirectory();
+            const settingsPath = path.join(claudeDir, 'settings.json');
+            let settingsContent;
+            try {
+                settingsContent = await fs.readFile(settingsPath, 'utf-8');
+            }
+            catch {
+                settingsContent = '{}';
+            }
+            // Ensure statusLine is registered (idempotent — adds only if missing).
+            // This runs unconditionally so a missing statusLine is repaired even when
+            // config already says enabled (@D2 symmetric self-heal with --disable).
+            if (!hasHudStatusLine(settingsContent)) {
+                // Check for non-Devflow statusLine
+                if (hasNonDevFlowStatusLine(settingsContent)) {
+                    const settings = JSON.parse(settingsContent);
+                    p.log.warn(`Existing statusLine found: ${color.dim(settings.statusLine?.command ?? 'unknown')}`);
+                    if (process.stdin.isTTY) {
+                        const overwrite = await p.confirm({
+                            message: 'Replace existing statusLine with Devflow HUD?',
+                            initialValue: false,
+                        });
+                        if (p.isCancel(overwrite) || !overwrite) {
+                            p.log.info('HUD not enabled — existing statusLine preserved');
+                            return;
+                        }
+                        // User confirmed: clear the non-Devflow statusLine so
+                        // addHudStatusLine can write the Devflow HUD. The guard inside
+                        // addHudStatusLine protects callers that haven't confirmed yet;
+                        // this call site has confirmed, so clear the field first.
+                        const confirmed = JSON.parse(settingsContent);
+                        delete confirmed.statusLine;
+                        settingsContent = JSON.stringify(confirmed, null, 2) + '\n';
+                    }
+                    else {
+                        p.log.info('Non-interactive mode — skipping (existing statusLine would be overwritten)');
+                        return;
+                    }
+                }
+                const updated = addHudStatusLine(settingsContent, devflowDir);
+                await writeFileAtomicExclusive(settingsPath, updated);
+            }
+            // Always update config and sync manifest — removing the already-enabled
+            // early-return makes --enable self-healing symmetric with --disable.
+            // @D2 a drifted manifest (hud=false when config says enabled) is repaired
+            // on --enable without requiring a disable/re-enable cycle.
+            const config = loadConfig();
+            const wasEnabled = config.enabled;
+            if (!wasEnabled) {
+                saveConfig({ ...config, enabled: true });
+            }
+            await syncManifestFeature(devflowDir, 'hud', true);
+            if (wasEnabled) {
+                p.log.info('HUD already enabled');
+            }
+            else {
+                p.log.success('HUD enabled');
+                p.log.info(color.dim('Restart Claude Code to see the HUD'));
+            }
+        }
+        if (options.disable) {
+            const config = loadConfig();
+            const wasEnabled = config.enabled;
+            // Always update config to disabled (idempotent).
+            if (wasEnabled) {
+                saveConfig({ ...config, enabled: false });
+            }
+            // @D1 Always attempt to hard-remove the statusLine from settings.json,
+            // regardless of config.enabled. This self-heals drift where hud.json says
+            // disabled but a Devflow statusLine still lingers in settings.json from a
+            // partial prior state (e.g. crash between config-write and settings-write).
+            const claudeDir = getClaudeDirectory();
+            const settingsPath = path.join(claudeDir, 'settings.json');
+            let statusLineRemoved = false;
+            try {
+                const settingsContent = await fs.readFile(settingsPath, 'utf-8');
+                const updated = removeHudStatusLine(settingsContent);
+                if (updated !== settingsContent) {
+                    await writeFileAtomicExclusive(settingsPath, updated);
+                    statusLineRemoved = true;
+                }
+            }
+            catch {
+                // settings.json may not exist — non-fatal
+            }
+            if (!wasEnabled && !statusLineRemoved) {
+                p.log.info('HUD already disabled');
+                return;
+            }
+            await syncManifestFeature(getDevFlowDirectory(), 'hud', false);
+            p.log.success('HUD disabled');
+        }
+    });
+}
+export const hudCommand = createHudCommand();
+//# sourceMappingURL=hud.js.map

package/dist/cli/commands/init-seed.js

@@ -0,0 +1,226 @@
+/**
+ * Pure seeding helpers for devflow init.
+ *
+ * Computes the initial state (seed) for init prompts from:
+ * - The existing manifest (from a prior install)
+ * - The project feature config (.devflow/config.json)
+ * - The current settings.json snapshot (for viewMode)
+ * - The plugin registry
+ *
+ * All exported functions are pure — no I/O, no side effects.
+ *
+ * Applies ADR-013: seeding helpers are CLI-init-specific logic, so they live
+ * beside init.ts in src/cli/commands/ rather than in src/core/ (which holds
+ * agent-neutral, target-agnostic utilities).
+ */
+import { resolveExistingViewMode, FLAG_REGISTRY } from '../../core/flags.js';
+import { partitionSelectablePlugins } from '../../core/plugins.js';
+/** Registry defaults — all features enabled except proxy (advanced-only, off by default). */
+export const FEATURE_DEFAULTS = {
+    ambient: true,
+    memory: true,
+    hud: true,
+    knowledge: true,
+    learning: true,
+    rules: true,
+    proxy: false,
+    compliance: { enabled: false, frameworks: [] },
+};
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Resolve feature booleans for the init seed.
+ *
+ * - memory / learning / knowledge come from projectConfig WHENEVER present,
+ *   independent of whether a manifest exists (covers config-present /
+ *   manifest-missing cases such as a fresh project with a prior learning run).
+ * - ambient / hud / rules come from manifest.features; registry defaults
+ *   (all true) are used when the manifest is absent.
+ *
+ * Applies ADR-001: .devflow/config.json is the source of truth for
+ * memory/learning/knowledge; manifest reflects the last install choices for
+ * the remaining toggles.
+ */
+export function resolveSeedFeatures(manifest, projectConfig) {
+    // ambient/hud/rules/proxy/compliance: manifest is the source; fall back to registry defaults.
+    // proxy and compliance follow the manifest group (like ambient) per ADR-001 — NOT config.json-gated.
+    const ambient = manifest?.features.ambient ?? FEATURE_DEFAULTS.ambient;
+    const hud = manifest?.features.hud ?? FEATURE_DEFAULTS.hud;
+    const rules = manifest?.features.rules ?? FEATURE_DEFAULTS.rules;
+    const proxy = manifest?.features.proxy ?? FEATURE_DEFAULTS.proxy;
+    // Return a fresh object so callers never hold a reference to FEATURE_DEFAULTS.compliance.
+    // Without the spread, `manifest?.features.compliance ?? FEATURE_DEFAULTS.compliance` returns
+    // the module-level default by reference — downstream mutation would corrupt it process-wide.
+    const rawCompliance = manifest?.features.compliance ?? FEATURE_DEFAULTS.compliance;
+    const compliance = { ...rawCompliance, frameworks: [...rawCompliance.frameworks] };
+    // memory/learning/knowledge: projectConfig wins whenever present (ADR-001).
+    // Helper eliminates the repeated projectConfig !== null ternary pattern.
+    const fromConfig = (key) => projectConfig !== null
+        ? projectConfig[key]
+        : (manifest?.features[key] ?? FEATURE_DEFAULTS[key]);
+    const memory = fromConfig('memory');
+    const knowledge = fromConfig('knowledge');
+    const learning = fromConfig('learning');
+    return { ambient, memory, hud, knowledge, learning, rules, proxy, compliance };
+}
+/**
+ * Resolve the enabled flag set for the init seed.
+ *
+ * @param enabledFlags - Currently-enabled flag IDs from the manifest,
+ *                       or null for a fresh install (no prior manifest).
+ * @param knownFlags   - Snapshot of all flag IDs known at the last install
+ *                       (manifest.features.knownFlags), or undefined when
+ *                       the manifest pre-dates the snapshot feature.
+ * @param registry     - Flag registry to consult; injectable for tests.
+ *
+ * Rules:
+ *   - null enabledFlags (fresh) → all default-ON flags in the registry
+ *   - knownFlags === undefined (old manifest, migration) → return enabledFlags
+ *     as-is; adopt nothing new (safe: user's prior choices preserved)
+ *   - Otherwise → enabledFlags ∪ {default-ON flags whose id ∉ knownFlags}
+ *     (newly added registry entries that the user never saw before are auto-adopted)
+ *   - Default-OFF flags are NEVER auto-added regardless of knownFlags
+ */
+export function resolveSeedFlags(enabledFlags, knownFlags, registry = FLAG_REGISTRY) {
+    // Fresh install → all default-ON flags from the registry
+    if (enabledFlags === null) {
+        return registry.filter(f => f.defaultEnabled).map(f => f.id);
+    }
+    // Old manifest without a knownFlags snapshot → adopt nothing new
+    if (knownFlags === undefined) {
+        return [...enabledFlags];
+    }
+    // Re-init with a knownFlags snapshot: union existing + newly-added default-ON entries
+    const knownSet = new Set(knownFlags);
+    const result = new Set(enabledFlags);
+    for (const flag of registry) {
+        if (flag.defaultEnabled && !knownSet.has(flag.id)) {
+            result.add(flag.id);
+        }
+    }
+    return [...result];
+}
+/**
+ * Resolve the plugin selection buckets for the init seed.
+ *
+ * @param manifestPlugins - Plugin names stored in the existing manifest,
+ *                          or null for a fresh install.
+ * @param knownPlugins    - Plugin name snapshot from the last install
+ *                          (manifest.knownPlugins), or undefined when the
+ *                          manifest pre-dates the snapshot feature.
+ * @param allPlugins      - Full plugin registry.
+ *
+ * Rules:
+ *   - null manifestPlugins (fresh) → non-optional workflow plugins preselected,
+ *     empty language list (matches current init UI defaults)
+ *   - knownPlugins === undefined → split existing into workflow/language buckets,
+ *     adopt nothing new
+ *   - Otherwise → split + adopt newly-added non-optional selectable plugins
+ *     whose name is ∉ knownPlugins and ∉ manifestPlugins
+ *
+ * Always-installed plugins (devflow-core-skills, devflow-ambient) are filtered
+ * out by partitionSelectablePlugins and never appear in the returned buckets.
+ */
+export function resolveSeedPlugins(manifestPlugins, knownPlugins, allPlugins) {
+    const { workflow, language } = partitionSelectablePlugins(allPlugins);
+    const workflowNames = new Set(workflow.map(p => p.name));
+    const languageNames = new Set(language.map(p => p.name));
+    // Fresh install → non-optional workflow plugins preselected, empty language
+    if (manifestPlugins === null) {
+        return {
+            workflowPlugins: workflow.filter(p => !p.optional).map(p => p.name),
+            languagePlugins: [],
+        };
+    }
+    // Split existing manifest plugins into the selectable buckets
+    const workflowPlugins = manifestPlugins.filter(n => workflowNames.has(n));
+    const languagePlugins = manifestPlugins.filter(n => languageNames.has(n));
+    // Old manifest (no knownPlugins snapshot) → adopt nothing new
+    if (knownPlugins === undefined) {
+        return { workflowPlugins, languagePlugins };
+    }
+    // Re-init with a knownPlugins snapshot: adopt new non-optional selectable plugins
+    const knownSet = new Set(knownPlugins);
+    const manifestSet = new Set(manifestPlugins);
+    for (const plugin of allPlugins) {
+        if (plugin.optional)
+            continue; // never auto-adopt optional plugins
+        if (knownSet.has(plugin.name))
+            continue; // was known at last install
+        if (manifestSet.has(plugin.name))
+            continue; // already in the selection
+        if (workflowNames.has(plugin.name)) {
+            workflowPlugins.push(plugin.name);
+        }
+        else if (languageNames.has(plugin.name)) {
+            languagePlugins.push(plugin.name);
+        }
+        // excluded always-installed plugins: neither bucket — silently ignored
+    }
+    return { workflowPlugins, languagePlugins };
+}
+/**
+ * Compose the full init seed from manifest, project config, settings, and registry.
+ *
+ * viewMode priority: existing settings.json (non-default) → manifest → 'default'
+ *
+ * This is the single composition point; callers (init.ts hoist block) call this
+ * once and pass `seed` down to Phase 4's prompt wiring.
+ */
+export function resolveInitSeed(seedManifest, seedConfig, settingsSnapshot, plugins) {
+    const features = resolveSeedFeatures(seedManifest, seedConfig);
+    // null for a fresh install (no manifest); string[] from manifest otherwise
+    const enabledFlags = seedManifest !== null ? seedManifest.features.flags : null;
+    const flags = resolveSeedFlags(enabledFlags, seedManifest?.features.knownFlags);
+    const manifestPlugins = seedManifest !== null ? seedManifest.plugins : null;
+    const { workflowPlugins, languagePlugins } = resolveSeedPlugins(manifestPlugins, seedManifest?.knownPlugins, plugins);
+    // viewMode: non-default setting wins; else manifest; else 'default'
+    const viewMode = resolveExistingViewMode(settingsSnapshot) ??
+        seedManifest?.features.viewMode ??
+        'default';
+    return { features, flags, viewMode, workflowPlugins, languagePlugins };
+}
+/**
+ * Resolve the three seed inputs under the --reset gate.
+ *
+ * --reset is a factory reset: the prior manifest, the prior project config, AND
+ * the current settings.json snapshot are all discarded so the seed collapses to
+ * registry defaults. Emptying the settings snapshot is essential — otherwise
+ * resolveInitSeed's viewMode resolution would surface an externally-set value
+ * (e.g. a /focus mode persisted in settings.json) and defeat the reset. This
+ * keeps --reset faithful to its USER-LOCKED contract: viewMode is forced to
+ * 'default'.
+ *
+ * The caller must still use the REAL (un-emptied) settings/manifest elsewhere —
+ * e.g. for security deny-state detection and installedAt preservation. This
+ * helper only shapes the inputs handed to resolveInitSeed.
+ *
+ * Pure function — no I/O, no side effects.
+ */
+export function resolveResetGatedInputs(reset, manifest, projectConfig, settingsJson) {
+    if (reset) {
+        return { seedManifest: null, seedConfig: null, seedSettings: '' };
+    }
+    return { seedManifest: manifest, seedConfig: projectConfig, seedSettings: settingsJson };
+}
+/**
+ * Apply CLI-explicit feature toggles on top of a seed's features.
+ *
+ * Per-key: `toggles.X ?? base.X` — an explicit CLI value (true/false) wins;
+ * undefined means "user did not specify this flag, keep the seed value".
+ *
+ * Used in Phase 4 to honour --ambient/--no-ambient etc. passed alongside
+ * --recommended.
+ */
+export function applyCliToggles(base, toggles) {
+    return {
+        ambient: toggles.ambient ?? base.ambient,
+        memory: toggles.memory ?? base.memory,
+        hud: toggles.hud ?? base.hud,
+        knowledge: toggles.knowledge ?? base.knowledge,
+        learning: toggles.learning ?? base.learning,
+        rules: toggles.rules ?? base.rules,
+        proxy: toggles.proxy ?? base.proxy,
+        compliance: toggles.compliance ?? base.compliance,
+    };
+}
+//# sourceMappingURL=init-seed.js.map