@xfe-repo/cli 2.0.8 → 2.0.11

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @xfe-repo/cli
 
+## 2.0.11
+
+### Patch Changes
+
+- 去除server依赖
+
+## 2.0.10
+
+### Patch Changes
+
+- 同步插件优化
+
+## 2.0.9
+
+### Patch Changes
+
+- 优化插件
+- Updated dependencies
+  - @xfe-repo/cli-presets@2.0.6
+  - @xfe-repo/cli-core@2.0.6
+  - @xfe-repo/server@0.1.1
+
+## 2.0.9
+
+### Patch Changes
+
+- 修复ai-rules插件的排序问题
+- Updated dependencies
+  - @xfe-repo/cli-presets@2.0.5
+  - @xfe-repo/cli-core@2.0.5
+
 ## 2.0.8
 
 ### Patch Changes

package/dist/backend/http-backend.d.ts

@@ -0,0 +1,47 @@
+/**
+ * XFE CLI HTTP Backend Gateway。
+ *
+ * CLI 通过该适配器连接本地或远端 xfe server。
+ */
+export interface BackendGatewayOptions {
+    readonly baseUrl: string;
+    readonly tenantId?: string;
+}
+export interface CreateRemoteTaskOptions {
+    readonly repoUrl: string;
+    readonly taskId: string;
+    readonly description: string;
+    readonly documentUrl?: string;
+    readonly baseBranch?: string;
+    readonly branchName?: string;
+    readonly workflowId?: string;
+    readonly prepareWorkspace?: boolean;
+}
+export interface StartRemoteTaskOptions {
+    readonly taskId: string;
+    readonly executor?: string;
+    readonly autoApprove?: boolean;
+}
+export interface RespondClientRequestOptions {
+    readonly requestId: string;
+    readonly action: 'accept' | 'decline' | 'cancel';
+    readonly content?: Record<string, unknown>;
+}
+export interface ListClientRequestsOptions {
+    readonly status?: string;
+}
+export declare class HttpBackendGateway {
+    private readonly baseUrl;
+    private readonly tenantId?;
+    constructor(options: BackendGatewayOptions);
+    health(): Promise<unknown>;
+    createTask(options: CreateRemoteTaskOptions): Promise<unknown>;
+    startTask(options: StartRemoteTaskOptions): Promise<unknown>;
+    listClientRequests(options?: ListClientRequestsOptions): Promise<unknown>;
+    respondClientRequest(options: RespondClientRequestOptions): Promise<unknown>;
+    private get;
+    private post;
+    private createUrl;
+    private createHeaders;
+}
+//# sourceMappingURL=http-backend.d.ts.map

package/dist/backend/http-backend.js

@@ -0,0 +1,84 @@
+/**
+ * XFE CLI HTTP Backend Gateway。
+ *
+ * CLI 通过该适配器连接本地或远端 xfe server。
+ */
+// ─── Gateway ───────────────────────────────────────────────
+export class HttpBackendGateway {
+    baseUrl;
+    tenantId;
+    constructor(options) {
+        this.baseUrl = trimTrailingSlash(options.baseUrl);
+        this.tenantId = options.tenantId;
+    }
+    async health() {
+        return this.get('/health');
+    }
+    async createTask(options) {
+        return this.post('/tasks', options);
+    }
+    async startTask(options) {
+        return this.post(`/tasks/${encodeURIComponent(options.taskId)}/start`, {
+            executor: options.executor,
+            autoApprove: options.autoApprove,
+        });
+    }
+    async listClientRequests(options = {}) {
+        return this.get('/client-requests', { status: options.status });
+    }
+    async respondClientRequest(options) {
+        return this.post(`/client-requests/${encodeURIComponent(options.requestId)}/respond`, {
+            action: options.action,
+            content: options.content,
+        });
+    }
+    async get(pathname, query) {
+        const response = await fetch(this.createUrl(pathname, query), { headers: this.createHeaders() });
+        return readResponse(response);
+    }
+    async post(pathname, body) {
+        const response = await fetch(this.createUrl(pathname), {
+            method: 'POST',
+            headers: { ...this.createHeaders(), 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        return readResponse(response);
+    }
+    createUrl(pathname, query = {}) {
+        const url = new URL(`${this.baseUrl}${pathname}`);
+        for (const [key, value] of Object.entries(query)) {
+            if (value)
+                url.searchParams.set(key, value);
+        }
+        return url.toString();
+    }
+    createHeaders() {
+        if (!this.tenantId)
+            return {};
+        return { 'x-xfe-tenant-id': this.tenantId };
+    }
+}
+// ─── Helpers ───────────────────────────────────────────────
+async function readResponse(response) {
+    const body = await readJson(response);
+    if (!response.ok) {
+        const message = typeof body === 'object' && body && 'error' in body ? String(body.error) : response.statusText;
+        throw new Error(`HTTP ${response.status}: ${message}`);
+    }
+    return body;
+}
+async function readJson(response) {
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, '');
+}
+//# sourceMappingURL=http-backend.js.map

package/dist/backend/server-task-commands.d.ts

@@ -0,0 +1,9 @@
+/**
+ * XFE CLI Server/Task 静态命令。
+ *
+ * 负责本地 server 启动、远端任务创建和 client request 交互循环。
+ */
+import { Command } from 'commander';
+export declare function registerServerCommands(program: Command): void;
+export declare function registerTaskCommands(program: Command): void;
+//# sourceMappingURL=server-task-commands.d.ts.map

package/dist/backend/server-task-commands.js

@@ -0,0 +1,262 @@
+/**
+ * XFE CLI Server/Task 静态命令。
+ *
+ * 负责本地 server 启动、远端任务创建和 client request 交互循环。
+ */
+import { createInterface } from 'node:readline/promises';
+import { DEFAULT_SERVER_PORT, startServer } from '@xfe-repo/server';
+import { HttpBackendGateway } from './http-backend.js';
+// ─── Public API ─────────────────────────────────────────────
+export function registerServerCommands(program) {
+    const serverCmd = program.command('server').helpCommand(false).description('XFE Server 管理');
+    serverCmd
+        .command('start')
+        .description('启动本地 xfe server')
+        .option('-p, --port <port>', `监听端口，默认 ${DEFAULT_SERVER_PORT}`)
+        .option('-H, --host <host>', '监听地址')
+        .action((options) => {
+        const server = startServer({ port: resolvePort(options.port), hostname: options.host });
+        printServerStarted(server);
+        bindServerSignals(server);
+    });
+}
+export function registerTaskCommands(program) {
+    const taskCmd = program.command('task').helpCommand(false).description('远端/本地 XFE Server 任务');
+    registerTaskCreateCommand(taskCmd);
+    registerTaskStartCommand(taskCmd);
+    registerRequestCommands(taskCmd);
+}
+// ─── Task Commands ─────────────────────────────────────────
+function registerTaskCreateCommand(taskCmd) {
+    taskCmd
+        .command('create')
+        .description('通过 xfe server 创建远端 agent 任务')
+        .requiredOption('--repo <repoUrl>', 'Git 仓库地址')
+        .requiredOption('--task <taskId>', '任务号，例如 3600')
+        .requiredOption('--description <description>', '任务需求描述')
+        .option('--server <url>', `server 地址，默认 http://localhost:${DEFAULT_SERVER_PORT}`)
+        .option('--tenant <tenantId>', '租户 ID，本地默认 local')
+        .option('--document-url <url>', '需求文档链接')
+        .option('--base-branch <branch>', '基准分支，默认 main')
+        .option('--branch <branchName>', '任务分支，默认 feat-${taskId}')
+        .option('--workflow <workflowId>', '任务流程 ID，默认 plan-code-review')
+        .option('--prepare-workspace', '创建任务后立即 clone 仓库并创建任务分支')
+        .option('--start', '创建任务后启动 agent workflow')
+        .option('--executor <executor>', 'agent executor，mock | codex | claude | copilot')
+        .option('--auto-approve', '启动 agent workflow 后自动通过计划审批')
+        .action(async (options) => {
+        const gateway = createBackendGateway(options);
+        const result = await gateway.createTask(createRemoteTaskPayload(options));
+        printJson(result);
+        if (!options.start)
+            return;
+        printJson(await gateway.startTask({ taskId: options.task, executor: options.executor, autoApprove: options.autoApprove }));
+    });
+}
+function registerTaskStartCommand(taskCmd) {
+    taskCmd
+        .command('start <taskId>')
+        .description('启动已创建的 agent workflow')
+        .option('--executor <executor>', 'agent executor，mock | codex | claude | copilot')
+        .option('--auto-approve', '自动通过计划审批')
+        .option('--server <url>', `server 地址，默认 http://localhost:${DEFAULT_SERVER_PORT}`)
+        .option('--tenant <tenantId>', '租户 ID，本地默认 local')
+        .action(async (taskId, options) => {
+        const gateway = createBackendGateway(options);
+        printJson(await gateway.startTask({ taskId, executor: options.executor, autoApprove: options.autoApprove }));
+    });
+}
+function registerRequestCommands(taskCmd) {
+    taskCmd
+        .command('requests')
+        .description('列出等待用户处理的 ask/approval 请求')
+        .option('--status <status>', '请求状态，默认不过滤')
+        .option('--server <url>', `server 地址，默认 http://localhost:${DEFAULT_SERVER_PORT}`)
+        .option('--tenant <tenantId>', '租户 ID，本地默认 local')
+        .action(async (options) => {
+        printJson(await createBackendGateway(options).listClientRequests({ status: options.status }));
+    });
+    taskCmd
+        .command('watch')
+        .description('监听并处理等待用户处理的 ask/approval 请求')
+        .option('--server <url>', `server 地址，默认 http://localhost:${DEFAULT_SERVER_PORT}`)
+        .option('--tenant <tenantId>', '租户 ID，本地默认 local')
+        .option('--interval <ms>', '轮询间隔，默认 1000')
+        .option('--once', '只处理当前 pending 请求后退出')
+        .action(async (options) => {
+        await watchClientRequests({ gateway: createBackendGateway(options), intervalMs: resolvePollInterval(options.interval), once: Boolean(options.once) });
+    });
+    taskCmd
+        .command('respond <requestId>')
+        .description('响应 ask/approval 请求')
+        .requiredOption('--action <action>', 'accept | decline | cancel')
+        .option('--content <json>', '响应内容 JSON')
+        .option('--server <url>', `server 地址，默认 http://localhost:${DEFAULT_SERVER_PORT}`)
+        .option('--tenant <tenantId>', '租户 ID，本地默认 local')
+        .action(async (requestId, options) => {
+        const result = await createBackendGateway(options).respondClientRequest({
+            requestId,
+            action: parseResponseAction(options.action),
+            content: parseJsonRecord(options.content),
+        });
+        printJson(result);
+    });
+}
+// ─── Watch Flow ────────────────────────────────────────────
+async function watchClientRequests(options) {
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    const handledRequestIds = new Set();
+    try {
+        while (true) {
+            await handlePendingRequests(terminal, options.gateway, handledRequestIds);
+            if (options.once)
+                return;
+            await wait(options.intervalMs);
+        }
+    }
+    finally {
+        terminal.close();
+    }
+}
+async function handlePendingRequests(terminal, gateway, handledRequestIds) {
+    const requests = await listPendingClientRequests(gateway, handledRequestIds);
+    for (const request of requests) {
+        handledRequestIds.add(request.id);
+        const response = await promptClientRequest(terminal, request);
+        await gateway.respondClientRequest({ requestId: request.id, action: response.action, content: response.content });
+    }
+}
+async function listPendingClientRequests(gateway, handledRequestIds) {
+    const response = await gateway.listClientRequests({ status: 'pending' });
+    return extractClientRequests(response).filter((request) => !handledRequestIds.has(request.id));
+}
+async function promptClientRequest(terminal, request) {
+    console.log(`\n[${request.kind}] ${request.id}`);
+    console.log(request.message);
+    if (isActionOnlyRequest(request.kind))
+        return { action: await promptAction(terminal), content: undefined };
+    return { action: 'accept', content: await promptSchemaContent(terminal, request.schema) };
+}
+async function promptAction(terminal) {
+    const answer = await terminal.question('处理方式 accept/decline/cancel，默认 accept: ');
+    const normalizedAnswer = answer.trim().toLowerCase();
+    if (!normalizedAnswer)
+        return 'accept';
+    if (normalizedAnswer === 'a' || normalizedAnswer === 'accept')
+        return 'accept';
+    if (normalizedAnswer === 'd' || normalizedAnswer === 'decline')
+        return 'decline';
+    if (normalizedAnswer === 'c' || normalizedAnswer === 'cancel')
+        return 'cancel';
+    throw new Error('处理方式必须是 accept、decline 或 cancel');
+}
+async function promptSchemaContent(terminal, schema) {
+    const fields = extractSchemaFields(schema);
+    if (fields.length === 0)
+        return undefined;
+    const content = {};
+    for (const field of fields) {
+        content[field.name] = await promptSchemaField(terminal, field);
+    }
+    return content;
+}
+async function promptSchemaField(terminal, field) {
+    const enumText = field.enumValues?.length ? ` (${field.enumValues.join(' | ')})` : '';
+    const defaultText = field.defaultValue === undefined ? '' : `，默认 ${String(field.defaultValue)}`;
+    const answer = await terminal.question(`${field.title}${enumText}${defaultText}: `);
+    const value = answer.trim() || field.defaultValue;
+    if (field.type === 'boolean')
+        return parseBooleanField(value);
+    if (field.type === 'number' || field.type === 'integer')
+        return Number(value);
+    return String(value ?? '');
+}
+function createRemoteTaskPayload(options) {
+    return {
+        repoUrl: options.repo,
+        taskId: options.task,
+        description: options.description,
+        documentUrl: options.documentUrl,
+        baseBranch: options.baseBranch,
+        branchName: options.branch,
+        workflowId: options.workflow,
+        prepareWorkspace: options.prepareWorkspace,
+    };
+}
+function createBackendGateway(options) {
+    return new HttpBackendGateway({ baseUrl: options.server ?? `http://localhost:${DEFAULT_SERVER_PORT}`, tenantId: options.tenant });
+}
+function printServerStarted(server) {
+    console.log(`XFE Server listening on ${server.hostname}:${server.port}`);
+    console.log(`HTTP health: http://${server.hostname}:${server.port}/health`);
+}
+function bindServerSignals(server) {
+    process.once('SIGINT', () => void stopLocalServer(server));
+    process.once('SIGTERM', () => void stopLocalServer(server));
+}
+async function stopLocalServer(server) {
+    await server.close();
+    process.exit(0);
+}
+function resolvePort(rawPort) {
+    const port = Number(rawPort);
+    return Number.isInteger(port) && port > 0 ? port : DEFAULT_SERVER_PORT;
+}
+function resolvePollInterval(rawInterval) {
+    const intervalMs = Number(rawInterval);
+    return Number.isInteger(intervalMs) && intervalMs > 0 ? intervalMs : 1000;
+}
+function parseResponseAction(action) {
+    if (action === 'accept' || action === 'decline' || action === 'cancel')
+        return action;
+    throw new Error('action 必须是 accept、decline 或 cancel');
+}
+function parseJsonRecord(content) {
+    if (!content)
+        return undefined;
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('content 必须是 JSON object');
+    return parsed;
+}
+function extractClientRequests(response) {
+    if (!isRecord(response) || !Array.isArray(response.requests))
+        return [];
+    return response.requests.filter(isClientRequestView);
+}
+function isClientRequestView(value) {
+    if (!isRecord(value))
+        return false;
+    return typeof value.id === 'string' && typeof value.kind === 'string' && typeof value.status === 'string' && typeof value.message === 'string';
+}
+function extractSchemaFields(schema) {
+    if (!schema || !isRecord(schema.properties))
+        return [];
+    return Object.entries(schema.properties).map(([name, value]) => createSchemaField(name, value));
+}
+function createSchemaField(name, value) {
+    const property = isRecord(value) ? value : {};
+    const enumValues = Array.isArray(property.enum) ? property.enum.filter((item) => typeof item === 'string') : undefined;
+    const title = typeof property.title === 'string' ? property.title : name;
+    const type = typeof property.type === 'string' ? property.type : undefined;
+    return { name, title, type, enumValues, defaultValue: property.default };
+}
+function isActionOnlyRequest(kind) {
+    return kind === 'approval' || kind === 'permission' || kind === 'confirm';
+}
+function parseBooleanField(value) {
+    if (typeof value === 'boolean')
+        return value;
+    const normalizedValue = String(value).trim().toLowerCase();
+    return normalizedValue === 'true' || normalizedValue === 'yes' || normalizedValue === 'y' || normalizedValue === '1';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function wait(intervalMs) {
+    return new Promise((resolve) => setTimeout(resolve, intervalMs));
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=server-task-commands.js.map

package/dist/components/Prompts/FuzzyPathPrompt.js

@@ -10,7 +10,7 @@ import { useKeymap, KeymapLayer } from '../../hooks/use-keymap.js';
 import { useSelectableList } from './use-selectable-list.js';
 import { OptionList, SearchBar } from './OptionList.js';
 export const FuzzyPathPrompt = memo(function FuzzyPathPrompt({ question, onSubmit }) {
-    const options = useMemo(() => collectPaths(question.rootPath || '.', question.itemType || 'any', question.excludePath).map((p) => ({ label: p, value: p })), [question.rootPath, question.itemType, question.excludePath]);
+    const options = useMemo(() => collectPaths(question.rootPath || '.', question.itemType || 'any', question.excludePath).map((p) => ({ key: p, label: p, value: p })), [question.rootPath, question.itemType, question.excludePath]);
     const { searchText, filtered, selectedIndex, selectedItem } = useSelectableList({
         items: options,
         searchable: true,

package/dist/components/Prompts/OptionList.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 /**
  * @xfe-repo/cli - 可滚动选项列表展示组件
  *
@@ -15,13 +15,25 @@ export const OptionList = memo(function OptionList({ options, selectedIndex, pag
     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [startIndex > 0 && _jsxs(Text, { dimColor: true, children: [" \u2191 \u8FD8\u6709 ", startIndex, " \u9879"] }), visibleItems.map((opt, i) => {
                 const actualIndex = startIndex + i;
                 const isFocused = actualIndex === selectedIndex;
-                return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: isFocused ? 'cyan' : undefined, children: isFocused ? '❯' : ' ' }), mode === 'checkbox' && _jsx(CheckboxIcon, { checked: opt.checked }), _jsx(Text, { color: isFocused ? 'cyan' : undefined, bold: isFocused, children: opt.label })] }, `${opt.label}-${actualIndex}`));
+                return (_jsxs(Box, { alignItems: "flex-start", children: [_jsx(OptionPrefix, { mode: mode, checked: opt.checked, isFocused: isFocused }), _jsx(OptionContent, { option: opt, isFocused: isFocused })] }, opt.key));
             }), startIndex + windowSize < totalItems && _jsxs(Text, { dimColor: true, children: [" \u2193 \u8FD8\u6709 ", totalItems - startIndex - windowSize, " \u9879"] })] }));
 });
 export const SearchBar = memo(function SearchBar({ text }) {
     return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "\u641C\u7D22: " }), _jsxs(Text, { children: [text, _jsx(Text, { color: "gray", children: "\u258C" })] })] }));
 });
 // ─── Render Helpers ─────────────────────────────────────────
+const OPTION_PREFIX_WIDTH = 2;
+const CHECKBOX_OPTION_PREFIX_WIDTH = 4;
+const FOCUSED_MARK = '❯';
+const EMPTY_MARK = ' ';
+const DESCRIPTION_COLOR = 'gray';
+const OptionPrefix = memo(function OptionPrefix({ mode, checked, isFocused, }) {
+    const prefixWidth = mode === 'checkbox' ? CHECKBOX_OPTION_PREFIX_WIDTH : OPTION_PREFIX_WIDTH;
+    return (_jsxs(Box, { width: prefixWidth, flexShrink: 0, children: [_jsx(Text, { color: isFocused ? 'cyan' : undefined, children: isFocused ? FOCUSED_MARK : EMPTY_MARK }), mode === 'checkbox' && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(CheckboxIcon, { checked: checked })] })), _jsx(Text, { children: " " })] }));
+});
+const OptionContent = memo(function OptionContent({ option, isFocused }) {
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 1, children: [_jsx(Text, { color: isFocused ? 'cyan' : undefined, bold: isFocused, children: option.label }), option.description && (_jsx(Text, { color: DESCRIPTION_COLOR, dimColor: true, children: option.description }))] }));
+});
 const CheckboxIcon = memo(function CheckboxIcon({ checked }) {
     return _jsx(Text, { color: checked ? 'green' : 'gray', children: checked ? '◉' : '○' });
 });

package/dist/components/Prompts/index.d.ts

@@ -1,4 +1,4 @@
-import type { PromptQuestion } from '@xfe-repo/cli-core';
+import type { PromptChoice, PromptQuestion } from '@xfe-repo/cli-core';
 import type { SelectOption } from './use-selectable-list.js';
 export interface PromptViewProps {
     readonly question: PromptQuestion;
@@ -11,8 +11,5 @@ export { SearchListPrompt } from './SearchListPrompt.js';
 export { SearchCheckboxPrompt } from './SearchCheckboxPrompt.js';
 export { FuzzyPathPrompt } from './FuzzyPathPrompt.js';
 export declare const Prompt: import("react").NamedExoticComponent<PromptViewProps>;
-export declare function normalizeChoices(choices?: {
-    name: string;
-    value: any;
-}[] | string[]): SelectOption[];
+export declare function normalizeChoices(choices?: PromptChoice[] | string[]): SelectOption[];
 //# sourceMappingURL=index.d.ts.map

package/dist/components/Prompts/index.js

@@ -40,8 +40,19 @@ export function normalizeChoices(choices) {
         return [];
     return choices.map((choice) => {
         if (typeof choice === 'string')
-            return { label: choice, value: choice };
-        return { label: choice.name, value: choice.value };
+            return { key: choice, label: choice, value: choice };
+        return {
+            key: choice.key ?? getChoiceFallbackKey(choice),
+            label: choice.name,
+            value: choice.value,
+            description: choice.description,
+        };
     });
 }
+function getChoiceFallbackKey(choice) {
+    if (typeof choice.value === 'string' || typeof choice.value === 'number' || typeof choice.value === 'boolean') {
+        return String(choice.value);
+    }
+    return choice.short ?? choice.name;
+}
 //# sourceMappingURL=index.js.map

package/dist/components/Prompts/use-selectable-list.d.ts

@@ -5,8 +5,10 @@
  * 供 ListPrompt / SearchListPrompt / FuzzyPathPrompt / SearchCheckboxPrompt 复用
  */
 export interface SelectOption {
+    readonly key: string;
     readonly label: string;
     readonly value: any;
+    readonly description?: string;
 }
 interface UseSelectableListOptions<T extends SelectOption> {
     readonly items: T[];

package/dist/components/Prompts/use-selectable-list.js

@@ -14,8 +14,8 @@ export function useSelectableList({ items, defaultIndex = 0, searchable = false,
     const filtered = useMemo(() => {
         if (!searchable || !searchText)
             return items;
-        const q = searchText.toLowerCase();
-        return items.filter((opt) => opt.label.toLowerCase().includes(q));
+        const searchKeyword = searchText.toLowerCase();
+        return items.filter((option) => getOptionSearchText(option).includes(searchKeyword));
     }, [items, searchText, searchable]);
     // 过滤结果变化时重置选中（跳过首次渲染，避免覆盖 defaultIndex）
     useUpdateEffect(() => {
@@ -54,4 +54,9 @@ export function useSelectableList({ items, defaultIndex = 0, searchable = false,
         selectedItem: filtered[selectedIndex],
     };
 }
+// ─── Helpers ────────────────────────────────────────────────
+function getOptionSearchText(option) {
+    const searchableText = [option.label, option.description ?? ''].join(' ');
+    return searchableText.toLowerCase();
+}
 //# sourceMappingURL=use-selectable-list.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfe-repo/cli",
-  "version": "2.0.8",
+  "version": "2.0.11",
   "description": "XFE CLI - Ink-based terminal UI for project scaffolding",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,8 +17,8 @@
     "ink-link": "^5.0.0",
     "react": "^19.1.0",
     "zod": "^4.3.6",
-    "@xfe-repo/cli-core": "2.0.4",
-    "@xfe-repo/cli-presets": "2.0.4"
+    "@xfe-repo/cli-presets": "2.0.6",
+    "@xfe-repo/cli-core": "2.0.6"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",