@booncli/booncli 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import Pastel from 'pastel';
+import { ensureConfigExists } from './config.js';
+await ensureConfigExists();
+const app = new Pastel({
+    importMeta: import.meta,
+});
+await app.run();

package/dist/command-actions.d.ts

@@ -0,0 +1,16 @@
+export declare const commandActions: readonly [{
+    readonly command: "/login";
+    readonly result: "Login";
+}, {
+    readonly command: "/loginout";
+    readonly result: "Loginout";
+}, {
+    readonly command: "/log";
+    readonly result: "Log";
+}, {
+    readonly command: "/clear";
+    readonly result: "Cleared";
+}];
+export type SlashCommand = (typeof commandActions)[number]['command'];
+export declare function isSlashCommand(value: string): value is SlashCommand;
+export declare function runCommand(value: string): string;

package/dist/command-actions.js

@@ -0,0 +1,15 @@
+export const commandActions = [
+    { command: '/login', result: 'Login' },
+    { command: '/loginout', result: 'Loginout' },
+    { command: '/log', result: 'Log' },
+    { command: '/clear', result: 'Cleared' },
+];
+const slashCommandSet = new Set(commandActions.map(({ command }) => command));
+export function isSlashCommand(value) {
+    return slashCommandSet.has(value);
+}
+export function runCommand(value) {
+    const command = value.trim().toLowerCase();
+    const action = commandActions.find(action => action.command === command);
+    return action?.result ?? value.trim();
+}

package/dist/commands/clear.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Clear(): React.JSX.Element;

package/dist/commands/clear.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Text } from 'ink';
+import { runCommand } from '../command-actions.js';
+export default function Clear() {
+    return React.createElement(Text, null, runCommand('/clear'));
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const slashCommands: readonly ["/login", "/loginout", "/log", "/clear"];
+export declare function getAvailableSlashCommands(isLoggedIn: boolean): ("/login" | "/loginout" | "/log" | "/clear")[];
+export declare function getCommandSuggestions(input: string, isLoggedIn?: boolean): ("/login" | "/loginout" | "/log" | "/clear")[];
+export declare function getDefaultSuggestionIndex(input: string, isLoggedIn?: boolean): number;
+export default function Index(): React.JSX.Element;

package/dist/commands/index.js

@@ -0,0 +1,251 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import BigText from 'ink-big-text';
+import { getProviderLoginUsername, isLoginMethod, isAccountPasswordLoginMethod, loginMethods, } from '../login-methods.js';
+import Radio from '../modules/radio.js';
+import { runCommand } from '../command-actions.js';
+export const slashCommands = ['/login', '/loginout', '/log', '/clear'];
+export function getAvailableSlashCommands(isLoggedIn) {
+    return slashCommands.filter(command => {
+        if (command === '/login') {
+            return !isLoggedIn;
+        }
+        if (command === '/loginout') {
+            return isLoggedIn;
+        }
+        return true;
+    });
+}
+export function getCommandSuggestions(input, isLoggedIn = false) {
+    const query = input.trim().toLowerCase();
+    if (!query.startsWith('/')) {
+        return [];
+    }
+    return getAvailableSlashCommands(isLoggedIn).filter(command => command.startsWith(query));
+}
+export function getDefaultSuggestionIndex(input, isLoggedIn = false) {
+    const query = input.trim().toLowerCase();
+    const suggestions = getCommandSuggestions(input, isLoggedIn);
+    const exactMatchIndex = suggestions.indexOf(query);
+    return Math.max(0, exactMatchIndex);
+}
+function getInputPlaceholder(pendingFlow) {
+    if (pendingFlow?.type === 'loginMethod') {
+        return 'Select login method';
+    }
+    if (pendingFlow?.type === 'loginUsername') {
+        return 'username';
+    }
+    if (pendingFlow?.type === 'loginPassword') {
+        return 'password';
+    }
+    if (pendingFlow?.type === 'loginoutConfirm') {
+        return 'yes/no';
+    }
+    return 'Enter your query';
+}
+export default function Index() {
+    const [input, setInput] = useState('');
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [pendingFlow, setPendingFlow] = useState();
+    const [username, setUsername] = useState();
+    const [sentMessages, setSentMessages] = useState([]);
+    const [nextMessageId, setNextMessageId] = useState(1);
+    const isLoggedIn = username !== undefined;
+    const suggestions = useMemo(() => (pendingFlow ? [] : getCommandSuggestions(input, isLoggedIn)), [input, isLoggedIn, pendingFlow]);
+    useEffect(() => {
+        if (selectedIndex >= suggestions.length) {
+            setSelectedIndex(0);
+        }
+    }, [selectedIndex, suggestions.length]);
+    const addMessage = (command, message) => {
+        setSentMessages(messages => [
+            ...messages.slice(-4),
+            { id: nextMessageId, command, message },
+        ]);
+        setNextMessageId(id => id + 1);
+    };
+    const resetInput = () => {
+        setInput('');
+        setSelectedIndex(0);
+    };
+    const clearPanel = () => {
+        setSentMessages([]);
+        setPendingFlow(undefined);
+        resetInput();
+    };
+    const confirmLoginout = (value) => {
+        const answer = value.trim().toLowerCase();
+        if (answer === 'yes') {
+            setUsername(undefined);
+            addMessage('/loginout', 'Logged out');
+            setPendingFlow(undefined);
+            resetInput();
+            return;
+        }
+        if (answer === 'no') {
+            addMessage('/loginout', 'Cancelled');
+            setPendingFlow(undefined);
+            resetInput();
+            return;
+        }
+        setInput('');
+    };
+    const submitLoginUsername = (value) => {
+        setPendingFlow({
+            type: 'loginPassword',
+            username: value.trim() || 'anonymous',
+        });
+        resetInput();
+    };
+    const submitLoginPassword = () => {
+        if (pendingFlow?.type !== 'loginPassword') {
+            resetInput();
+            return;
+        }
+        setUsername(pendingFlow.username);
+        addMessage('/login', `Logged in as ${pendingFlow.username}`);
+        setPendingFlow(undefined);
+        resetInput();
+    };
+    const selectLoginMethod = (method) => {
+        if (!isLoginMethod(method)) {
+            return;
+        }
+        if (isAccountPasswordLoginMethod(method)) {
+            setPendingFlow({ type: 'loginUsername' });
+            resetInput();
+            return;
+        }
+        const providerUsername = getProviderLoginUsername(method);
+        if (providerUsername) {
+            setUsername(providerUsername);
+            addMessage('/login', `Logged in as ${providerUsername}`);
+            setPendingFlow(undefined);
+            resetInput();
+        }
+    };
+    const sendMessage = (value) => {
+        if (pendingFlow?.type === 'loginMethod') {
+            resetInput();
+            return;
+        }
+        if (pendingFlow?.type === 'loginUsername') {
+            submitLoginUsername(value);
+            return;
+        }
+        if (pendingFlow?.type === 'loginPassword') {
+            submitLoginPassword();
+            return;
+        }
+        if (pendingFlow?.type === 'loginoutConfirm') {
+            confirmLoginout(value);
+            return;
+        }
+        const currentSuggestions = getCommandSuggestions(value, isLoggedIn);
+        const selectedSuggestion = currentSuggestions[selectedIndex];
+        const command = selectedSuggestion ?? value.trim();
+        const normalizedCommand = command.toLowerCase();
+        if (normalizedCommand === '/clear') {
+            clearPanel();
+            return;
+        }
+        if (normalizedCommand === '/login') {
+            if (isLoggedIn) {
+                addMessage(command, `Already logged in as ${username}`);
+                resetInput();
+                return;
+            }
+            setPendingFlow({ type: 'loginMethod' });
+            resetInput();
+            return;
+        }
+        if (normalizedCommand === '/loginout') {
+            if (!isLoggedIn) {
+                addMessage(command, 'Not logged in');
+                resetInput();
+                return;
+            }
+            setPendingFlow({ type: 'loginoutConfirm' });
+            resetInput();
+            return;
+        }
+        const message = runCommand(command);
+        if (message.length > 0) {
+            addMessage(command, message);
+        }
+        resetInput();
+    };
+    useInput((_value, key) => {
+        if (key.upArrow && suggestions.length > 0) {
+            setSelectedIndex(index => Math.max(0, index - 1));
+            return;
+        }
+        if (key.downArrow && suggestions.length > 0) {
+            setSelectedIndex(index => Math.min(suggestions.length - 1, index + 1));
+            return;
+        }
+        if (key.tab && suggestions[selectedIndex]) {
+            const suggestion = suggestions[selectedIndex];
+            setInput(suggestion);
+            setSelectedIndex(getDefaultSuggestionIndex(suggestion, isLoggedIn));
+            return;
+        }
+        if (key.escape) {
+            setInput('');
+            setSelectedIndex(0);
+            setPendingFlow(undefined);
+        }
+    });
+    const inputPlaceholder = getInputPlaceholder(pendingFlow);
+    const isLoginMethodSelection = pendingFlow?.type === 'loginMethod';
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(BigText, { text: "BOONCLI" }),
+        sentMessages.length > 0 && (React.createElement(Box, { flexDirection: "column" }, sentMessages.map(({ id, command, message }) => (React.createElement(Text, { key: id },
+            command.startsWith('/') ? 'Run' : 'Sent',
+            ":",
+            ' ',
+            React.createElement(Text, { color: "cyan" }, command),
+            " -",
+            ' ',
+            React.createElement(Text, { color: "green" }, message)))))),
+        isLoginMethodSelection && (React.createElement(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1 },
+            React.createElement(Text, null, "Login: select a method."),
+            React.createElement(Radio, { isActive: isLoginMethodSelection, items: [...loginMethods], onSelect: selectLoginMethod }))),
+        pendingFlow?.type === 'loginUsername' && (React.createElement(Box, { marginLeft: 2, marginTop: 1 },
+            React.createElement(Text, null,
+                "Login: enter any ",
+                React.createElement(Text, { color: "cyan" }, "username"),
+                "."))),
+        pendingFlow?.type === 'loginPassword' && (React.createElement(Box, { marginLeft: 2, marginTop: 1 },
+            React.createElement(Text, null,
+                "Login: enter any ",
+                React.createElement(Text, { color: "cyan" }, "password"),
+                "."))),
+        pendingFlow?.type === 'loginoutConfirm' && (React.createElement(Box, { marginLeft: 2, marginTop: 1 },
+            React.createElement(Text, null,
+                "Confirm ",
+                React.createElement(Text, { color: "cyan" }, "/loginout"),
+                "? Type",
+                ' ',
+                React.createElement(Text, { color: "green" }, "yes"),
+                " or ",
+                React.createElement(Text, { color: "red" }, "no"),
+                "."))),
+        React.createElement(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, paddingY: 0, borderLeft: false, borderRight: false, marginTop: 1 },
+            React.createElement(Text, { color: "cyan" }, "\u276F "),
+            React.createElement(TextInput, { focus: !isLoginMethodSelection, placeholder: inputPlaceholder, value: input, ...(pendingFlow?.type === 'loginPassword' ? { mask: '*' } : {}), onChange: value => {
+                    setInput(value);
+                    if (!pendingFlow) {
+                        setSelectedIndex(getDefaultSuggestionIndex(value, isLoggedIn));
+                    }
+                }, onSubmit: sendMessage })),
+        suggestions.length > 0 && (React.createElement(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1 }, suggestions.map((command, index) => {
+            const isSelected = index === selectedIndex;
+            return (React.createElement(Text, { key: command, ...(isSelected ? { color: 'yellow' } : {}) },
+                isSelected ? '>' : ' ',
+                " ",
+                command));
+        })))));
+}

package/dist/commands/log.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Log(): React.JSX.Element;

package/dist/commands/log.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Text } from 'ink';
+import { runCommand } from '../command-actions.js';
+export default function Log() {
+    return React.createElement(Text, null, runCommand('/log'));
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Login(): React.JSX.Element;

package/dist/commands/login.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Text } from 'ink';
+import { runCommand } from '../command-actions.js';
+export default function Login() {
+    return React.createElement(Text, null, runCommand('/login'));
+}

package/dist/commands/loginout.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Loginout(): React.JSX.Element;

package/dist/commands/loginout.js

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Text } from 'ink';
+import { runCommand } from '../command-actions.js';
+export default function Loginout() {
+    return React.createElement(Text, null, runCommand('/loginout'));
+}

package/dist/config.d.ts

@@ -0,0 +1,27 @@
+export type ModelProviderConfig = {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly wireApi: string;
+    readonly envKey: string;
+};
+export type ResolvedModelProviderConfig = ModelProviderConfig & {
+    readonly apiKey: string | undefined;
+};
+export type BoonCliConfig = {
+    readonly modelProviders: {
+        readonly deepseek: ModelProviderConfig;
+    };
+};
+export declare const defaultConfig: BoonCliConfig;
+export declare function getConfigDirectory(): string;
+export declare function getConfigFilePath(): string;
+export declare function ensureConfigExists(): Promise<string>;
+export declare function readConfig(): Promise<BoonCliConfig>;
+export declare function resolveProviderApiKey(provider: ModelProviderConfig): string | undefined;
+export declare function readResolvedDeepseekProvider(): Promise<{
+    apiKey: string | undefined;
+    name: string;
+    baseUrl: string;
+    wireApi: string;
+    envKey: string;
+}>;

package/dist/config.js

@@ -0,0 +1,90 @@
+import { constants } from 'node:fs';
+import { access, chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+const defaultConfigFileContent = `[model_providers.deepseek]
+name = "DeepSeek"
+base_url = "https://api.deepseek.com/v1"
+wire_api = "responses"
+env_key = "DEEPSEEK_API_KEY"
+`;
+export const defaultConfig = {
+    modelProviders: {
+        deepseek: {
+            name: 'DeepSeek',
+            baseUrl: 'https://api.deepseek.com/v1',
+            wireApi: 'responses',
+            envKey: 'DEEPSEEK_API_KEY',
+        },
+    },
+};
+export function getConfigDirectory() {
+    return (process.env['BOONCLI_CONFIG_DIR'] ?? path.join(os.homedir(), '.booncli'));
+}
+export function getConfigFilePath() {
+    return path.join(getConfigDirectory(), 'config.toml');
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readTomlValue(rawConfig, key) {
+    const match = new RegExp(`^${key}\\s*=\\s*"(.*)"$`, 'm').exec(rawConfig);
+    return match?.[1];
+}
+function parseConfig(rawConfig) {
+    return {
+        modelProviders: {
+            deepseek: {
+                name: readTomlValue(rawConfig, 'name') ??
+                    defaultConfig.modelProviders.deepseek.name,
+                baseUrl: readTomlValue(rawConfig, 'base_url') ??
+                    defaultConfig.modelProviders.deepseek.baseUrl,
+                wireApi: readTomlValue(rawConfig, 'wire_api') ??
+                    defaultConfig.modelProviders.deepseek.wireApi,
+                envKey: readTomlValue(rawConfig, 'env_key') ??
+                    defaultConfig.modelProviders.deepseek.envKey,
+            },
+        },
+    };
+}
+export async function ensureConfigExists() {
+    const configDirectory = getConfigDirectory();
+    const configFilePath = getConfigFilePath();
+    if (await pathExists(configFilePath)) {
+        return configFilePath;
+    }
+    await mkdir(configDirectory, { recursive: true });
+    await writeFile(configFilePath, defaultConfigFileContent, { mode: 0o600 });
+    await chmod(configFilePath, 0o600);
+    return configFilePath;
+}
+export async function readConfig() {
+    const configFilePath = await ensureConfigExists();
+    try {
+        const rawConfig = await readFile(configFilePath, 'utf8');
+        return parseConfig(rawConfig);
+    }
+    catch (error) {
+        throw new Error(`Failed to read config file: ${configFilePath}`, {
+            cause: error,
+        });
+    }
+}
+export function resolveProviderApiKey(provider) {
+    return process.env[provider.envKey];
+}
+export async function readResolvedDeepseekProvider() {
+    const config = await readConfig();
+    const provider = config.modelProviders.deepseek;
+    return {
+        ...provider,
+        apiKey: resolveProviderApiKey(provider),
+    };
+}

package/dist/login-methods.d.ts

@@ -0,0 +1,6 @@
+export declare const accountPasswordLoginMethod = "\u8D26\u53F7\u5BC6\u7801\u767B\u5F55";
+export declare const loginMethods: readonly ["google", "github", "apple", "账号密码登录"];
+export type LoginMethod = (typeof loginMethods)[number];
+export declare function isLoginMethod(method: string): method is LoginMethod;
+export declare function isAccountPasswordLoginMethod(method: string): method is typeof accountPasswordLoginMethod;
+export declare function getProviderLoginUsername(method: LoginMethod): "google" | "github" | "apple" | undefined;

package/dist/login-methods.js

@@ -0,0 +1,17 @@
+export const accountPasswordLoginMethod = '账号密码登录';
+export const loginMethods = [
+    'google',
+    'github',
+    'apple',
+    accountPasswordLoginMethod,
+];
+const loginMethodSet = new Set(loginMethods);
+export function isLoginMethod(method) {
+    return loginMethodSet.has(method);
+}
+export function isAccountPasswordLoginMethod(method) {
+    return method === accountPasswordLoginMethod;
+}
+export function getProviderLoginUsername(method) {
+    return isAccountPasswordLoginMethod(method) ? undefined : method;
+}

package/dist/modules/checkbox.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type CheckboxProps = {
+    readonly items: readonly string[];
+    readonly defaultChecked?: readonly number[];
+    readonly isActive?: boolean;
+    readonly onToggle?: (item: string, index: number, checked: boolean) => void;
+    readonly onSubmit?: (checkedItems: string[]) => void;
+    readonly onBack?: () => void;
+};
+export default function Checkbox({ items, defaultChecked, isActive, onToggle, onSubmit, onBack, }: CheckboxProps): React.JSX.Element;
+export {};

package/dist/modules/checkbox.js

@@ -0,0 +1,47 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function Checkbox({ items, defaultChecked = [], isActive = true, onToggle, onSubmit, onBack, }) {
+    const [cursor, setCursor] = useState(0);
+    const [checkedSet, setCheckedSet] = useState(new Set(defaultChecked));
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            setCursor(index => Math.max(0, index - 1));
+        }
+        if (key.downArrow) {
+            setCursor(index => Math.min(items.length - 1, index + 1));
+        }
+        // 空格切换选中
+        if (!key.return && _input === ' ') {
+            const checked = !checkedSet.has(cursor);
+            setCheckedSet(previous => {
+                const next = new Set(previous);
+                if (checked)
+                    next.add(cursor);
+                else
+                    next.delete(cursor);
+                return next;
+            });
+            onToggle?.(items[cursor], cursor, checked);
+        }
+        // Esc 返回
+        if (key.escape) {
+            onBack?.();
+        }
+        // 回车提交
+        if (key.return) {
+            const checkedItems = items.filter((_, index) => checkedSet.has(index));
+            onSubmit?.(checkedItems);
+        }
+    }, { isActive });
+    return (React.createElement(Box, { flexDirection: "column" }, items.map((item, i) => {
+        const isCursor = i === cursor;
+        const isChecked = checkedSet.has(i);
+        // 选中状态用 ■（实心方块），未选中用 □（空心方块），样式与 Radio 完全对齐
+        return (React.createElement(Text, { key: item, color: isCursor ? 'yellow' : 'white' },
+            isCursor ? '❯' : ' ',
+            " ",
+            isChecked ? '◉' : '○',
+            " ",
+            item));
+    })));
+}

package/dist/modules/loading.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Loading(): React.JSX.Element;

package/dist/modules/loading.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+export default function Loading() {
+    return (React.createElement(Box, null,
+        React.createElement(Text, null,
+            React.createElement(Spinner, null),
+            " Thinking...")));
+}

package/dist/modules/radio.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type RadioProps = {
+    readonly items: readonly string[];
+    readonly defaultIndex?: number;
+    readonly isActive?: boolean;
+    readonly onSelect?: (item: string, index: number) => void;
+};
+export default function Radio({ items, defaultIndex, isActive, onSelect, }: RadioProps): React.JSX.Element;
+export {};

package/dist/modules/radio.js

@@ -0,0 +1,28 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function Radio({ items, defaultIndex = 0, isActive = true, onSelect, }) {
+    const [index, setIndex] = useState(defaultIndex);
+    useInput((_input, key) => {
+        if (key.upArrow) {
+            setIndex(index => Math.max(0, index - 1));
+        }
+        if (key.downArrow) {
+            setIndex(index => Math.min(items.length - 1, index + 1));
+        }
+        if (key.return) {
+            const selectedItem = items[index];
+            if (selectedItem) {
+                onSelect?.(selectedItem, index);
+            }
+        }
+    }, { isActive });
+    return (React.createElement(Box, { flexDirection: "column" }, items.map((item, i) => {
+        const isSelected = i === index;
+        return (React.createElement(Text, { key: item, ...(isSelected ? { color: 'yellow' } : {}) },
+            isSelected ? '❯' : ' ',
+            " ",
+            isSelected ? '◉' : '○',
+            " ",
+            item));
+    })));
+}

package/dist/scripts/build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/build.js

@@ -0,0 +1,7 @@
+import { chmod, rm } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+await rm('dist', { force: true, recursive: true });
+await execFileAsync('tsc');
+await chmod('dist/cli.js', 0o755);

package/package.json

@@ -0,0 +1,62 @@
+{
+	"name": "@booncli/booncli",
+	"version": "1.0.0",
+	"license": "MIT",
+	"bin": {
+		"booncli": "dist/cli.js"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "TS_NODE_TRANSPILE_ONLY=true node --no-warnings --loader=ts-node/esm source/scripts/build.ts",
+		"dev": "TS_NODE_TRANSPILE_ONLY=true node --no-warnings --loader=ts-node/esm source/cli.tsx",
+		"watch": "tsc --watch",
+		"test": "prettier --check . && xo && TS_NODE_TRANSPILE_ONLY=true ava"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"ink": "^4.1.0",
+		"ink-big-text": "^2.0.0",
+		"ink-spinner": "^5.0.0",
+		"ink-text-input": "^5.0.1",
+		"pastel": "^2.0.0",
+		"react": "^18.2.0",
+		"zod": "^3.21.4"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/react": "^18.0.32",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.54.2"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
+}

package/readme.md

@@ -0,0 +1,70 @@
+# booncli
+
+> This readme is automatically generated by [create-pastel-app](https://github.com/vadimdemedes/create-pastel-app)
+
+## Install
+
+```bash
+$ npm install --global booncli
+```
+
+## CLI
+
+```
+$ booncli --help
+
+  Usage
+    $ booncli
+
+  Options
+    --name  Your name
+
+  Commands
+    clear
+    log
+    login
+    loginout
+
+  Examples
+    $ booncli --name=Jane
+    Hello, Jane
+
+    $ booncli login
+    Login
+
+    $ booncli loginout
+    Loginout
+
+    $ booncli log
+    Log
+
+    $ booncli clear
+    Cleared
+
+    $ booncli
+    Opens an interactive command dialog with /login, /loginout, /log and /clear suggestions.
+```
+
+单选框组件： /Users/zhuxwz/webSpace/space/CLI/booncli/source/modules/radio.tsx
+复选框组件：/Users/zhuxwz/webSpace/space/CLI/booncli/source/modules/checkbox.tsx
+Loading 组件：/Users/zhuxwz/webSpace/space/CLI/booncli/source/modules/loading.tsx
+
+## Local Config
+
+首次运行 CLI 时会自动创建本地配置文件：
+
+```bash
+~/.booncli/config.toml
+```
+
+默认内容：
+
+```toml
+[model_providers.deepseek]
+name = "DeepSeek"
+base_url = "https://api.deepseek.com/v1"
+wire_api = "responses"
+env_key = "DEEPSEEK_API_KEY"
+```
+
+配置文件权限会设置为仅当前用户可读写。配置文件只保存环境变量名称，真实 API key 从 `DEEPSEEK_API_KEY` 环境变量读取。