praxis-agent 0.7.0 → 0.8.0

package/dist/cli/tui/custom-themes.js

@@ -0,0 +1,284 @@
+import { constants } from 'node:fs';
+import { mkdir, open, readdir, readFile, rm } 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 { TUI_THEMES } from './theme.js';
+export const CUSTOM_THEME_TOKENS = [
+    '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',
+];
+const MAX_THEME_FILE_BYTES = 256 * 1024;
+const CUSTOM_NAME = /^[A-Za-z][A-Za-z0-9 _-]{0,63}$/u;
+const CUSTOM_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const HEX = /^#[0-9a-f]{6}$/iu;
+const RGB = /^rgb\(\s*(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\s*,\s*(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\s*,\s*(?:\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\s*\)$/iu;
+const ANSI256 = /^ansi256\((?:[0-9]|[1-9]\d|1\d\d|2[0-4]\d)\)$/u;
+const ANSI = /^ansi:[A-Za-z][A-Za-z0-9]*$/u;
+function configRootPath() {
+    return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
+}
+export function customThemeDirectory(configRoot = configRootPath()) {
+    return join(configRoot, 'themes');
+}
+function slugify(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, '-')
+        .replace(/^-+|-+$/gu, '');
+}
+export function validateCustomThemeName(name) {
+    const normalized = name.trim();
+    if (!CUSTOM_NAME.test(normalized)) {
+        throw new Error('Theme name must start with a letter and contain only letters, numbers, spaces, hyphens, or underscores (1–64 characters).');
+    }
+    const slug = slugify(normalized);
+    if (!CUSTOM_SLUG.test(slug))
+        throw new Error('Theme name must contain at least one ASCII letter or number.');
+    return slug;
+}
+function validateColor(value) {
+    const normalized = value.trim();
+    if (!HEX.test(normalized) &&
+        !RGB.test(normalized) &&
+        !ANSI256.test(normalized) &&
+        !ANSI.test(normalized)) {
+        throw new Error(`Invalid theme color ${JSON.stringify(value)}. Use rgb(r,g,b), #rrggbb, ansi256(n), or ansi:name.`);
+    }
+    return normalized;
+}
+function parseTheme(value, slug) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error(`Invalid custom theme file: ${slug}.json`);
+    const record = value;
+    if (typeof record.name !== 'string' || !CUSTOM_NAME.test(record.name))
+        throw new Error(`Invalid custom theme name: ${slug}.json`);
+    if (!TUI_THEMES.includes(record.base) ||
+        record.base === 'auto')
+        throw new Error(`Invalid custom theme base: ${slug}.json`);
+    if (typeof record.overrides !== 'object' ||
+        record.overrides === null ||
+        Array.isArray(record.overrides))
+        throw new Error(`Invalid custom theme overrides: ${slug}.json`);
+    const overrides = {};
+    for (const [token, color] of Object.entries(record.overrides)) {
+        if (!CUSTOM_THEME_TOKENS.includes(token))
+            throw new Error(`Unknown custom theme token ${JSON.stringify(token)}.`);
+        if (typeof color !== 'string')
+            throw new Error(`Theme token ${token} must be a color string.`);
+        overrides[token] = validateColor(color);
+    }
+    const expectedSlug = slugify(record.name);
+    if (expectedSlug !== slug)
+        throw new Error(`Custom theme filename must match its name: ${slug}.json`);
+    return {
+        name: record.name,
+        slug,
+        base: record.base,
+        overrides,
+    };
+}
+async function readThemeFile(path, slug) {
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const info = await handle.stat();
+        if (info.size > MAX_THEME_FILE_BYTES)
+            throw new Error(`Custom theme exceeds ${MAX_THEME_FILE_BYTES} bytes: ${path}`);
+        return parseTheme(JSON.parse(await handle.readFile('utf8')), slug);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON: ${path}`, { cause: error });
+        throw error;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function acquireThemeLease(directory) {
+    const lease = new ExclusiveFileLease(join(directory, '.praxis-themes.lock'));
+    for (let attempt = 0; attempt < 400; attempt += 1) {
+        const handle = await lease.tryAcquire();
+        if (handle)
+            return handle;
+        await setTimeout(5);
+    }
+    throw new Error(`Custom theme write lock timed out: ${directory}`);
+}
+export async function loadTuiCustomThemes(configRoot = configRootPath()) {
+    const directory = customThemeDirectory(configRoot);
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const themes = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.json'))
+            continue;
+        const slug = entry.name.slice(0, -'.json'.length);
+        if (!CUSTOM_SLUG.test(slug))
+            throw new Error(`Invalid custom theme filename: ${entry.name}`);
+        themes.push(await readThemeFile(join(directory, entry.name), slug));
+    }
+    return themes.sort((left, right) => left.name.localeCompare(right.name));
+}
+function serializedTheme(theme) {
+    return `${JSON.stringify({ name: theme.name, base: theme.base, overrides: theme.overrides }, null, 2)}\n`;
+}
+export async function createTuiCustomTheme({ name, base, configRoot = configRootPath(), }) {
+    const slug = validateCustomThemeName(name);
+    if (!TUI_THEMES.includes(base) ||
+        base === 'auto')
+        throw new Error(`Invalid custom theme base: ${base}`);
+    const directory = customThemeDirectory(configRoot);
+    await mkdir(directory, { recursive: true });
+    const handle = await acquireThemeLease(directory);
+    try {
+        const path = join(directory, `${slug}.json`);
+        try {
+            await readFile(path, 'utf8');
+            throw new Error(`A custom theme named ${JSON.stringify(name.trim())} already exists.`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const theme = {
+            name: name.trim(),
+            slug,
+            base,
+            overrides: {},
+        };
+        const committed = await writeFileAtomically(path, serializedTheme(theme), {
+            mode: 0o600,
+            beforeCommit: async () => {
+                try {
+                    await readFile(path, 'utf8');
+                    return false;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return true;
+                    throw error;
+                }
+            },
+        });
+        if (!committed)
+            throw new Error(`A custom theme named ${JSON.stringify(name.trim())} already exists.`);
+        return theme;
+    }
+    finally {
+        await handle.release();
+    }
+}
+export async function updateTuiCustomTheme(theme, token, value, configRoot = configRootPath()) {
+    const color = value === undefined ? undefined : validateColor(value);
+    const directory = customThemeDirectory(configRoot);
+    await mkdir(directory, { recursive: true });
+    const handle = await acquireThemeLease(directory);
+    try {
+        const path = join(directory, `${theme.slug}.json`);
+        const current = await readThemeFile(path, theme.slug);
+        const overrides = { ...current.overrides };
+        if (color === undefined)
+            delete overrides[token];
+        else
+            overrides[token] = color;
+        const next = { ...current, overrides };
+        if (!(await writeFileAtomically(path, serializedTheme(next))))
+            throw new Error(`Unable to update custom theme: ${path}`);
+        return next;
+    }
+    finally {
+        await handle.release();
+    }
+}
+export async function deleteTuiCustomTheme(theme, configRoot = configRootPath()) {
+    const directory = customThemeDirectory(configRoot);
+    const handle = await acquireThemeLease(directory);
+    try {
+        await rm(join(directory, `${theme.slug}.json`), { force: false });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    finally {
+        await handle.release();
+    }
+}
+//# sourceMappingURL=custom-themes.js.map

package/dist/cli/tui/file-picker.d.ts

@@ -11,7 +11,9 @@ export type TuiMentionEntry = ({
 } & TuiFileEntry) | ({
     kind: 'agent';
 } & TuiAgentEntry);
-export declare function loadTuiFileEntries(cwd: string): Promise<readonly TuiFileEntry[]>;
+export declare function loadTuiFileEntries(cwd: string, options?: {
+    respectGitignore?: boolean;
+}): Promise<readonly TuiFileEntry[]>;
 export declare function filterTuiFileEntries(entries: readonly TuiFileEntry[], query: string): readonly TuiFileEntry[];
 export declare function filterTuiMentionEntries(files: readonly TuiFileEntry[], agents: readonly TuiAgentEntry[], query: string): readonly TuiMentionEntry[];
 export declare function fileReferenceAtCursor(input: string, cursor: number): {

package/dist/cli/tui/file-picker.js

@@ -1,10 +1,16 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
-export async function loadTuiFileEntries(cwd) {
+export async function loadTuiFileEntries(cwd, options = {}) {
     let stdout;
     try {
-        const result = await execFileAsync('rg', ['--files', '--hidden', '--glob', '!.git/**'], {
+        const result = await execFileAsync('rg', [
+            '--files',
+            '--hidden',
+            ...(options.respectGitignore === false ? ['--no-ignore'] : []),
+            '--glob',
+            '!.git/**',
+        ], {
             cwd,
             encoding: 'utf8',
             maxBuffer: 4 * 1024 * 1024,

package/dist/cli/tui/keybindings.js

@@ -143,7 +143,6 @@ const CLAUDE_2_1_208_KEYBINDINGS = {
             context: 'ThemePicker',
             bindings: {
                 'ctrl+t': 'theme:toggleSyntaxHighlighting',
-                'ctrl+e': 'theme:editCustom',
             },
         },
         {

package/dist/cli/tui/mcp-panel-controller.d.ts

@@ -0,0 +1,32 @@
+import type { ClaudeMcpManagement } from '../../mcp/claude-mcp-management.js';
+import type { ClaudeMcpRuntime } from '../../mcp/claude-mcp-tools.js';
+import { type TuiMcpPanelInput, type TuiMcpPanelCommand, type TuiMcpPanelModel, type TuiMcpPanelState } from './mcp-panel-projector.js';
+export type TuiMcpRuntimeController = ClaudeMcpRuntime;
+export interface TuiMcpSessionCommands {
+    mcpInspect(): ReturnType<ClaudeMcpRuntime['inspect']>;
+    mcpReconnect(name: string): ReturnType<ClaudeMcpRuntime['reconnect']>;
+    mcpAuthenticate(name: string): ReturnType<ClaudeMcpRuntime['authenticate']>;
+    mcpReload(): ReturnType<ClaudeMcpRuntime['reload']>;
+    mcpTools(name: string): ReturnType<ClaudeMcpRuntime['tools']>;
+}
+export declare function mcpRuntimeFromSession(commands: TuiMcpSessionCommands): TuiMcpRuntimeController;
+export interface TuiMcpPanelDispatchResult {
+    model: TuiMcpPanelModel;
+    state: TuiMcpPanelState;
+    closed: boolean;
+    error?: string;
+}
+export declare class McpPanelController {
+    private readonly cwd;
+    private readonly management;
+    private readonly runtime;
+    constructor(options: {
+        cwd: string;
+        management: Pick<ClaudeMcpManagement, 'list' | 'disabled' | 'setEnabled'>;
+        runtime: ClaudeMcpRuntime;
+    });
+    open(): Promise<TuiMcpPanelModel>;
+    execute(command: TuiMcpPanelCommand): Promise<TuiMcpPanelModel | null>;
+    dispatch(model: TuiMcpPanelModel, state: TuiMcpPanelState, input: TuiMcpPanelInput, onOperation?: (command: TuiMcpPanelCommand) => void): Promise<TuiMcpPanelDispatchResult>;
+}
+//# sourceMappingURL=mcp-panel-controller.d.ts.map

package/dist/cli/tui/mcp-panel-controller.js

@@ -0,0 +1,80 @@
+import { projectTuiMcpPanel, reduceTuiMcpPanelState, } from './mcp-panel-projector.js';
+export function mcpRuntimeFromSession(commands) {
+    return {
+        inspect: () => commands.mcpInspect(),
+        reconnect: (name) => commands.mcpReconnect(name),
+        authenticate: (name) => commands.mcpAuthenticate(name),
+        reload: () => commands.mcpReload(),
+        tools: (name) => commands.mcpTools(name),
+    };
+}
+export class McpPanelController {
+    cwd;
+    management;
+    runtime;
+    constructor(options) {
+        this.cwd = options.cwd;
+        this.management = options.management;
+        this.runtime = options.runtime;
+    }
+    async open() {
+        const [records, disabledNames, runtime] = await Promise.all([
+            this.management.list(),
+            this.management.disabled(),
+            this.runtime.inspect(),
+        ]);
+        return projectTuiMcpPanel({
+            cwd: this.cwd,
+            records,
+            disabledNames,
+            runtime,
+        });
+    }
+    async execute(command) {
+        if (command.type === 'close')
+            return null;
+        if (command.type === 'reconnect') {
+            await this.runtime.reconnect(command.name);
+            return this.open();
+        }
+        if (command.type === 'authenticate') {
+            await this.runtime.authenticate(command.name);
+            return this.open();
+        }
+        if (command.type === 'set-enabled') {
+            await this.management.setEnabled(command.name, command.scope, command.enabled);
+            await this.runtime.reload();
+            return this.open();
+        }
+        const tools = await this.runtime.tools(command.name);
+        const model = await this.open();
+        return {
+            ...model,
+            servers: model.servers.map((server) => server.name === command.name ? { ...server, tools } : server),
+        };
+    }
+    async dispatch(model, state, input, onOperation) {
+        const transition = reduceTuiMcpPanelState(model, state, input);
+        if (!transition.command) {
+            return { model, state: transition.state, closed: false };
+        }
+        onOperation?.(transition.command);
+        try {
+            const next = await this.execute(transition.command);
+            return {
+                model: next ?? model,
+                state: transition.state,
+                closed: next === null,
+            };
+        }
+        catch (error) {
+            return {
+                model,
+                state,
+                closed: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+//# sourceMappingURL=mcp-panel-controller.js.map

package/dist/cli/tui/mcp-panel-projector.d.ts

@@ -0,0 +1,79 @@
+import type { McpScope, McpServerRecord } from '../../mcp/claude-mcp-management.js';
+export type TuiMcpCapability = 'tools' | 'resources' | 'prompts';
+export type TuiMcpServerStatus = 'connected' | 'failed' | 'disabled' | 'needs-authentication';
+export interface TuiMcpTool {
+    name: string;
+    fullName: string;
+    description?: string;
+}
+export interface TuiMcpRuntimeServer {
+    name: string;
+    status: Exclude<TuiMcpServerStatus, 'disabled'>;
+    statusDetail?: string;
+    authDetail?: string;
+    capabilities?: readonly TuiMcpCapability[];
+    toolCount?: number;
+}
+export interface TuiMcpServer {
+    name: string;
+    scope: McpScope;
+    path: string;
+    location: string;
+    status: TuiMcpServerStatus;
+    statusDetail: string;
+    authDetail?: string;
+    transport: 'stdio' | 'http' | 'sse';
+    command?: string;
+    args: readonly string[];
+    url?: string;
+    capabilities: readonly TuiMcpCapability[];
+    toolCount: number;
+    tools?: readonly TuiMcpTool[];
+}
+export interface TuiMcpPanelModel {
+    cwd: string;
+    servers: readonly TuiMcpServer[];
+}
+export type TuiMcpPanelDepth = 'list' | 'detail' | 'tools' | 'tool';
+export interface TuiMcpPanelState {
+    depth: TuiMcpPanelDepth;
+    serverIndex: number;
+    selectedIndex: number;
+}
+export type TuiMcpPanelInput = {
+    type: 'up' | 'down' | 'confirm' | 'back';
+} | {
+    type: 'select';
+    index: number;
+};
+export type TuiMcpPanelCommand = {
+    type: 'close';
+} | {
+    type: 'view-tools';
+    name: string;
+} | {
+    type: 'reconnect';
+    name: string;
+} | {
+    type: 'authenticate';
+    name: string;
+} | {
+    type: 'set-enabled';
+    name: string;
+    scope: McpScope;
+    enabled: boolean;
+};
+export interface TuiMcpPanelTransition {
+    state: TuiMcpPanelState;
+    command?: TuiMcpPanelCommand;
+}
+export declare function projectTuiMcpPanel({ cwd, records, disabledNames, runtime, }: {
+    cwd: string;
+    records: readonly McpServerRecord[];
+    disabledNames: readonly string[];
+    runtime: readonly TuiMcpRuntimeServer[];
+}): TuiMcpPanelModel;
+export declare function initialTuiMcpPanelState(model: TuiMcpPanelModel): TuiMcpPanelState;
+export declare function tuiMcpServerActions(server: TuiMcpServer): readonly TuiMcpPanelCommand[];
+export declare function reduceTuiMcpPanelState(model: TuiMcpPanelModel, state: TuiMcpPanelState, input: TuiMcpPanelInput): TuiMcpPanelTransition;
+//# sourceMappingURL=mcp-panel-projector.d.ts.map