praxis-agent 0.7.0 → 0.8.0

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

@@ -0,0 +1,132 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { 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';
+import { DEFAULT_TUI_THEME_SETTINGS, TUI_THEMES, } from './theme.js';
+import { loadTuiCustomThemes } from './custom-themes.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function configRootPath() {
+    return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
+}
+async function readSettings(path) {
+    try {
+        const source = await readFile(path, 'utf8');
+        const value = JSON.parse(source);
+        if (!isRecord(value))
+            throw new Error(`JSON root must be an object: ${path}`);
+        return { value, fingerprint: fingerprint(source) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { value: {}, fingerprint: fingerprint() };
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON: ${path}`, { cause: error });
+        throw error;
+    }
+}
+function fingerprint(source) {
+    return source === undefined
+        ? 'missing'
+        : createHash('sha256').update(source).digest('hex');
+}
+async function fingerprintUnchanged(path, expected) {
+    try {
+        return fingerprint(await readFile(path, 'utf8')) === expected;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return expected === fingerprint();
+        throw error;
+    }
+}
+function settingsFromRecord(value, customTheme) {
+    const configuredTheme = value.theme;
+    const theme = TUI_THEMES.includes(configuredTheme)
+        ? configuredTheme
+        : typeof configuredTheme === 'string' &&
+            /^custom:[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(configuredTheme) &&
+            customTheme?.slug === configuredTheme.slice('custom:'.length)
+            ? configuredTheme
+            : DEFAULT_TUI_THEME_SETTINGS.theme;
+    return {
+        theme,
+        syntaxHighlightingDisabled: typeof value.syntaxHighlightingDisabled === 'boolean'
+            ? value.syntaxHighlightingDisabled
+            : DEFAULT_TUI_THEME_SETTINGS.syntaxHighlightingDisabled,
+        ...(customTheme === undefined ? {} : { customTheme }),
+    };
+}
+export function themeSettingsWithCustomTheme(settings, customThemes) {
+    if (!settings.theme.startsWith('custom:'))
+        return settings;
+    const customTheme = customThemes.find((theme) => `custom:${theme.slug}` === settings.theme);
+    return customTheme === undefined ? settings : { ...settings, customTheme };
+}
+export async function loadTuiThemeSettings(configRoot = configRootPath()) {
+    const { value } = await readSettings(join(configRoot, 'settings.json'));
+    const configured = value.theme;
+    const customSlug = typeof configured === 'string' && configured.startsWith('custom:')
+        ? configured.slice('custom:'.length)
+        : undefined;
+    const customTheme = customSlug
+        ? (await loadTuiCustomThemes(configRoot)).find((theme) => theme.slug === customSlug)
+        : undefined;
+    return settingsFromRecord(value, customTheme);
+}
+export async function saveTuiThemeSettings(update, configRoot = configRootPath(), hooks = {}) {
+    const path = join(configRoot, 'settings.json');
+    const lease = new ExclusiveFileLease(join(configRoot, '.praxis-settings.lock'));
+    let handle = null;
+    for (let attempt = 0; attempt < 400; attempt += 1) {
+        handle = await lease.tryAcquire();
+        if (handle)
+            break;
+        await setTimeout(5);
+    }
+    if (!handle)
+        throw new Error(`Settings write lock timed out: ${path}`);
+    try {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const { value, fingerprint: expectedFingerprint } = await readSettings(path);
+            const selectedTheme = update.theme ?? value.theme;
+            const customTheme = typeof selectedTheme === 'string' && selectedTheme.startsWith('custom:')
+                ? (await loadTuiCustomThemes(configRoot)).find((theme) => theme.slug === selectedTheme.slice('custom:'.length))
+                : undefined;
+            if (typeof selectedTheme === 'string' &&
+                selectedTheme.startsWith('custom:') &&
+                customTheme === undefined) {
+                throw new Error(`Custom theme is not available: ${selectedTheme}`);
+            }
+            const next = {
+                ...settingsFromRecord(value, customTheme),
+                ...update,
+                ...(customTheme === undefined ? {} : { customTheme }),
+            };
+            const persisted = { ...value };
+            if (update.theme !== undefined)
+                persisted.theme = update.theme;
+            if (update.syntaxHighlightingDisabled !== undefined)
+                persisted.syntaxHighlightingDisabled = update.syntaxHighlightingDisabled;
+            const committed = await writeFileAtomically(path, `${JSON.stringify(persisted, null, 2)}\n`, {
+                beforeCommit: async () => {
+                    if (!(await fingerprintUnchanged(path, expectedFingerprint)))
+                        return false;
+                    await hooks.afterValidation?.();
+                    return fingerprintUnchanged(path, expectedFingerprint);
+                },
+            });
+            if (committed)
+                return next;
+        }
+        throw new Error(`Settings changed concurrently: ${path}`);
+    }
+    finally {
+        await handle.release();
+    }
+}
+//# sourceMappingURL=theme-settings.js.map

package/dist/cli/tui/theme.d.ts

@@ -0,0 +1,53 @@
+import { type ReactNode } from 'react';
+import type { TuiCustomTheme } from './custom-themes.js';
+export declare const TUI_THEMES: readonly ["auto", "dark", "light", "dark-daltonized", "light-daltonized", "dark-ansi", "light-ansi"];
+export type TuiTheme = (typeof TUI_THEMES)[number];
+export type TuiThemeSetting = TuiTheme | `custom:${string}`;
+export interface TuiThemeSettings {
+    theme: TuiThemeSetting;
+    syntaxHighlightingDisabled: boolean;
+    customTheme?: TuiCustomTheme;
+}
+export interface TuiSyntaxPalette {
+    text: string;
+    keyword: string;
+    identifier: string;
+    string: string;
+    removedBackground?: string;
+    addedBackground?: string;
+    addedHighlight?: string;
+}
+export interface TuiPalette {
+    profile: TuiTheme;
+    dark: boolean;
+    ansiOnly: boolean;
+    syntaxHighlightingDisabled: boolean;
+    brand: string;
+    accent: string;
+    info: string;
+    link: string;
+    error: string;
+    success: string;
+    warning: string;
+    muted: string;
+    selectionText: string;
+    syntaxTheme: 'Monokai Extended' | 'GitHub' | 'ansi';
+    syntax: TuiSyntaxPalette;
+}
+export type TuiSyntaxToken = 'text' | 'keyword' | 'identifier' | 'string';
+export type TerminalColorCapability = 'ansi16' | 'ansi256' | 'truecolor';
+type TerminalEnvironment = Readonly<Record<string, string | undefined>>;
+export declare function tuiSyntaxStyle(palette: TuiPalette, token: TuiSyntaxToken, change?: 'added' | 'removed'): {
+    color?: string;
+    backgroundColor?: string;
+};
+export declare const DEFAULT_TUI_THEME_SETTINGS: TuiThemeSettings;
+export declare function terminalColorCapability(environment?: TerminalEnvironment): TerminalColorCapability;
+export declare function tuiPalette(profile: TuiTheme, syntaxHighlightingDisabled?: boolean, environment?: TerminalEnvironment, customTheme?: TuiCustomTheme): TuiPalette;
+export declare function TuiThemeProvider({ settings, children, }: {
+    settings: TuiThemeSettings;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useTuiPalette(): TuiPalette;
+export {};
+//# sourceMappingURL=theme.d.ts.map

package/dist/cli/tui/theme.js

@@ -0,0 +1,265 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+export const TUI_THEMES = [
+    'auto',
+    'dark',
+    'light',
+    'dark-daltonized',
+    'light-daltonized',
+    'dark-ansi',
+    'light-ansi',
+];
+export function tuiSyntaxStyle(palette, token, change) {
+    if (palette.syntaxHighlightingDisabled)
+        return {};
+    const backgroundColor = change === 'added'
+        ? palette.syntax.addedBackground
+        : change === 'removed'
+            ? palette.syntax.removedBackground
+            : undefined;
+    return {
+        color: palette.syntax[token],
+        ...(backgroundColor === undefined ? {} : { backgroundColor }),
+    };
+}
+export const DEFAULT_TUI_THEME_SETTINGS = {
+    theme: 'auto',
+    syntaxHighlightingDisabled: false,
+};
+const DARK_SYNTAX = {
+    text: '#ffffff',
+    keyword: '#5fd7ff',
+    identifier: '#afd700',
+    string: '#d7d787',
+    removedBackground: '#5f0000',
+    addedBackground: '#005f00',
+    addedHighlight: '#008700',
+};
+const LIGHT_SYNTAX = {
+    text: '#303030',
+    keyword: '#af005f',
+    identifier: '#875faf',
+    string: '#005f87',
+    removedBackground: '#ffd7d7',
+    addedBackground: '#d7ffd7',
+    addedHighlight: '#afffaf',
+};
+function automaticDark(environment) {
+    const background = environment.COLORFGBG?.split(';').at(-1);
+    return background === undefined || Number(background) < 8;
+}
+export function terminalColorCapability(environment = process.env) {
+    if (environment.FORCE_COLOR === '3')
+        return 'truecolor';
+    if (environment.FORCE_COLOR === '2')
+        return 'ansi256';
+    if (environment.FORCE_COLOR === '1')
+        return 'ansi16';
+    if (/^(?:truecolor|24bit)$/iu.test(environment.COLORTERM ?? ''))
+        return 'truecolor';
+    if (/(?:direct|truecolor|24bit)/iu.test(environment.TERM ?? ''))
+        return 'truecolor';
+    if (/(?:iTerm\.app|WezTerm|ghostty|vscode|Hyper)/iu.test(environment.TERM_PROGRAM ?? ''))
+        return 'truecolor';
+    return /256color/iu.test(environment.TERM ?? '') ? 'ansi256' : 'ansi16';
+}
+const ANSI_256_LEVELS = [0, 95, 135, 175, 215, 255];
+const ansi256ColorCache = new Map();
+const ANSI_16_COLORS = {
+    '#ffffff': 'whiteBright',
+    '#5fd7ff': 'cyanBright',
+    '#afd700': 'yellowBright',
+    '#d7d787': 'whiteBright',
+    '#5f0000': 'black',
+    '#005f00': 'black',
+    '#008700': 'green',
+    '#d97757': 'redBright',
+    '#b8a1ff': 'whiteBright',
+    '#5fafff': 'cyanBright',
+    '#ff5f5f': 'redBright',
+    '#5fd75f': 'greenBright',
+    '#ffd75f': 'yellowBright',
+    '#a8a8a8': 'white',
+    '#303030': 'black',
+    '#af005f': 'red',
+    '#875faf': 'magenta',
+    '#005f87': 'blue',
+    '#ffd7d7': 'whiteBright',
+    '#d7ffd7': 'whiteBright',
+    '#afffaf': 'whiteBright',
+    '#005faf': 'blue',
+    '#af0000': 'red',
+    '#875f00': 'red',
+    '#585858': 'black',
+};
+function ansi16Color(hex) {
+    return ANSI_16_COLORS[hex.toLowerCase()] ?? hex;
+}
+function ansi256Color(hex) {
+    const cached = ansi256ColorCache.get(hex);
+    if (cached)
+        return cached;
+    const match = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/iu.exec(hex);
+    if (!match)
+        return hex;
+    const rgb = [
+        Number.parseInt(match[1] ?? '', 16),
+        Number.parseInt(match[2] ?? '', 16),
+        Number.parseInt(match[3] ?? '', 16),
+    ];
+    let bestIndex = 0;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const [red, redLevel] of ANSI_256_LEVELS.entries()) {
+        for (const [green, greenLevel] of ANSI_256_LEVELS.entries()) {
+            for (const [blue, blueLevel] of ANSI_256_LEVELS.entries()) {
+                const distance = (rgb[0] - redLevel) ** 2 +
+                    (rgb[1] - greenLevel) ** 2 +
+                    (rgb[2] - blueLevel) ** 2;
+                if (distance < bestDistance) {
+                    bestDistance = distance;
+                    bestIndex = 16 + red * 36 + green * 6 + blue;
+                }
+            }
+        }
+    }
+    for (let index = 232; index <= 255; index += 1) {
+        const level = 8 + (index - 232) * 10;
+        const distance = rgb.reduce((total, component) => total + (component - level) ** 2, 0);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            bestIndex = index;
+        }
+    }
+    const color = `ansi256(${bestIndex})`;
+    ansi256ColorCache.set(hex, color);
+    return color;
+}
+function adaptSyntaxColors(syntax, adapt) {
+    return {
+        text: adapt(syntax.text),
+        keyword: adapt(syntax.keyword),
+        identifier: adapt(syntax.identifier),
+        string: adapt(syntax.string),
+        ...(syntax.removedBackground === undefined
+            ? {}
+            : { removedBackground: adapt(syntax.removedBackground) }),
+        ...(syntax.addedBackground === undefined
+            ? {}
+            : { addedBackground: adapt(syntax.addedBackground) }),
+        ...(syntax.addedHighlight === undefined
+            ? {}
+            : { addedHighlight: adapt(syntax.addedHighlight) }),
+    };
+}
+export function tuiPalette(profile, syntaxHighlightingDisabled = false, environment = process.env, customTheme) {
+    const dark = profile === 'auto'
+        ? automaticDark(environment)
+        : profile === 'dark' ||
+            profile === 'dark-daltonized' ||
+            profile === 'dark-ansi';
+    const ansiOnly = profile.endsWith('-ansi');
+    const daltonized = profile.endsWith('-daltonized');
+    const syntaxBase = ansiOnly
+        ? {
+            text: dark ? 'white' : 'black',
+            keyword: 'cyanBright',
+            identifier: 'yellowBright',
+            string: 'greenBright',
+        }
+        : dark
+            ? {
+                ...DARK_SYNTAX,
+                ...(daltonized
+                    ? {
+                        addedBackground: '#00005f',
+                        addedHighlight: '#005f87',
+                    }
+                    : {}),
+            }
+            : {
+                ...LIGHT_SYNTAX,
+                ...(daltonized
+                    ? {
+                        addedBackground: '#d7ffff',
+                        addedHighlight: '#afd7ff',
+                    }
+                    : {}),
+            };
+    const terminalCapability = terminalColorCapability(environment);
+    const adaptAutoColor = terminalCapability === 'ansi16'
+        ? ansi16Color
+        : terminalCapability === 'ansi256'
+            ? ansi256Color
+            : (color) => color;
+    const syntax = profile === 'auto'
+        ? adaptSyntaxColors(syntaxBase, adaptAutoColor)
+        : syntaxBase;
+    const autoColor = (color) => profile === 'auto' ? adaptAutoColor(color) : color;
+    const palette = {
+        profile,
+        dark,
+        ansiOnly,
+        syntaxHighlightingDisabled,
+        brand: ansiOnly ? 'redBright' : autoColor('#D97757'),
+        accent: ansiOnly
+            ? 'magentaBright'
+            : daltonized
+                ? dark
+                    ? '#5fd7ff'
+                    : '#005f87'
+                : dark
+                    ? autoColor('#B8A1FF')
+                    : autoColor('#875faf'),
+        info: ansiOnly ? 'cyanBright' : autoColor(dark ? '#5fd7ff' : '#005f87'),
+        link: ansiOnly ? 'blueBright' : autoColor(dark ? '#5fafff' : '#005faf'),
+        error: ansiOnly ? 'redBright' : autoColor(dark ? '#ff5f5f' : '#af0000'),
+        success: ansiOnly ? 'greenBright' : autoColor(dark ? '#5fd75f' : '#008700'),
+        warning: ansiOnly
+            ? 'yellowBright'
+            : autoColor(dark ? '#ffd75f' : '#875f00'),
+        muted: ansiOnly
+            ? dark
+                ? 'white'
+                : 'black'
+            : autoColor(dark ? '#a8a8a8' : '#585858'),
+        selectionText: dark ? 'black' : 'white',
+        syntaxTheme: ansiOnly ? 'ansi' : dark ? 'Monokai Extended' : 'GitHub',
+        syntax,
+    };
+    if (customTheme) {
+        const overrides = customTheme.overrides;
+        const override = (token, fallback) => overrides[token] ?? fallback;
+        palette.brand = override('claude', palette.brand);
+        palette.accent = override('suggestion', palette.accent);
+        palette.info = override('professionalBlue', palette.info);
+        palette.link = override('ide', palette.link);
+        palette.error = override('error', palette.error);
+        palette.success = override('success', palette.success);
+        palette.warning = override('warning', palette.warning);
+        palette.muted = override('inactive', palette.muted);
+        palette.selectionText = override('inverseText', palette.selectionText);
+        palette.syntax = {
+            ...palette.syntax,
+            text: override('text', palette.syntax.text),
+            keyword: override('claudeBlue_FOR_SYSTEM_SPINNER', palette.syntax.keyword),
+            identifier: override('suggestion', palette.syntax.identifier),
+            string: override('success', palette.syntax.string),
+            removedBackground: override('diffRemoved', palette.syntax.removedBackground ?? ''),
+            addedBackground: override('diffAdded', palette.syntax.addedBackground ?? ''),
+            addedHighlight: override('diffAddedWord', palette.syntax.addedHighlight ?? ''),
+        };
+        palette.profile = customTheme.base;
+    }
+    return palette;
+}
+const TuiPaletteContext = createContext(tuiPalette('auto'));
+export function TuiThemeProvider({ settings, children, }) {
+    const baseTheme = TUI_THEMES.includes(settings.theme)
+        ? settings.theme
+        : 'dark';
+    return (_jsx(TuiPaletteContext.Provider, { value: tuiPalette(baseTheme, settings.syntaxHighlightingDisabled, process.env, settings.customTheme), children: children }));
+}
+export function useTuiPalette() {
+    return useContext(TuiPaletteContext);
+}
+//# sourceMappingURL=theme.js.map

package/dist/cli.d.ts

@@ -6,6 +6,7 @@ import type { InteractiveResumeOptions, InteractiveServiceFactory } from './cli/
 import type { TuiSlashCommand } from './cli/tui/slash-commands.js';
 import { type TuiHookConfiguration } from './cli/tui/hook-settings.js';
 import { type ClaudePermissionMode } from './permissions/claude-permission-resolver.js';
+import { type ClaudeMcpServerStatus, type ClaudeMcpToolInspection } from './mcp/claude-mcp-tools.js';
 import { authenticateMcpServer } from './mcp/claude-mcp-oauth.js';
 import { servePraxisMcpStdio } from './mcp/praxis-mcp-server.js';
 import { parseContextEnvironment, parseProviderEnvironment } from './providers/environment.js';
@@ -35,6 +36,8 @@ interface SessionCommands {
     rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
     changeCwd?(sessionId: string | undefined, cwd: string): Promise<string>;
     recordCdUsage?(sessionId: string): Promise<void>;
+    approveRecentlyDenied?(sessionId: string, display: string): Promise<void>;
+    retryRecentlyDenied?(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;
     answerSideQuestion?(sessionId: string | undefined, question: string, signal?: AbortSignal, onDelta?: (delta: string) => void, permissionMode?: ClaudePermissionMode): Promise<SideQuestionResult>;
     recordBtwUsage?(sessionId: string | undefined, permissionMode?: ClaudePermissionMode): Promise<string>;
     recordBackgroundUsage?(sessionId: string | undefined, permissionMode?: ClaudePermissionMode): Promise<string>;
@@ -57,6 +60,11 @@ interface SessionCommands {
     } | null>;
     slashCommands?(): readonly TuiSlashCommand[];
     hookConfiguration?(): Promise<TuiHookConfiguration>;
+    mcpInspect?(): Promise<readonly ClaudeMcpServerStatus[]>;
+    mcpReconnect?(name: string): Promise<void>;
+    mcpAuthenticate?(name: string): Promise<void>;
+    mcpReload?(): Promise<void>;
+    mcpTools?(name: string): Promise<readonly ClaudeMcpToolInspection[]>;
     close?(): Promise<void>;
     runtimeInfo?(): CliRuntimeInfo;
     agentDefinitions?(): readonly {
@@ -98,6 +106,7 @@ export interface CliDependencies extends InteractiveServiceFactory {
         model?: string;
         effort?: CliControls['effort'];
         permissionMode?: ClaudePermissionMode;
+        isSessionActionApproved?: (call: ModelToolCall) => boolean;
         controls?: CliControls;
         interactive?: boolean;
         sessionKind?: 'bg';