intention-coding 0.3.7 → 0.4.0

package/dist/utils/dify.js

@@ -0,0 +1,243 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeFlow = invokeFlow;
+exports.removeCodeBlock = removeCodeBlock;
+/**
+ * 调用工作流
+ *
+ * @param params 请求参数对象
+ * @param params.appid 应用ID，如果不提供则使用默认值 "app-ESTcrkOPOmkxdrO0120mE4s1"
+ * @param params.data 工作流输入数据
+ * @param params.timeout 请求超时时间（毫秒）
+ * @param streamCb 流回调函数，用于处理流式响应
+ * @returns Promise 返回一个Promise对象，解析为工作流响应结果或流响应对象
+ */
+function invokeFlow(params, streamCb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { appid = 'app-ESTcrkOPOmkxdrO0120mE4s1', data, timeout = 30 * 60 * 1000 // 默认设置为30分钟
+         } = params;
+        const controller = new AbortController();
+        const signal = controller.signal;
+        const fetchData = (...args_1) => __awaiter(this, [...args_1], void 0, function* (retryCount = 0) {
+            try {
+                // 设置fetch的timeout选项
+                const fetchOptions = {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${appid}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        'inputs': data,
+                        'response_mode': 'streaming',
+                        'user': "aico-mcp"
+                    }),
+                    signal
+                };
+                // 发起请求，加入 abort 信号
+                const res = yield fetch('http://11.0.166.20:9199/v1/workflows/run', fetchOptions);
+                if (!res.ok) {
+                    if (retryCount < 3) {
+                        yield new Promise(resolve => setTimeout(resolve, 1000));
+                        return fetchData(retryCount + 1);
+                    }
+                    const errorResponse = yield res.text();
+                    throw new Error(`网络响应异常: ${res.status} ${res.statusText} - ${errorResponse}`);
+                }
+                if (res.ok) {
+                    if (res.body) {
+                        const reader = res.body.getReader();
+                        const decoder = new TextDecoder('utf-8');
+                        if (streamCb) {
+                            // 流式处理，调用 streamCb
+                            const streamResponse = new ReadableStream({
+                                start(controller) {
+                                    let buffer = '';
+                                    function push() {
+                                        reader.read().then(({ done, value }) => {
+                                            if (done) {
+                                                // 处理剩余的缓冲区数据
+                                                const lines = buffer.split('\n');
+                                                for (const line of lines) {
+                                                    handleLine(line, controller);
+                                                }
+                                                // 调用结束回调
+                                                if (streamCb) {
+                                                    streamCb({ isEnd: true });
+                                                }
+                                                controller.close();
+                                                return;
+                                            }
+                                            const chunkText = decoder.decode(value, { stream: true });
+                                            buffer += chunkText;
+                                            // 按行分割缓冲区数据
+                                            const lines = buffer.split('\n');
+                                            for (let i = 0; i < lines.length - 1; i++) {
+                                                handleLine(lines[i], controller);
+                                            }
+                                            // 保留最后一行未处理的数据
+                                            buffer = lines[lines.length - 1];
+                                            // 继续读取下一部分数据
+                                            push();
+                                        });
+                                    }
+                                    function handleLine(line, controller) {
+                                        var _a;
+                                        line = line.trim();
+                                        if (line.startsWith('data:')) {
+                                            const dataStr = line.slice(5).trim();
+                                            if (dataStr === '')
+                                                return;
+                                            try {
+                                                const jsonData = JSON.parse(dataStr);
+                                                if ((_a = jsonData.data) === null || _a === void 0 ? void 0 : _a.text) {
+                                                    const wrappedData = {
+                                                        content: jsonData.data.text.toString(),
+                                                        controller
+                                                    };
+                                                    if (streamCb) {
+                                                        streamCb(wrappedData);
+                                                    }
+                                                }
+                                            }
+                                            catch (e) {
+                                                console.error('解析JSON失败:', e);
+                                            }
+                                        }
+                                    }
+                                    push();
+                                }
+                            });
+                            // 返回一个 Promise，resolve undefined 表示流式处理开始
+                            return undefined;
+                        }
+                        else {
+                            // 非流式处理，收集所有数据并返回
+                            let buffer = '';
+                            let accumulatedText = '';
+                            let isResponseEnded = false;
+                            const readAll = () => __awaiter(this, void 0, void 0, function* () {
+                                const { done, value } = yield reader.read();
+                                if (done) {
+                                    if (!isResponseEnded) {
+                                        // 响应提前结束，抛出错误
+                                        throw new Error('响应提前结束');
+                                    }
+                                    // 返回最终的响应对象
+                                    return accumulatedText;
+                                }
+                                const chunkText = decoder.decode(value, { stream: true });
+                                buffer += chunkText;
+                                // 按行分割缓冲区数据
+                                const lines = buffer.split('\n');
+                                for (let i = 0; i < lines.length - 1; i++) {
+                                    const line = lines[i].trim();
+                                    if (!line.startsWith('data:'))
+                                        continue;
+                                    const dataStr = line.slice(5).trim();
+                                    if (dataStr === '')
+                                        continue;
+                                    try {
+                                        const jsonData = JSON.parse(dataStr);
+                                        switch (jsonData.event) {
+                                            case 'message':
+                                            case 'agent_message':
+                                            case 'text_chunk': {
+                                                const content = jsonData.event === 'text_chunk' ? jsonData.data.text : jsonData.answer;
+                                                accumulatedText += content;
+                                                break;
+                                            }
+                                            case 'workflow_finished':
+                                                accumulatedText = jsonData.data;
+                                                isResponseEnded = true;
+                                                break;
+                                            case 'message_end':
+                                                isResponseEnded = true;
+                                                break;
+                                            case 'error':
+                                                throw new Error(`服务器错误: ${jsonData.code}, ${jsonData.message}`);
+                                            default:
+                                                // 忽略其他事件类型
+                                                break;
+                                        }
+                                    }
+                                    catch (e) {
+                                        throw new Error('解析JSON失败: ' + e.message);
+                                    }
+                                }
+                                // 保留最后一行未处理的数据
+                                buffer = lines[lines.length - 1];
+                                return readAll();
+                            });
+                            return readAll();
+                        }
+                    }
+                    else {
+                        throw new Error('响应体为空');
+                    }
+                }
+                else {
+                    const errorResponse = yield res.text();
+                    throw new Error(`网络响应异常: ${res.status} ${res.statusText} - ${errorResponse}`);
+                }
+            }
+            catch (error) {
+                // 捕获并抛出错误
+                if (error.name === 'AbortError') {
+                    throw new Error('请求已被中止，超时');
+                }
+                throw error;
+            }
+        });
+        try {
+            const result = yield Promise.race([
+                fetchData(),
+                new Promise((_, reject) => {
+                    setTimeout(() => {
+                        controller.abort();
+                        reject(new Error('请求超时'));
+                    }, timeout);
+                })
+            ]);
+            if (streamCb) {
+                // 流式处理，不返回数据
+                return undefined;
+            }
+            else {
+                // 非流式处理，返回数据
+                return result;
+            }
+        }
+        catch (error) {
+            controller.abort(); // 确保请求被中止
+            throw error;
+        }
+    });
+}
+/**
+ * 移除指定语言的代码块
+ *
+ * @param content 包含代码块的内容
+ * @returns 移除代码块后的内容
+ */
+function removeCodeBlock(content) {
+    const codeBlockMatch = content.trim().match(/^```(\w+)\n/);
+    let language = '';
+    if (codeBlockMatch) {
+        language = codeBlockMatch[1]; // 提取语言类型，如 json、sql 等
+    }
+    const startRegExp = new RegExp(`^\\\`\\\`\\\`${language}\\n`);
+    return content
+        .trim()
+        .replace(startRegExp, '')
+        .replace(/\n?```$/, '');
+}

package/dist/utils/logger.js

@@ -0,0 +1,129 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const winston_1 = __importDefault(require("winston"));
+const winston_daily_rotate_file_1 = __importDefault(require("winston-daily-rotate-file"));
+const config_1 = require("./config");
+const path_1 = __importDefault(require("path"));
+// 确保日志目录存在
+let logDir;
+try {
+    const storageDir = (0, config_1.getStorageDir)();
+    if (storageDir) {
+        logDir = storageDir + '/logs';
+    }
+    else {
+        logDir = './.aico/logs';
+    }
+}
+catch (error) {
+    // 如果getStorageDir失败，使用默认日志目录
+    logDir = './.aico/logs';
+}
+// 定义日志级别和颜色
+const levels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    verbose: 4
+};
+const colors = {
+    error: 'red',
+    warn: 'yellow',
+    info: 'green',
+    debug: 'blue',
+    verbose: 'cyan'
+};
+winston_1.default.addColors(colors);
+// 控制台输出的格式化
+const consoleFormat = winston_1.default.format.combine(winston_1.default.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston_1.default.format.colorize(), winston_1.default.format.printf((_a) => {
+    var { timestamp, level, message } = _a, meta = __rest(_a, ["timestamp", "level", "message"]);
+    const metaStr = Object.keys(meta).length ? JSON.stringify(meta, null, 2) : '';
+    return `${timestamp} [${level}]: ${message} ${metaStr}`;
+}));
+// 文件输出的格式化（JSON格式，包含完整的错误信息）
+const fileFormat = winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), winston_1.default.format.json());
+// 异常和拒绝处理的专用格式化
+const exceptionFormat = winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), winston_1.default.format.printf(info => {
+    const { timestamp, level, message, stack } = info, meta = __rest(info, ["timestamp", "level", "message", "stack"]);
+    // 获取错误对象
+    const error = meta.error || meta;
+    // 构建完整的错误信息对象
+    const errorInfo = {
+        timestamp,
+        level: level || 'error',
+        message: message || 'Uncaught Exception',
+        stack: stack || (error && error.stack) || 'No stack trace available',
+        error: Object.assign({ name: (error && error.name) || 'Error', message: (error && error.message) || String(error || message), code: (error && error.code) || meta.code }, meta)
+    };
+    return JSON.stringify(errorInfo, null, 2);
+}));
+// 创建日志传输器
+const transports = [
+    // 控制台输出
+    new winston_1.default.transports.Console({
+        format: consoleFormat,
+        level: 'verbose'
+    })
+];
+// 只有当logDir有效时才添加文件传输器
+if (logDir) {
+    transports.push(new winston_daily_rotate_file_1.default({
+        filename: path_1.default.join(logDir, 'application-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        zippedArchive: true,
+        maxSize: '2m',
+        maxFiles: '1d',
+        format: fileFormat,
+        level: 'info'
+    }));
+}
+// 创建logger实例
+exports.logger = winston_1.default.createLogger({
+    level: 'debug',
+    levels,
+    format: winston_1.default.format.combine(winston_1.default.format.errors({ stack: true }), winston_1.default.format.splat()),
+    transports,
+    exceptionHandlers: logDir ? [
+        new winston_daily_rotate_file_1.default({
+            filename: path_1.default.join(logDir, 'exceptions-%DATE%.log'),
+            datePattern: 'YYYY-MM-DD',
+            zippedArchive: true,
+            maxSize: '1m',
+            maxFiles: '1d',
+            format: exceptionFormat
+        })
+    ] : [],
+    rejectionHandlers: logDir ? [
+        new winston_daily_rotate_file_1.default({
+            filename: path_1.default.join(logDir, 'rejections-%DATE%.log'),
+            datePattern: 'YYYY-MM-DD',
+            zippedArchive: true,
+            maxSize: '1m',
+            maxFiles: '1d',
+            format: exceptionFormat
+        })
+    ] : []
+});
+// 添加一个关闭时的监听，确保日志都写入完毕
+process.on('SIGINT', () => {
+    exports.logger.end(() => {
+        exports.logger.info('日志已关闭');
+        process.exit(0);
+    });
+});

package/dist/utils/openai.js

@@ -0,0 +1,225 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIService = exports.OpenAIService = void 0;
+class OpenAIService {
+    constructor() {
+        this.apiKey = 'sk-d535ca964a434f20898150f77d6cdb2a';
+        this.baseUrl = 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions';
+        this.model = 'qwen3-coder-plus';
+        this.kimiApiKey = 'sk-fp8wJSigZBEP3x8y6MAZWGPuVIHJ5PDZtX9lMQQk8hjP2R0u';
+        this.kimiBaseUrl = 'https://api.moonshot.cn/anthropic';
+        this.kimiModel = 'kimi-k2-0711-preview';
+    }
+    generateText(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { prompt, temperature, system_prompt } = params;
+            let lastError = null;
+            // First try with qwen3-coder-plus
+            try {
+                const response = yield fetch(this.baseUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: this.model,
+                        messages: [
+                            ...(system_prompt ? [{ role: 'system', content: system_prompt }] : []),
+                            { role: 'user', content: prompt }
+                        ],
+                        max_tokens: 65536,
+                        temperature,
+                        stream: false,
+                    }),
+                });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    throw new Error(`OpenAI API error: ${response.status} ${response.statusText} - ${errorText}`);
+                }
+                const data = yield response.json();
+                if (!data.choices || data.choices.length === 0) {
+                    throw new Error('No choices returned from OpenAI API');
+                }
+                return data.choices[0].message.content;
+            }
+            catch (error) {
+                lastError = error;
+                // If first attempt fails, retry with kimi model
+                try {
+                    const response = yield fetch(this.kimiBaseUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${this.kimiApiKey}`,
+                        },
+                        body: JSON.stringify({
+                            model: this.kimiModel,
+                            messages: [
+                                ...(system_prompt ? [{ role: 'system', content: system_prompt }] : []),
+                                { role: 'user', content: prompt }
+                            ],
+                            max_tokens: 65536,
+                            temperature,
+                            stream: false,
+                        }),
+                    });
+                    if (!response.ok) {
+                        const errorText = yield response.text();
+                        throw new Error(`Kimi API error: ${response.status} ${response.statusText} - ${errorText}`);
+                    }
+                    const data = yield response.json();
+                    if (!data.choices || data.choices.length === 0) {
+                        throw new Error('No choices returned from Kimi API');
+                    }
+                    return data.choices[0].message.content;
+                }
+                catch (kimiError) {
+                    // If both attempts fail, throw the original error
+                    throw lastError;
+                }
+            }
+        });
+    }
+    generateStream(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { prompt, model, temperature, system_prompt } = params;
+            try {
+                const response = yield fetch(this.baseUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model,
+                        messages: [
+                            ...(system_prompt ? [{ role: 'system', content: system_prompt }] : []),
+                            { role: 'user', content: prompt }
+                        ],
+                        max_tokens: 65536,
+                        temperature,
+                        stream: true,
+                    }),
+                });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    throw new Error(`OpenAI API error: ${response.status} ${response.statusText} - ${errorText}`);
+                }
+                if (!response.body) {
+                    throw new Error('Response body is null');
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                return {
+                    [Symbol.asyncIterator]() {
+                        return __asyncGenerator(this, arguments, function* _a() {
+                            var _b, _c, _d;
+                            try {
+                                while (true) {
+                                    const { done, value } = yield __await(reader.read());
+                                    if (done)
+                                        break;
+                                    const chunk = decoder.decode(value);
+                                    const lines = chunk.split('\n').filter(line => line.trim() !== '');
+                                    for (const line of lines) {
+                                        if (line.startsWith('data: ')) {
+                                            const data = line.slice(6);
+                                            if (data === '[DONE]')
+                                                return yield __await(void 0);
+                                            try {
+                                                const parsed = JSON.parse(data);
+                                                const content = (_d = (_c = (_b = parsed.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.delta) === null || _d === void 0 ? void 0 : _d.content;
+                                                if (content) {
+                                                    yield yield __await(content);
+                                                }
+                                            }
+                                            catch (e) {
+                                                // Skip invalid JSON
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            finally {
+                                reader.releaseLock();
+                            }
+                        });
+                    }
+                };
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Analyze an image using vision capabilities
+     *
+     * @param params - Vision analysis parameters
+     * @returns Analysis result content
+     */
+    analyzeImage(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { prompt, image_base64, system_prompt } = params;
+            const response = yield fetch("https://api.moonshot.cn/v1/chat/completions", {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer sk-fp8wJSigZBEP3x8y6MAZWGPuVIHJ5PDZtX9lMQQk8hjP2R0u`,
+                },
+                body: JSON.stringify({
+                    model: 'kimi-latest',
+                    messages: [
+                        ...(system_prompt ? [{
+                                role: 'system',
+                                content: [{ type: 'text', text: system_prompt }]
+                            }] : []),
+                        {
+                            role: 'user',
+                            content: [
+                                { type: 'image_url', image_url: { url: image_base64 } },
+                                { type: 'text', text: prompt }
+                            ]
+                        }
+                    ],
+                    stream: false,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = yield response.text();
+                throw new Error(`OpenAI Vision API error: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+            const data = yield response.json();
+            if (!data.choices || data.choices.length === 0) {
+                throw new Error('No choices returned from OpenAI Vision API');
+            }
+            return data.choices[0].message.content;
+        });
+    }
+}
+exports.OpenAIService = OpenAIService;
+// Export singleton instance
+exports.openAIService = new OpenAIService();

package/dist/utils/pack.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packProject = packProject;
+exports.processRemoteRepo = processRemoteRepo;
+const aico_pack_1 = require("aico-pack");
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+function packProject(projectPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ---------------------- 步骤1：准备Markdown存储目录 ----------------------
+        const mdDir = path_1.default.join((0, config_1.getStorageDir)(), 'tech');
+        yield promises_1.default.mkdir(mdDir, { recursive: true });
+        // ---------------------- 步骤2：生成架构设计Markdown文档 ----------------------
+        logger_1.logger.info(`📂 正在分析当前本地项目`);
+        // 定义输出文件路径
+        const mdPath = path_1.default.join(mdDir, `项目架构分析.md`);
+        const options = {
+            output: mdPath,
+            style: 'markdown',
+            headerText: "智能软件星工厂",
+            fileSummary: true,
+            removeEmptyLines: true,
+            removeComments: true,
+            showLineNumbers: true,
+            compress: true,
+            quiet: true,
+            customPatterns: [
+                "**/*.md",
+                "**/*.log",
+                "**/*.json",
+                "**/*.txt",
+                "**/*.dockerfile",
+                "**/*.yml",
+                "**/*.yaml",
+                "**/*.sh",
+                "**/*.env",
+                "**/*.env.example",
+                "**/LICENSE",
+                "**/test/**",
+            ],
+        };
+        // 如果提供了项目路径，则使用该路径，否则使用默认的PROJECT_ROOT
+        const targetPath = projectPath || config_1.PROJECT_ROOT;
+        yield (0, aico_pack_1.runCli)([targetPath], process.cwd(), options);
+        return mdPath;
+    });
+}
+/**
+ * 处理远程仓库生成Markdown
+ */
+function processRemoteRepo(repoUrl, outputPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const options = {
+            remote: repoUrl,
+            output: outputPath,
+            compress: true
+        };
+        yield (0, aico_pack_1.runCli)([config_1.PROJECT_ROOT], process.cwd(), options);
+        return outputPath;
+    });
+}