praxis-agent 0.6.0 → 0.8.0

package/dist/cli/tui/config-dashboard.d.ts

@@ -0,0 +1,63 @@
+import React from 'react';
+import type { ModelUsage } from '../../core/runtime.js';
+import { type ConfigSettingDefinition, type ConfigSettingsSnapshot, type ConfigValue } from './config-settings.js';
+export type ConfigDashboardTab = 'settings' | 'status' | 'config' | 'usage' | 'stats';
+export interface ConfigStatusData {
+    version: string;
+    sessionName?: string;
+    sessionId: string;
+    cwd: string;
+    authSource?: string;
+    baseUrl?: string;
+    model: string;
+    settingSources: readonly string[];
+}
+export interface ConfigUsageData {
+    costUsd: number;
+    apiDurationMs: number;
+    wallDurationMs: number;
+    linesAdded: number;
+    linesRemoved: number;
+    usage: ModelUsage;
+}
+export interface ContextCategory {
+    label: string;
+    tokens: number;
+}
+export interface ConfigContextData {
+    contextWindowTokens: number;
+    categories: readonly ContextCategory[];
+}
+export interface ConfigDashboardValueRow {
+    label: string;
+    value: string;
+}
+export interface ConfigRow {
+    definition: ConfigSettingDefinition;
+    value: ConfigValue;
+    displayValue: string;
+}
+export type ConfigEffectiveValues = Readonly<Partial<Record<string, ConfigValue>>>;
+export declare function projectConfigRows(snapshot: ConfigSettingsSnapshot, query?: string, effectiveValues?: ConfigEffectiveValues): ConfigRow[];
+export declare function projectContextUsage(data: ConfigContextData): {
+    categories: ContextCategory[];
+    usedTokens: number;
+    freeTokens: number;
+    contextWindowTokens: number;
+};
+export declare function ConfigDashboard({ tab, snapshot, query, selectedIndex, searchFocused, status, usage, settings, stats, effectiveValues, width, screenReader, maxRows, }: {
+    tab: ConfigDashboardTab;
+    snapshot: ConfigSettingsSnapshot;
+    query?: string;
+    selectedIndex?: number;
+    searchFocused?: boolean;
+    status?: ConfigStatusData;
+    usage?: ConfigUsageData;
+    settings?: readonly ConfigDashboardValueRow[];
+    stats?: readonly ConfigDashboardValueRow[];
+    effectiveValues?: ConfigEffectiveValues;
+    width: number;
+    screenReader: boolean;
+    maxRows?: number;
+}): React.JSX.Element;
+//# sourceMappingURL=config-dashboard.d.ts.map

package/dist/cli/tui/config-dashboard.js

@@ -0,0 +1,150 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { CLAUDE_2_1_208_CONFIG_SETTINGS, configSettingValue, } from './config-settings.js';
+const tabs = [
+    { id: 'settings', label: 'Settings' },
+    { id: 'status', label: 'Status' },
+    { id: 'config', label: 'Config' },
+    { id: 'usage', label: 'Usage' },
+    { id: 'stats', label: 'Stats' },
+];
+function displayValue(definition, value) {
+    if (definition.id === 'permissionMode') {
+        return ({
+            default: 'Manual',
+            plan: 'Plan',
+            acceptEdits: 'Accept edits',
+            auto: 'Auto',
+            dontAsk: "Don't ask",
+        }[String(value)] ?? String(value));
+    }
+    if (definition.id === 'theme') {
+        return ({
+            auto: 'Auto',
+            dark: 'Dark mode',
+            light: 'Light mode',
+            'light-daltonized': 'Light mode (colorblind-friendly)',
+            'dark-daltonized': 'Dark mode (colorblind-friendly)',
+            'light-ansi': 'Light mode (ANSI colors only)',
+            'dark-ansi': 'Dark mode (ANSI colors only)',
+        }[String(value)] ?? String(value));
+    }
+    if (definition.id === 'notifChannel') {
+        return ({
+            auto: 'Auto',
+            iterm2: 'iTerm2 (OSC 9)',
+            terminal_bell: 'Terminal bell',
+            iterm2_with_bell: 'iTerm2 and terminal bell',
+            kitty: 'Kitty',
+            ghostty: 'Ghostty',
+            notifications_disabled: 'Disabled',
+        }[String(value)] ?? String(value));
+    }
+    if (definition.id === 'language' && value === 'default')
+        return 'Default (English)';
+    return String(value);
+}
+export function projectConfigRows(snapshot, query = '', effectiveValues = {}) {
+    const normalized = query.trim().toLowerCase();
+    return CLAUDE_2_1_208_CONFIG_SETTINGS.map((definition) => {
+        const value = effectiveValues[definition.id] ?? configSettingValue(snapshot, definition);
+        return { definition, value, displayValue: displayValue(definition, value) };
+    }).filter((row) => !normalized ||
+        row.definition.label.toLowerCase().includes(normalized) ||
+        row.definition.nativeKey.toLowerCase().includes(normalized) ||
+        row.displayValue.toLowerCase().includes(normalized));
+}
+export function projectContextUsage(data) {
+    if (!Number.isSafeInteger(data.contextWindowTokens) ||
+        data.contextWindowTokens <= 0)
+        throw new Error('Context window must be a positive integer');
+    const categories = data.categories.map((category) => {
+        if (!Number.isSafeInteger(category.tokens) || category.tokens < 0)
+            throw new Error(`Invalid context category tokens: ${category.label}`);
+        return category;
+    });
+    const usedTokens = categories.reduce((total, category) => total + category.tokens, 0);
+    if (usedTokens > data.contextWindowTokens)
+        throw new Error('Measured context categories exceed the context window');
+    return {
+        categories,
+        usedTokens,
+        freeTokens: data.contextWindowTokens - usedTokens,
+        contextWindowTokens: data.contextWindowTokens,
+    };
+}
+function DashboardTabs({ active, screenReader, }) {
+    if (screenReader) {
+        return (_jsx(Box, { flexDirection: "column", children: tabs.map((tab) => (_jsxs(Text, { children: [tab.id === active ? 'Selected tab: ' : '', tab.label] }, tab.id))) }));
+    }
+    return (_jsxs(Text, { children: ['  ', tabs.map((tab) => (_jsxs(Text, { inverse: tab.id === active, children: [' ', tab.label, ' '] }, tab.id)))] }));
+}
+function ConfigRows({ rows, query, selectedIndex, searchFocused, maxRows, screenReader, width, }) {
+    const bounded = Math.max(1, maxRows);
+    const start = Math.max(0, Math.min(selectedIndex - bounded + 1, rows.length - bounded));
+    const visible = rows.slice(start, start + bounded);
+    return (_jsxs(_Fragment, { children: [_jsx(Box, { borderStyle: screenReader ? undefined : 'round', paddingX: 1, children: _jsxs(Text, { inverse: searchFocused, children: ["\u2315 ", query || 'Search settings…'] }) }), _jsx(Text, { children: " " }), start > 0 ? _jsxs(Text, { children: [" \u2191 ", start, " more above"] }) : null, visible.map((row, offset) => {
+                const index = start + offset;
+                const selected = index === selectedIndex && !searchFocused;
+                const stacked = width < 60;
+                return (_jsxs(Box, { flexDirection: stacked ? 'column' : 'row', children: [_jsx(Box, { width: stacked ? undefined : Math.min(46, width - 12), children: _jsxs(Text, { inverse: !screenReader && selected, children: [screenReader && selected
+                                        ? 'Selected: '
+                                        : selected
+                                            ? '❯ '
+                                            : '  ', row.definition.label] }) }), _jsx(Text, { children: stacked ? `  ${row.displayValue}` : row.displayValue })] }, row.definition.id));
+            }), start + visible.length < rows.length ? (_jsxs(Text, { children: [" \u2193 ", rows.length - start - visible.length, " more below"] })) : null, _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: searchFocused
+                    ? 'Type to filter · Enter/↓ to select · ↑ to tabs · Esc to clear'
+                    : 'Enter/Space to change · / to search · Esc to close' })] }));
+}
+function StatusRows({ status }) {
+    const rows = [
+        ['Version', status.version],
+        ['Session name', status.sessionName ?? '/rename to add a name'],
+        ['Session ID', status.sessionId],
+        ['cwd', status.cwd],
+        ...(status.authSource ? [['Auth token', status.authSource]] : []),
+        ...(status.baseUrl ? [['Provider base URL', status.baseUrl]] : []),
+        ['Model', status.model],
+        ['Setting sources', status.settingSources.join(', ')],
+    ];
+    return (_jsxs(_Fragment, { children: [rows.map(([label, value]) => (_jsxs(Box, { children: [_jsx(Box, { width: 22, children: _jsxs(Text, { children: [label, ":"] }) }), _jsx(Text, { children: value })] }, label))), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Esc to cancel" })] }));
+}
+function UsageRows({ usage }) {
+    const seconds = (milliseconds) => `${Math.round(milliseconds / 1_000)}s`;
+    return (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Session" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: ["Total cost: $", usage.costUsd.toFixed(4)] }), _jsxs(Text, { children: ["Total duration (API): ", seconds(usage.apiDurationMs)] }), _jsxs(Text, { children: ["Total duration (wall): ", seconds(usage.wallDurationMs)] }), _jsxs(Text, { children: ["Total code changes: ", usage.linesAdded, " lines added, ", usage.linesRemoved, ' ', "lines removed"] }), _jsxs(Text, { children: ["Usage: ", usage.usage.inputTokens, " input, ", usage.usage.outputTokens, ' ', "output, ", usage.usage.cacheReadInputTokens ?? 0, " cache read,", ' ', usage.usage.cacheCreationInputTokens ?? 0, " cache write"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: "Esc to cancel" })] }));
+}
+function ValueRows({ rows }) {
+    return rows.map((row) => (_jsxs(Box, { children: [_jsx(Box, { width: 28, children: _jsxs(Text, { children: [row.label, ":"] }) }), _jsx(Text, { children: row.value })] }, row.label)));
+}
+export function ConfigDashboard({ tab, snapshot, query = '', selectedIndex = 0, searchFocused = true, status, usage, settings, stats, effectiveValues, width, screenReader, maxRows = 18, }) {
+    const rows = projectConfigRows(snapshot, query, effectiveValues);
+    let content;
+    switch (tab) {
+        case 'settings':
+            if (settings === undefined)
+                throw new Error('Settings tab requires measured settings data');
+            content = _jsx(ValueRows, { rows: settings });
+            break;
+        case 'status':
+            if (status === undefined)
+                throw new Error('Status tab requires measured status data');
+            content = _jsx(StatusRows, { status: status });
+            break;
+        case 'config':
+            content = (_jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Config" }), _jsx(Text, { children: "Available commands: /config \u00B7 /status \u00B7 /usage" }), _jsx(ConfigRows, { rows: rows, query: query, selectedIndex: Math.max(0, Math.min(selectedIndex, rows.length - 1)), searchFocused: searchFocused, maxRows: maxRows, screenReader: screenReader, width: width })] }));
+            break;
+        case 'usage':
+            if (usage === undefined)
+                throw new Error('Usage tab requires measured usage data');
+            content = _jsx(UsageRows, { usage: usage });
+            break;
+        case 'stats':
+            if (stats === undefined)
+                throw new Error('Stats tab requires measured stats data');
+            content =
+                stats.length === 0 ? (_jsx(Text, { children: "No stats available yet. Start using Praxis Code!" })) : (_jsx(ValueRows, { rows: stats }));
+            break;
+    }
+    return (_jsxs(Box, { flexDirection: "column", width: Math.min(100, width), children: [!screenReader ? _jsx(Text, { children: '─'.repeat(Math.min(100, width)) }) : null, _jsx(DashboardTabs, { active: tab, screenReader: screenReader }), _jsx(Text, { children: " " }), content] }));
+}
+//# sourceMappingURL=config-dashboard.js.map

package/dist/cli/tui/config-settings.d.ts

@@ -0,0 +1,32 @@
+export type ConfigStorageScope = 'settings' | 'state';
+export type ConfigValue = boolean | string;
+export interface ConfigSettingDefinition {
+    id: string;
+    nativeKey: string;
+    label: string;
+    scope: ConfigStorageScope;
+    path: readonly string[];
+    values: readonly ConfigValue[] | 'language';
+    defaultValue: ConfigValue;
+    runtimeStatus: 'integrated' | 'interactive-integration' | 'not-applicable';
+    runtimeConsumer: string;
+    applicabilityReason?: string;
+}
+export interface ConfigSettingsSnapshot {
+    settings: Readonly<Record<string, unknown>>;
+    state: Readonly<Record<string, unknown>>;
+}
+export interface ConfigSettingsLocation {
+    configRoot: string;
+    statePath: string;
+}
+export type ConfigSettingsTarget = string | ConfigSettingsLocation;
+export declare const CLAUDE_2_1_208_CONFIG_SETTINGS: readonly [ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition, ConfigSettingDefinition];
+export declare function resolveConfigSettingsLocation(target?: ConfigSettingsTarget): ConfigSettingsLocation;
+export declare function configSettingDefinition(id: string): ConfigSettingDefinition | undefined;
+export declare function configSettingValue(snapshot: ConfigSettingsSnapshot, definition: ConfigSettingDefinition): ConfigValue;
+export declare function loadConfigSettings(target?: ConfigSettingsTarget): Promise<ConfigSettingsSnapshot>;
+export declare function saveConfigSetting(id: string, value: ConfigValue, target?: ConfigSettingsTarget, hooks?: {
+    afterValidation?: () => Promise<void>;
+}): Promise<ConfigSettingsSnapshot>;
+//# sourceMappingURL=config-settings.d.ts.map

package/dist/cli/tui/config-settings.js

@@ -0,0 +1,276 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { open, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { setTimeout } from 'node:timers/promises';
+import { writeFileAtomically } from '../../platform/atomic-write.js';
+import { ExclusiveFileLease, } from '../../platform/exclusive-file-lease.js';
+const booleanValues = [true, false];
+export const CLAUDE_2_1_208_CONFIG_SETTINGS = [
+    setting('autoCompact', 'Auto-compact', 'settings', ['autoCompactEnabled'], booleanValues, true, 'compaction threshold policy'),
+    setting('switchModelsOnFlag', 'Switch models when a message is flagged', 'settings', ['switchModelsOnFlag'], booleanValues, true, 'provider capability-aware model fallback'),
+    setting('tips', 'Show tips', 'settings', ['spinnerTipsEnabled'], booleanValues, true, 'interactive spinner tips'),
+    setting('reduceMotion', 'Reduce motion', 'settings', ['prefersReducedMotion'], booleanValues, false, 'all animated TUI surfaces'),
+    setting('thinking', 'Thinking mode', 'settings', ['alwaysThinkingEnabled'], booleanValues, true, 'interactive thinking controls and provider adapter'),
+    setting('recap', 'Session recap', 'settings', ['awaySummaryEnabled'], booleanValues, true, 'interactive session resume recap'),
+    setting('checkpoints', 'Rewind code (checkpoints)', 'settings', ['fileCheckpointingEnabled'], booleanValues, true, 'file-history snapshot and rewind runtime'),
+    setting('workflows', 'Dynamic workflows', 'settings', ['enableWorkflows'], booleanValues, true, 'workflow tool exposure and SessionService'),
+    setting('workflowKeywordTriggerEnabled', 'Ultracode keyword trigger', 'settings', ['workflowKeywordTriggerEnabled'], booleanValues, true, 'workflow keyword dispatcher'),
+    setting('workflowSizeGuideline', 'Dynamic workflow size', 'state', ['workflowSizeGuideline'], ['unrestricted', 'small', 'medium', 'large'], 'unrestricted', 'workflow planner sizing guidance'),
+    setting('verbose', 'Verbose output', 'settings', ['verbose'], booleanValues, false, 'interactive transcript detail and protocol diagnostics'),
+    setting('progressBar', 'Terminal progress bar', 'settings', ['terminalProgressBarEnabled'], booleanValues, true, 'terminal progress renderer'),
+    setting('turnDuration', 'Show turn duration', 'settings', ['showTurnDuration'], booleanValues, true, 'interactive turn footer'),
+    setting('permissionMode', 'Default permission mode', 'settings', ['permissions', 'defaultMode'], ['default', 'plan', 'acceptEdits', 'auto', 'dontAsk'], 'default', 'startup permission mode selection'),
+    setting('worktreeBaseRef', 'Worktree base ref', 'settings', ['worktree', 'baseRef'], ['fresh', 'head'], 'fresh', 'worktree creation runtime'),
+    setting('useAutoModeDuringPlan', 'Use auto mode during plan', 'settings', ['useAutoModeDuringPlan'], booleanValues, true, 'plan approval permission transition'),
+    setting('gitignore', 'Respect .gitignore in file picker', 'state', ['respectGitignore'], booleanValues, true, 'interactive file picker'),
+    setting('copyFullResponse', 'Skip the /copy picker', 'state', ['copyFullResponse'], booleanValues, false, '/copy local command'),
+    setting('defaultToAgentsView', 'Open agents view by default', 'state', ['defaultToAgentsView'], booleanValues, false, 'interactive agents dashboard'),
+    setting('leftArrowOpensAgents', '← opens agents', 'state', ['leftArrowOpensAgents'], booleanValues, true, 'global interactive key dispatcher'),
+    setting('autoUpdatesChannel', 'Auto-update channel', 'settings', ['autoUpdatesChannel'], ['latest', 'stable'], 'latest', 'self-update policy'),
+    setting('theme', 'Theme', 'settings', ['theme'], [
+        'auto',
+        'dark',
+        'light',
+        'light-daltonized',
+        'dark-daltonized',
+        'light-ansi',
+        'dark-ansi',
+    ], 'auto', 'Stage 109 theme runtime'),
+    setting('notifChannel', 'Local notifications', 'settings', ['preferredNotifChannel'], [
+        'auto',
+        'iterm2',
+        'terminal_bell',
+        'iterm2_with_bell',
+        'kitty',
+        'ghostty',
+        'notifications_disabled',
+    ], 'auto', 'task and permission notification dispatcher'),
+    setting('outputStyle', 'Output style', 'settings', ['outputStyle'], ['default', 'Proactive', 'Explanatory', 'Learning'], 'default', 'system-prompt output-style projection'),
+    setting('language', 'Language', 'settings', ['language'], 'language', 'default', 'system-prompt language projection'),
+    setting('editor', 'Editor mode', 'settings', ['editorMode'], ['normal', 'vim'], 'normal', 'interactive composer editor mode'),
+    setting('askUserQuestionTimeout', 'Question auto-continue timeout', 'settings', ['askUserQuestionTimeout'], ['never', '60s', '5m', '10m'], 'never', 'AskUserQuestion decision timer'),
+    setting('externalEditorContext', 'Show last response in external editor', 'state', ['externalEditorContext'], booleanValues, false, 'external editor prompt projection'),
+    setting('prStatus', 'Show PR status footer', 'state', ['prStatusFooterEnabled'], booleanValues, true, 'interactive repository footer'),
+    setting('model', 'Model', 'settings', ['model'], [
+        'default',
+        'sonnet',
+        'opus',
+        'haiku',
+        'best',
+        'sonnet[1m]',
+        'opus[1m]',
+        'opusplan',
+    ], 'default', 'startup provider model selection'),
+    setting('tui', 'TUI renderer', 'settings', ['tui'], ['default', 'fullscreen'], 'default', 'interactive renderer mode'),
+];
+function setting(nativeKey, label, scope, path, values, defaultValue, runtimeConsumer) {
+    const integrated = new Set([
+        'autoCompact',
+        'thinking',
+        'checkpoints',
+        'workflows',
+        'permissionMode',
+        'worktreeBaseRef',
+        'gitignore',
+        'theme',
+        'outputStyle',
+        'language',
+        'model',
+    ]).has(nativeKey);
+    const notApplicable = nativeKey === 'switchModelsOnFlag';
+    return {
+        id: nativeKey,
+        nativeKey,
+        label,
+        scope,
+        path,
+        values,
+        defaultValue,
+        runtimeStatus: integrated
+            ? 'integrated'
+            : notApplicable
+                ? 'not-applicable'
+                : 'interactive-integration',
+        runtimeConsumer,
+        ...(notApplicable
+            ? {
+                applicabilityReason: 'Claude subscription flag fallback is outside the API-provider, subscription-auth-free Praxis boundary',
+            }
+            : {}),
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function resolveConfigSettingsLocation(target) {
+    if (typeof target === 'object')
+        return target;
+    if (typeof target === 'string')
+        return { configRoot: target, statePath: join(target, '.claude.json') };
+    const configuredRoot = process.env.CLAUDE_CONFIG_DIR;
+    return configuredRoot
+        ? {
+            configRoot: configuredRoot,
+            statePath: join(configuredRoot, '.claude.json'),
+        }
+        : {
+            configRoot: join(homedir(), '.claude'),
+            statePath: join(homedir(), '.claude.json'),
+        };
+}
+function configPath(location, scope) {
+    return scope === 'settings'
+        ? join(location.configRoot, 'settings.json')
+        : location.statePath;
+}
+async function readObject(path) {
+    try {
+        const source = await readRegularSource(path);
+        if (source === undefined)
+            return { value: {}, fingerprint: sourceFingerprint() };
+        const value = JSON.parse(source);
+        if (!isRecord(value))
+            throw new Error(`JSON root must be an object: ${path}`);
+        return { value, fingerprint: sourceFingerprint(source) };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON: ${path}`, { cause: error });
+        throw error;
+    }
+}
+async function readRegularSource(path) {
+    let handle;
+    try {
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT')
+            return undefined;
+        if (code === 'ELOOP')
+            throw new Error(`Config path must be a regular file: ${path}`);
+        throw error;
+    }
+    try {
+        if (!(await handle.stat()).isFile())
+            throw new Error(`Config path must be a regular file: ${path}`);
+        return handle.readFile('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+function sourceFingerprint(source) {
+    return source === undefined
+        ? 'missing'
+        : createHash('sha256').update(source).digest('hex');
+}
+async function fingerprintUnchanged(path, expected) {
+    const source = await readRegularSource(path);
+    return sourceFingerprint(source) === expected;
+}
+function valueAtPath(source, path) {
+    let current = source;
+    for (const segment of path) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function withValueAtPath(source, path, value) {
+    const [head, ...tail] = path;
+    if (!head)
+        throw new Error('Config setting path cannot be empty');
+    if (tail.length === 0)
+        return { ...source, [head]: value };
+    const storedChild = source[head];
+    if (storedChild !== undefined && !isRecord(storedChild)) {
+        throw new Error(`Config setting path ${path.join('.')} crosses a non-object`);
+    }
+    const child = storedChild ?? {};
+    return { ...source, [head]: withValueAtPath(child, tail, value) };
+}
+function validValue(definition, value) {
+    if (definition.values === 'language')
+        return (typeof value === 'string' &&
+            value.trim().length > 0 &&
+            value.length <= 256);
+    return definition.values.includes(value);
+}
+export function configSettingDefinition(id) {
+    return CLAUDE_2_1_208_CONFIG_SETTINGS.find((definition) => definition.id === id || definition.nativeKey === id);
+}
+export function configSettingValue(snapshot, definition) {
+    const source = definition.scope === 'settings' ? snapshot.settings : snapshot.state;
+    const stored = valueAtPath(source, definition.path);
+    return validValue(definition, stored) ? stored : definition.defaultValue;
+}
+export async function loadConfigSettings(target) {
+    const location = resolveConfigSettingsLocation(target);
+    const [settings, state] = await Promise.all([
+        readObject(configPath(location, 'settings')),
+        readObject(configPath(location, 'state')),
+    ]);
+    return { settings: settings.value, state: state.value };
+}
+async function acquireLease(location, scope) {
+    const path = configPath(location, scope);
+    const lockParent = await realpath(dirname(path)).catch((error) => {
+        if (error.code === 'ENOENT')
+            return dirname(path);
+        throw error;
+    });
+    const lease = new ExclusiveFileLease(scope === 'settings'
+        ? join(lockParent, '.praxis-settings.lock')
+        : join(lockParent, '.praxis-claude-state.lock'));
+    for (let attempt = 0; attempt < 400; attempt += 1) {
+        const handle = await lease.tryAcquire();
+        if (handle)
+            return handle;
+        await setTimeout(5);
+    }
+    throw new Error(`Config write lock timed out: ${path}`);
+}
+export async function saveConfigSetting(id, value, target, hooks = {}) {
+    const definition = configSettingDefinition(id);
+    if (!definition)
+        throw new Error(`Unknown Claude config setting: ${id}`);
+    if (!validValue(definition, value))
+        throw new Error(`Invalid value for Claude config setting ${id}: ${String(value)}`);
+    const location = resolveConfigSettingsLocation(target);
+    await loadConfigSettings(location);
+    const path = configPath(location, definition.scope);
+    const handle = await acquireLease(location, definition.scope);
+    try {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const settingsPath = configPath(location, 'settings');
+            const statePath = configPath(location, 'state');
+            const [settings, state] = await Promise.all([
+                readObject(settingsPath),
+                readObject(statePath),
+            ]);
+            const current = definition.scope === 'settings' ? settings : state;
+            const next = withValueAtPath(current.value, definition.path, value);
+            const committed = await writeFileAtomically(path, `${JSON.stringify(next, null, 2)}\n`, {
+                beforeCommit: async () => {
+                    const unchanged = (await fingerprintUnchanged(settingsPath, settings.fingerprint)) && (await fingerprintUnchanged(statePath, state.fingerprint));
+                    if (!unchanged)
+                        return false;
+                    await hooks.afterValidation?.();
+                    return ((await fingerprintUnchanged(settingsPath, settings.fingerprint)) && (await fingerprintUnchanged(statePath, state.fingerprint)));
+                },
+            });
+            if (committed)
+                return loadConfigSettings(location);
+        }
+        throw new Error(`Config changed concurrently: ${path}`);
+    }
+    finally {
+        await handle.release();
+    }
+}
+//# sourceMappingURL=config-settings.js.map

package/dist/cli/tui/custom-themes.d.ts

@@ -0,0 +1,21 @@
+import { type TuiTheme } from './theme.js';
+export declare const CUSTOM_THEME_TOKENS: readonly ["autoAccept", "autoAcceptShimmer", "background", "bashBorder", "bashMessageBackgroundColor", "blue_FOR_SUBAGENTS_ONLY", "briefLabelClaude", "briefLabelYou", "chromeYellow", "claude", "claudeBlueShimmer_FOR_SYSTEM_SPINNER", "claudeBlue_FOR_SYSTEM_SPINNER", "claudeShimmer", "clawd_background", "clawd_body", "cyan_FOR_SUBAGENTS_ONLY", "diffAdded", "diffAddedDimmed", "diffAddedWord", "diffRemoved", "diffRemovedDimmed", "diffRemovedWord", "error", "fastMode", "fastModeShimmer", "green_FOR_SUBAGENTS_ONLY", "ide", "inactive", "inactiveShimmer", "inverseText", "memoryBackgroundColor", "merged", "messageActionsBackground", "orange_FOR_SUBAGENTS_ONLY", "pink_FOR_SUBAGENTS_ONLY", "planMode", "professionalBlue", "promptBorder", "promptBorderShimmer", "purple_FOR_SUBAGENTS_ONLY", "rainbow_blue", "rainbow_blue_shimmer", "rainbow_green", "rainbow_green_shimmer", "rainbow_indigo", "rainbow_indigo_shimmer", "rainbow_orange", "rainbow_orange_shimmer", "rainbow_red", "rainbow_red_shimmer", "rainbow_violet", "rainbow_violet_shimmer", "rainbow_yellow", "rainbow_yellow_shimmer", "rate_limit_empty", "rate_limit_fill", "red_FOR_SUBAGENTS_ONLY", "remember", "selectionBg", "success", "subtle", "suggestion", "text", "userMessageBackground", "userMessageBackgroundHover", "warning", "warningShimmer", "yellow_FOR_SUBAGENTS_ONLY"];
+export type CustomThemeToken = (typeof CUSTOM_THEME_TOKENS)[number];
+export type CustomThemeBase = Exclude<TuiTheme, 'auto'>;
+export interface TuiCustomTheme {
+    name: string;
+    slug: string;
+    base: CustomThemeBase;
+    overrides: Readonly<Partial<Record<CustomThemeToken, string>>>;
+}
+export declare function customThemeDirectory(configRoot?: string): string;
+export declare function validateCustomThemeName(name: string): string;
+export declare function loadTuiCustomThemes(configRoot?: string): Promise<readonly TuiCustomTheme[]>;
+export declare function createTuiCustomTheme({ name, base, configRoot, }: {
+    name: string;
+    base: CustomThemeBase;
+    configRoot?: string;
+}): Promise<TuiCustomTheme>;
+export declare function updateTuiCustomTheme(theme: TuiCustomTheme, token: CustomThemeToken, value: string | undefined, configRoot?: string): Promise<TuiCustomTheme>;
+export declare function deleteTuiCustomTheme(theme: TuiCustomTheme, configRoot?: string): Promise<void>;
+//# sourceMappingURL=custom-themes.d.ts.map