@xfe-repo/cli 2.0.8 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @xfe-repo/cli
 
+## 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,45 @@
+/**
+ * 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 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 baseUrl;
+    private 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,88 @@
+/**
+ * XFE CLI HTTP Backend Gateway。
+ *
+ * CLI 通过该适配器连接本地或远端 xfe server。
+ */
+// ─── HttpBackendGateway ─────────────────────────────────────
+export class HttpBackendGateway {
+    baseUrl;
+    tenantId;
+    constructor(options) {
+        this.baseUrl = normalizeBaseUrl(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(createPathWithQuery('/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) {
+        const response = await fetch(this.createUrl(pathname), { 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) {
+        return `${this.baseUrl}${pathname}`;
+    }
+    createHeaders() {
+        if (!this.tenantId)
+            return {};
+        return { 'x-xfe-tenant-id': this.tenantId };
+    }
+}
+// ─── Helpers ────────────────────────────────────────────────
+async function readResponse(response) {
+    const text = await response.text();
+    const body = parseJson(text);
+    if (!response.ok) {
+        const message = typeof body === 'object' && body && 'error' in body ? String(body.error) : text;
+        throw new Error(message || `HTTP ${response.status}`);
+    }
+    return body;
+}
+function parseJson(text) {
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/$/, '');
+}
+function createPathWithQuery(pathname, query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value)
+            searchParams.set(key, value);
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${pathname}?${queryString}` : pathname;
+}
+//# 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,254 @@
+/**
+ * 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 port = resolvePort(options.port);
+        const server = startServer({ port, hostname: options.host });
+        console.log(`XFE Server listening on ${options.host ?? '0.0.0.0'}:${server.port}`);
+        console.log(`HTTP health: http://${options.host ?? 'localhost'}:${server.port}/health`);
+        console.log(`MCP endpoint: http://${options.host ?? 'localhost'}:${server.port}/mcp`);
+        process.once('SIGINT', () => void stopLocalServer(server.close));
+        process.once('SIGTERM', () => void stopLocalServer(server.close));
+    });
+}
+export function registerTaskCommands(program) {
+    const taskCmd = program.command('task').helpCommand(false).description('远端/本地 XFE Server 任务');
+    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('--prepare-workspace', '创建任务后立即 clone 仓库并创建任务分支')
+        .option('--start', '创建任务后启动 agent workflow')
+        .option('--executor <executor>', 'agent executor，mock | codex | copilot')
+        .option('--auto-approve', '启动 agent workflow 后自动通过计划审批')
+        .action(async (options) => {
+        const gateway = createBackendGateway(options);
+        const result = await gateway.createTask({
+            repoUrl: options.repo,
+            taskId: options.task,
+            description: options.description,
+            documentUrl: options.documentUrl,
+            baseBranch: options.baseBranch,
+            prepareWorkspace: options.prepareWorkspace,
+        });
+        printJson(result);
+        if (!options.start)
+            return;
+        const started = await gateway.startTask({ taskId: options.task, executor: options.executor, autoApprove: options.autoApprove });
+        printJson(started);
+    });
+    taskCmd
+        .command('start <taskId>')
+        .description('启动已创建的 agent workflow')
+        .option('--executor <executor>', 'agent executor，mock | codex | 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);
+        const started = await gateway.startTask({ taskId, executor: options.executor, autoApprove: options.autoApprove });
+        printJson(started);
+    });
+    registerRequestCommands(taskCmd);
+}
+// ─── Command Registration ───────────────────────────────────
+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) => {
+        const gateway = createBackendGateway(options);
+        const result = await gateway.listClientRequests({ status: options.status });
+        printJson(result);
+    });
+    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 gateway = createBackendGateway(options);
+        const result = await gateway.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) {
+            const requests = await listPendingClientRequests(options.gateway, handledRequestIds);
+            for (const request of requests) {
+                handledRequestIds.add(request.id);
+                const response = await promptClientRequest(terminal, request);
+                await options.gateway.respondClientRequest({ requestId: request.id, action: response.action, content: response.content });
+            }
+            if (options.once)
+                return;
+            await wait(options.intervalMs);
+        }
+    }
+    finally {
+        terminal.close();
+    }
+}
+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 };
+    const content = await promptSchemaContent(terminal, request.schema);
+    return { action: 'accept', content };
+}
+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 ?? '');
+}
+// ─── Helpers ────────────────────────────────────────────────
+function createBackendGateway(options) {
+    return new HttpBackendGateway({ baseUrl: options.server ?? `http://localhost:${DEFAULT_SERVER_PORT}`, tenantId: options.tenant });
+}
+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;
+}
+async function stopLocalServer(close) {
+    await close();
+    process.exit(0);
+}
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfe-repo/cli",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "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-core": "2.0.5",
+    "@xfe-repo/cli-presets": "2.0.5"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",