@rdmind/rdmind 0.0.15-alpha.1 → 0.0.15-alpha.7

package/dist/src/ui/commands/importCommand.js

@@ -1,762 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { CommandKind, } from './types.js';
-import { MessageType } from '../types.js';
-/**
- * 解析 import 命令参数
- */
-function parseImportArgs(args) {
-    const trimmedArgs = args.trim();
-    const parts = trimmedArgs.split(/\s+/);
-    if (parts.length === 1 && parts[0]) {
-        // /import MySQL
-        return {
-            middleware: parts[0].toLowerCase(),
-        };
-    }
-    else if (parts.length === 2) {
-        // /import MySQL 项目名
-        return {
-            middleware: parts[0].toLowerCase(),
-            projectName: parts[1],
-        };
-    }
-    return null;
-}
-/**
- * 处理 MySQL 导入逻辑
- */
-async function handleMySQLImport(context, projectName) {
-    const workspaceRoot = process.cwd();
-    // 检查是否提供了项目名（生成配置类需要项目名）
-    if (!projectName) {
-        context.ui.addItem({
-            type: MessageType.ERROR,
-            text: `❌ 请提供项目名称。\n\n使用格式：/import mysql <项目名>\n例如：/import mysql sns-demo`,
-        }, Date.now());
-        return;
-    }
-    context.ui.addItem({
-        type: MessageType.INFO,
-        text: `RDMind正在接入MySQL...`,
-    }, Date.now());
-    // 生成简化的 MySQL 接入提示词，让大模型自己管理整个流程
-    const prompt = generateSimpleMySQLSetupPrompt(workspaceRoot, projectName);
-    return {
-        type: 'submit_prompt',
-        content: prompt,
-    };
-}
-/**
- * 处理 Redis 导入逻辑
- */
-async function handleRedisImport(context) {
-    const workspaceRoot = process.cwd();
-    context.ui.addItem({
-        type: MessageType.INFO,
-        text: `RDMind正在接入Redis...`,
-    }, Date.now());
-    // 生成完整的 Redis 接入提示词，让大模型处理所有步骤
-    const prompt = generateCompleteRedisSetupPrompt(workspaceRoot);
-    return {
-        type: 'submit_prompt',
-        content: prompt,
-    };
-}
-/**
- * 生成简化的 Apollo 接入提示词
- */
-function generateSimpleApolloSetupPrompt(appId) {
-    return `请为Java项目完成 Apollo 接入配置，AppId："${appId}"。这是一个简单的配置文件更新任务，请创建todo列表来跟踪进度。
-
-**优化执行策略：**
-
-**第一步：查找 app.properties 文件**
-使用 file_search 工具查找 app.properties 文件：
-参数：pattern="**/app.properties"
-
-**第二步：更新 app.properties 文件**
-1. 使用 read_file 工具读取文件内容
-2. 查找文件中的 "app.id=sample" 行或类似的 app.id 配置
-3. 将现有的 app.id 值替换为 "${appId}"
-4. 使用 edit_file 工具更新文件内容（保持文件中的所有其他内容不变）
-
-**严格执行约束：**
-- 只能修改 app.id 的值，其他内容必须保持原样
-- 如果找不到 app.properties 文件，立即报告错误并停止
-- 如果文件中没有 app.id 配置，添加 app.id=${appId} 到文件末尾
-- 使用 edit_file 而不是 write_file 来确保更精确的修改
-
-**成功完成后告知用户：**
-✅ Apollo 接入配置已完成！
-📖 文档链接：https://docs.xiaohongshu.com/doc/98113484a8a9c92cbcfeddc10a310312
-
-**错误处理：**
-- 找不到 app.properties 文件：提示用户确保项目中存在该文件
-- 文件读取失败：报告具体的错误信息`;
-}
-/**
- * 生成优化的 MySQL 接入提示词
- */
-function generateSimpleMySQLSetupPrompt(workspaceRoot, projectName) {
-    return `请为Java项目 "${projectName}" 完成 MySQL 接入配置。这是一个需要系统化执行的多步骤任务，请创建todo列表来跟踪进度。
-
-**项目工作目录：** ${workspaceRoot}
-**项目名称：** ${projectName}
-
-**优化执行策略：**
-
-**第一步：项目结构探测（严格按此执行）**
-1. 使用 list_directory 工具，参数：path="${workspaceRoot}" 
-2. 从返回的目录列表中找到包含 "infrastructure" 或 "infra" 的目录名
-3. 使用 read_file 读取该目录下的 pom.xml，确认是模块文件
-4. 使用 list_directory 列出该目录下的 src/main/java 路径，找到包结构
-
-**第二步：检查 infra-root-pom 依赖**
-1. 使用 read_file 读取工作区根目录的 pom.xml
-2. 检查是否包含 <artifactId>infra-root-pom</artifactId> 依赖
-3. 如果缺少 infra-root-pom，立即提示用户并终止
-
-**第三步：目录创建（必须完成两个目录）**
-基于已确定的 infrastructure Java包路径，必须创建以下两个目录：
-1. {infrastructure包路径}/config/mysql - 用于配置类
-2. {infrastructure包路径}/mysql/mapper - 用于Mapper接口
-使用 run_terminal_cmd 工具，命令格式：mkdir -p {完整路径}
-
-**第四步：检查配置类文件是否存在**
-根据项目名 "${projectName}" 生成配置类文件名。
-转换规则：将 kebab-case 转为 CamelCase（如 sns-demo → SnsDemo）
-配置类文件路径：{infrastructure包路径}/config/mysql/{CamelCaseProjectName}DataSourceConfig.java
-使用 file_search 工具检查文件是否已存在，pattern="**/{CamelCaseProjectName}DataSourceConfig.java"
-如果找到文件，提示用户使用不同项目名
-
-**第五步：MySQL依赖检查和添加**
-1. 使用 read_file 读取 infrastructure 模块的 pom.xml
-2. 检查是否已存在以下MySQL依赖：
-   - com.xiaohongshu.redsql:redsql-spring-boot-starter
-   - org.mybatis:mybatis  
-   - org.mybatis:mybatis-spring
-3. 如果缺少任何依赖，使用 edit_file 在 </dependencies> 标签前添加缺失的依赖（严格按此格式）：
-\`\`\`xml
-        <!-- mysql -->
-        <dependency>
-            <groupId>com.xiaohongshu.redsql</groupId>
-            <artifactId>redsql-spring-boot-starter</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis-spring</artifactId>
-        </dependency>
-\`\`\`
-4. 如果所有依赖都已存在，跳过添加步骤
-
-**第六步：生成数据源配置类（严格使用此模板）**
-使用 edit_file 创建配置类文件，内容必须严格按照以下模板（替换占位符）：
-
-文件路径：{infrastructure包路径}/config/mysql/{CamelCaseProjectName}DataSourceConfig.java
-
-文件内容（**必须完全按照此模板，只替换占位符**）：
-\`\`\`java
-package {实际包路径}.config.mysql;
-
-import javax.sql.DataSource;
-
-import org.apache.ibatis.session.SqlSessionFactory;
-import org.mybatis.spring.SqlSessionFactoryBean;
-import org.mybatis.spring.annotation.MapperScan;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.boot.jdbc.DataSourceBuilder;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
-import org.springframework.jdbc.core.JdbcTemplate;
-
-import com.xiaohongshu.redsql.group.jdbc.GroupDataSource;
-
-@Configuration
-@MapperScan(basePackages = "{实际包路径}.mysql.mapper",
-        sqlSessionFactoryRef = "{camelCaseProjectName}SqlSessionFactory")
-public class {CamelCaseProjectName}DataSourceConfig {
-
-    @Bean(name = "{camelCaseProjectName}Datasource", initMethod = "init")
-    @ConfigurationProperties(prefix = "spring.datasource.{projectName}")
-    public GroupDataSource {camelCaseProjectName}Datasource() {
-        return DataSourceBuilder.create().type(GroupDataSource.class).build();
-    }
-
-    @Bean(name = "{camelCaseProjectName}SqlSessionFactory")
-    public SqlSessionFactory {camelCaseProjectName}SqlSessionFactory(@Qualifier("{camelCaseProjectName}Datasource") DataSource datasource)
-            throws Exception {
-        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
-        sqlSessionFactoryBean.setDataSource(datasource);
-        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
-        return sqlSessionFactoryBean.getObject();
-    }
-
-    @Bean(name="{camelCaseProjectName}JdbcTemplate")
-    public JdbcTemplate jdbcTemplate(@Qualifier("{camelCaseProjectName}Datasource") DataSource dataSource) {
-        return new JdbcTemplate(dataSource);
-    }
-}
-\`\`\`
-
-**第七步：更新 application-sit.yml 配置文件**
-1. 使用 file_search 查找 "**/application-sit.yml" 文件
-2. 使用 read_file 读取文件内容  
-3. 使用 edit_file 在文件末尾添加以下内容（严格按此格式）：
-\`\`\`yaml
-
-spring:
-  datasource:
-    ${projectName}:
-      url: # TODO: 请填写数据库连接标识符
-\`\`\`
-
-**严格执行约束：**
-- 禁止使用多次 list_directory 或重复的文件查找操作
-- 第一步必须只使用一次 list_directory，参数：path="${workspaceRoot}"
-- 第三步必须同时创建两个目录：config/mysql 和 mysql/mapper  
-- 第四步使用 file_search 检查文件存在性，不要使用 read_file（会报错）
-- 配置类和YAML配置必须严格按照提供的模板，禁止修改格式
-- 依赖标签中严禁添加 version 元素
-- 每一步只允许使用指定的工具，不得偏离
-- 如果某步骤失败，立即报告错误并停止执行
-
-**成功完成后告知用户：**
-✅ MySQL 接入配置已完成！请参考接入文档进行标识符申请：
-📖 文档链接：https://docs.xiaohongshu.com/doc/920c445ca92ebe2a964655e0ef3ec6ac
-
-**错误处理：**
-- 找不到 infrastructure 模块：提示用户确保项目存在相应模块
-- 缺少 infra-root-pom：提示先接入 infra-root-pom
-- 配置类已存在：提示使用不同项目名`;
-}
-/**
- * 生成简化的 RocketMQ 接入提示词
- */
-function generateSimpleRocketMqSetupPrompt(workspaceRoot) {
-    return `请为Java项目完成 RocketMQ 接入配置。这是一个需要系统化执行的多步骤任务，请创建todo列表来跟踪进度。
-
-**项目工作目录：** ${workspaceRoot}
-
-**优化执行策略：**
-
-**第一步：项目结构探测（一次性完成）**
-使用 list_directory 工具列出工作区根目录，寻找：
-- 包含 "domain" 的目录（用于添加依赖）
-- 包含 "infrastructure" 或 "infra" 的目录（用于创建配置类）
-- 对应的包结构目录
-
-**第二步：检查 infra-root-pom 依赖**
-1. 使用 read_file 读取工作区根目录的 pom.xml
-2. 检查是否包含 <artifactId>infra-root-pom</artifactId> 依赖
-3. 如果缺少，立即提示用户并终止
-
-**第三步：events-client 依赖检查和添加**
-1. 使用 read_file 读取 domain 模块的 pom.xml
-2. 检查是否已存在 com.xiaohongshu:events-client 依赖
-3. 如果缺少，使用 edit_file 在 </dependencies> 标签前添加：
-\`\`\`xml
-        <dependency>
-            <groupId>com.xiaohongshu</groupId>
-            <artifactId>events-client</artifactId>
-        </dependency>
-\`\`\`
-
-**第四步：创建目录结构**
-在 infrastructure Java包路径下创建以下目录：
-1. config/mq - 用于配置类
-2. events - 用于事件处理类（在domain包下）
-使用 run_terminal_cmd，命令：mkdir -p {完整路径}
-
-**第五步：生成配置类文件（使用以下固定模板）**
-根据实际的包路径，创建以下配置类文件（严格按照模板，只替换包名）：
-
-**1. RocketMqProducerConfig.java** - 配置类目录
-\`\`\`java
-package {实际包路径}.config.mq;
-
-import com.xiaohongshu.events.client.producer.EventsProducer;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-public class RocketMqProducerConfig {
-
-    @Bean
-    public EventsProducer eventsProducer() {
-        EventsProducer eventsProducer = new EventsProducer();
-        eventsProducer.setEnableXrayTrace(true);
-        eventsProducer.start();
-        return eventsProducer;
-    }
-}
-\`\`\`
-
-**2. WrapperMqProducer.java** - 配置类目录
-\`\`\`java
-package {实际包路径}.config.mq;
-
-import com.xiaohongshu.events.client.DelayMessage;
-import com.xiaohongshu.events.client.Message;
-import com.xiaohongshu.events.client.producer.EventsProducer;
-import com.xiaohongshu.events.client.producer.SendResult;
-import com.xiaohongshu.events.client.producer.SendStatus;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.springframework.stereotype.Component;
-
-import javax.annotation.Resource;
-
-@Component
-@Slf4j
-public class WrapperMqProducer {
-
-    @Resource
-    private EventsProducer eventsProducer;
-
-    public boolean send(String topic, String tag, String key, byte[] body) {
-        if (StringUtils.isEmpty(topic)) {
-            log.error("sendMq topic is null, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-            return false;
-        }
-
-        if (StringUtils.isEmpty(tag)) {
-            log.error("sendMq tag is null, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-            return false;
-        }
-
-        try {
-            Message message = new Message();
-            message.setTopic(topic);
-            message.setTags(tag);
-            message.setKey(key);
-            message.setBody(body);
-            SendResult sendResult = eventsProducer.send(message);
-            if (sendResult == null) {
-                log.error("sendMq result is null, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-                return false;
-            }
-
-            if (sendResult.getSendStatus() != SendStatus.SUCCESS) {
-                log.error("sendMq failed, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-                return false;
-            }
-            log.info("sendMq success, topic:{}, tag:{}, key:{}, outputMqId:{}", topic, tag, key, sendResult.getMsgId());
-            return true;
-        } catch (Exception e) {
-            log.error("send mq error", e);
-        }
-        return false;
-    }
-
-    public boolean sendDelay(String topic, String tag, String key, byte[] body, long delayTime) {
-        if (StringUtils.isEmpty(topic)) {
-            log.error("sendMq topic is null, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-            return false;
-        }
-
-        if (StringUtils.isEmpty(tag)) {
-            log.error("sendMq tag is null, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-            return false;
-        }
-
-        try {
-            DelayMessage message = new DelayMessage();
-            message.setTopic(topic);
-            message.setTags(tag);
-            message.setKey(key);
-            message.setBody(body);
-            //消息投递时间：秒级单位
-            message.setDeliverTime(delayTime / 1000);
-            SendResult sendResult = eventsProducer.sendDelay(message);
-            if (sendResult == null) {
-                log.error("sendDelay result is null, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-                return false;
-            }
-
-            if (sendResult.getSendStatus() != SendStatus.SUCCESS) {
-                log.error("sendDelay failed, topic:{}, tag:{}, body:{}", topic, tag, new String(body));
-                return false;
-            }
-            log.info("sendDelay success, topic:{}, tag:{}, key:{}, outputMqId:{}", topic, tag, key, sendResult.getMsgId());
-            return true;
-        } catch (Exception e) {
-            log.error("sendDelay mq error", e);
-        }
-        return false;
-    }
-}
-\`\`\`
-
-**3. MessageLifecycleListener.java** - 配置类目录
-\`\`\`java
-package {实际包路径}.config.mq;
-
-import com.xiaohongshu.events.client.consumer.AbstractConsumer;
-import com.xiaohongshu.events.client.producer.AbstractProducer;
-import com.xiaohongshu.events.common.life.LifeCycleException;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.BeansException;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationContextAware;
-import org.springframework.context.SmartLifecycle;
-
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * 用于控制消息生产者和消费者的启动和关闭，避免实例在依赖未启动完成前进行生产或消费
- */
-@Slf4j
-public class MessageLifecycleListener implements SmartLifecycle, ApplicationContextAware {
-
-    private final AtomicBoolean started = new AtomicBoolean(false);
-
-    private ApplicationContext applicationContext;
-
-    @Override
-    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
-        this.applicationContext = applicationContext;
-    }
-
-    @Override
-    public void start() {
-        if (started.compareAndSet(false, true)) {
-            startup();
-        }
-    }
-
-    @Override
-    public void stop() {
-        if (started.compareAndSet(true, false)) {
-            shutdown();
-        }
-    }
-
-    @Override
-    public boolean isRunning() {
-        return started.get();
-    }
-
-    private void startup() {
-        log.info("开始启动消息生产者和消费者");
-        // 启动消费者
-        applicationContext.getBeansOfType(AbstractConsumer.class)
-                .values()
-                .stream()
-                .forEach(this::startConsumer);
-
-        // 启动生产者
-        applicationContext.getBeansOfType(AbstractProducer.class)
-                .values()
-                .stream()
-                .forEach(this::startProducer);
-    }
-
-    private void shutdown() {
-        log.info("开始关闭消息生产者和消费者");
-        if (Objects.isNull(applicationContext)) {
-            return;
-        }
-
-        // 关闭生产者
-        applicationContext.getBeansOfType(AbstractProducer.class)
-                .values()
-                .stream()
-                .forEach(this::shutdownProducer);
-
-        // 关闭消费者
-        applicationContext.getBeansOfType(AbstractConsumer.class)
-                .values()
-                .stream()
-                .forEach(this::shutdownConsumer);
-    }
-
-    private void startConsumer(AbstractConsumer consumer) {
-        try {
-            if (!consumer.isStarted()) {
-                consumer.start();
-            }
-        } catch (LifeCycleException e) {
-            log.error("启动消费者 topic: {}, group: {} 失败: {}", consumer.getTopic(), consumer.getGroup(), e.getMessage(), e);
-        }
-    }
-
-    private void startProducer(AbstractProducer producer) {
-        try {
-            if (!producer.isStarted()) {
-                producer.start();
-            }
-        } catch (LifeCycleException e) {
-            log.error("启动生产者: [{}] 失败: {}", producer.getTopics(), e.getMessage(), e);
-        }
-    }
-
-    private void shutdownConsumer(AbstractConsumer consumer) {
-        try {
-            if (consumer.isStarted()) {
-                consumer.shutdown();
-            }
-        } catch (LifeCycleException e) {
-            log.error("关闭消费者 topic: {}, group: {} 失败: {}", consumer.getTopic(), consumer.getGroup(), e.getMessage(), e);
-        }
-    }
-
-    private void shutdownProducer(AbstractProducer producer) {
-        try {
-            if (producer.isStarted()) {
-                producer.shutdown();
-            }
-        } catch (LifeCycleException e) {
-            log.error("关闭生产者: [{}] 失败: {}", producer.getTopics(), e.getMessage(), e);
-        }
-    }
-}
-\`\`\`
-
-**4. RocketMqConsumerConfig.java** - 配置类目录
-\`\`\`java
-package {实际包路径}.config.mq;
-
-import com.xiaohongshu.events.client.consumer.EventsPushConsumer;
-import {domain包路径}.events.MqProcessor;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-import javax.annotation.Resource;
-
-@Configuration
-public class RocketMqConsumerConfig {
-
-    @Resource
-    private MqProcessor mqProcessor;
-
-    @Bean
-    public MessageLifecycleListener eventOrderConfiguration() {
-        return new MessageLifecycleListener();
-    }
-
-    @Bean
-    public EventsPushConsumer mqConsumer() {
-        EventsPushConsumer consumer = new EventsPushConsumer();
-        consumer.setTopic("");
-        consumer.setGroup("");
-        consumer.setEnableXrayTrace(true);
-        consumer.setMessageProcessor(mqProcessor);
-        return consumer;
-    }
-}
-\`\`\`
-
-**5. MqProcessor.java** - domain/events目录
-\`\`\`java
-package {domain包路径}.events;
-
-import com.xiaohongshu.events.client.MessageExt;
-import com.xiaohongshu.events.client.api.MessageProcessor;
-import com.xiaohongshu.events.client.consumer.ConsumeContext;
-import com.xiaohongshu.events.client.consumer.ConsumeStatus;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-@Service
-@Slf4j
-public class MqProcessor implements MessageProcessor {
-    @Override
-    public ConsumeStatus process(MessageExt messageExt, ConsumeContext consumeContext) {
-        return null;
-    }
-}
-\`\`\`
-
-**严格执行约束：**
-- 禁止使用多次 list_directory 调用
-- 配置类必须严格按照上述模板，只替换包名占位符，不得修改代码内容
-- 严禁在依赖中添加 version 标签
-- 如果某步骤失败，立即报告错误并停止
-
-**成功完成后告知用户：**
-✅ RocketMQ 接入配置已完成！包含生产者、消费者、消息处理器和生命周期管理器等完整配置。
-📖 更详细的使用说明请参考：https://docs.xiaohongshu.com/doc/adc99c5ec0214993aed7771f866ecd58
-
-**错误处理：**
-- 找不到 domain 或 infrastructure 模块：提示用户确保项目存在相应模块
-- 缺少 infra-root-pom：提示先接入 infra-root-pom`;
-}
-/**
- * 生成完整的 Redis 接入提示词
- */
-function generateCompleteRedisSetupPrompt(workspaceRoot) {
-    return `请为Java项目完成 Redis 接入配置。这是一个需要系统化执行的多步骤任务，请创建todo列表来跟踪进度。
-
-**项目工作目录：** ${workspaceRoot}
-
-**完整任务流程：**
-
-1. **查找 infrastructure 模块的 pom.xml 文件**
-   - 在工作区根目录下查找包含 "infrastructure" 或 "infra" 的子目录
-   - 验证该目录下是否存在 pom.xml 文件
-   - 确认是模块 pom（包含 <parent> 和 <dependencies>）
-
-2. **检查顶层 pom.xml 中的 infra-root-pom 依赖**
-   - 读取工作区根目录的 pom.xml 文件
-   - 检查是否包含 <artifactId>infra-root-pom</artifactId> 依赖
-   - 如果不存在，提示用户先接入 infra-root-pom
-
-3. **检查模块 pom.xml 中的 Redis 相关依赖**
-   - 读取 infrastructure 模块的 pom.xml 内容
-   - 检查是否已存在 groupId: com.xiaohongshu.infra.midware, artifactId: redis-spring 的依赖
-   - 如果已存在，直接完成并告知用户
-
-4. **添加 Redis 依赖到 infrastructure 模块**
-   - 在 infrastructure 模块的 pom.xml 文件中添加 Redis 依赖
-   - 在 </dependencies> 标签正上方添加以下内容：
-   
-   \`\`\`xml
-   <!-- Spring 环境通过连接符接入引入redis-spring -->
-   <dependency>
-       <groupId>com.xiaohongshu.infra.midware</groupId>
-       <artifactId>redis-spring</artifactId>
-   </dependency>
-   \`\`\`
-
-**重要说明：**
-- 使用 file_search 或 list_dir 工具查找文件和目录
-- 使用 read_file 工具读取文件内容
-- 使用 edit_file 工具编辑 pom.xml 文件
-- 保持正确的XML缩进，严禁添加version标签
-- 如果任何步骤失败，提供清晰的错误信息和解决建议
-
-**成功完成后告知用户：**
-✅ Redis 接入配置已完成！请参考接入文档进行标识符申请：
-📖 文档链接：https://docs.xiaohongshu.com/doc/5ff2d7dadba283a5fb6e7bd6c6e53001
-
-**错误情况处理：**
-- 如果找不到 infrastructure 模块：提示用户确保项目中存在相应模块目录
-- 如果没有 infra-root-pom 依赖：提示用户先接入 infra-root-pom
-- 如果 Redis 依赖已存在：告知用户无需重复添加`;
-}
-/**
- * 处理 Apollo 导入逻辑
- */
-async function handleApolloImport(context, appId) {
-    if (!appId) {
-        context.ui.addItem({
-            type: MessageType.ERROR,
-            text: `❌ 请提供 AppId 参数\n\n使用格式：/import apollo <appid>\n\n示例：/import apollo my-app-id`,
-        }, Date.now());
-        return;
-    }
-    context.ui.addItem({ type: MessageType.INFO, text: `RDMind正在接入Apollo...` }, Date.now());
-    // 生成简化的 Apollo 接入提示词
-    const prompt = generateSimpleApolloSetupPrompt(appId);
-    return {
-        type: 'submit_prompt',
-        content: prompt,
-    };
-}
-/**
- * 处理 RocketMQ 导入逻辑
- */
-async function handleRocketMqImport(context) {
-    const workspaceRoot = process.cwd();
-    context.ui.addItem({
-        type: MessageType.INFO,
-        text: `RDMind正在接入RocketMQ...`,
-    }, Date.now());
-    // 生成简化的 RocketMQ 接入提示词
-    const prompt = generateSimpleRocketMqSetupPrompt(workspaceRoot);
-    return {
-        type: 'submit_prompt',
-        content: prompt,
-    };
-}
-/**
- * MySQL 子命令
- */
-const mysqlCommand = {
-    name: 'mysql',
-    description: '导入 MySQL ',
-    kind: CommandKind.BUILT_IN,
-    action: async (context, args) => {
-        const projectName = args.trim() || undefined;
-        return await handleMySQLImport(context, projectName);
-    },
-};
-/**
- * Apollo 子命令
- */
-const apolloCommand = {
-    name: 'apollo',
-    description: '导入 Apollo ',
-    kind: CommandKind.BUILT_IN,
-    action: async (context, args) => {
-        const appId = args.trim() || undefined;
-        return await handleApolloImport(context, appId);
-    },
-};
-/**
- * Redis 子命令
- */
-const redisCommand = {
-    name: 'redis',
-    description: '导入 Redis ',
-    kind: CommandKind.BUILT_IN,
-    action: async (context, _args) => await handleRedisImport(context),
-};
-/**
- * RocketMQ 子命令
- */
-const rocketMqCommand = {
-    name: 'rocketmq',
-    description: '导入 RocketMQ ',
-    kind: CommandKind.BUILT_IN,
-    action: async (context, _args) => await handleRocketMqImport(context),
-};
-/**
- * 主 import 命令
- */
-export const importCommand = {
-    name: 'import',
-    description: '为工作区的 Java 项目导入中间件',
-    kind: CommandKind.BUILT_IN,
-    subCommands: [mysqlCommand, redisCommand, apolloCommand, rocketMqCommand],
-    action: async (context, args) => {
-        const parsedArgs = parseImportArgs(args);
-        if (!parsedArgs) {
-            context.ui.addItem({
-                type: MessageType.ERROR,
-                text: '❌ 命令格式错误。请使用以下格式：\n• /import <中间件类型> [项目名]\n\n支持的中间件类型：\n• MySQL - 接入MySQL数据库中间件（需要项目名）\n• Redis - 接入Redis缓存中间件\n• Apollo - 接入Apollo配置中心（需要应用ID）\n• RocketMQ - 接入RocketMQ消息中间件\n\n示例：\n• /import MySQL my-project\n• /import Redis\n• /import Apollo my-app-id\n• /import RocketMQ',
-            }, Date.now());
-            return;
-        }
-        const { middleware, projectName } = parsedArgs;
-        // 根据中间件类型调用相应的处理函数
-        switch (middleware) {
-            case 'mysql':
-                return await handleMySQLImport(context, projectName);
-            case 'redis':
-                return await handleRedisImport(context);
-            case 'apollo':
-                return await handleApolloImport(context, projectName);
-            case 'rocketmq':
-                return await handleRocketMqImport(context);
-            default:
-                context.ui.addItem({
-                    type: MessageType.ERROR,
-                    text: `❌ 不支持的中间件类型：${middleware}\n\n当前支持的中间件类型：MySQL, Redis, Apollo, RocketMQ`,
-                }, Date.now());
-                return;
-        }
-    },
-};
-//# sourceMappingURL=importCommand.js.map