cloudcc-cli 2.2.5 → 2.2.7

package/src/mcp/tools/JSP Migrator/handler.js

@@ -0,0 +1,842 @@
+const fs = require('fs');
+const path = require('path');
+
+function uniq(items) {
+    return Array.from(new Set((items || []).filter(Boolean)));
+}
+
+function toPascalCase(value) {
+    return String(value || '')
+        .replace(/\.[^.]+$/, '')
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+
+function toKebabCase(value) {
+    const base = String(value || '')
+        .replace(/\.[^.]+$/, '')
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+    return base || 'jsp-migrated-component';
+}
+
+function lineNumberAt(source, index) {
+    if (index <= 0) return 1;
+    let count = 1;
+    for (let i = 0; i < index && i < source.length; i += 1) {
+        if (source[i] === '\n') count += 1;
+    }
+    return count;
+}
+
+function extractTagBlock(source, tag) {
+    const start = source.indexOf(tag);
+    if (start === -1) return null;
+
+    const closeTag = '</cc>';
+    const contentStart = start + tag.length;
+    const closeStart = source.indexOf(closeTag, contentStart);
+    if (closeStart === -1) return null;
+
+    return {
+        tag,
+        start,
+        end: closeStart + closeTag.length,
+        innerStart: contentStart,
+        innerEnd: closeStart,
+        inner: source.slice(contentStart, closeStart)
+    };
+}
+
+function extractBraceBlock(source, openBraceIndex) {
+    let depth = 0;
+    let inSingle = false;
+    let inDouble = false;
+    let inBacktick = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+
+    for (let i = openBraceIndex; i < source.length; i += 1) {
+        const ch = source[i];
+        const next = source[i + 1];
+
+        if (inLineComment) {
+            if (ch === '\n') inLineComment = false;
+            continue;
+        }
+
+        if (inBlockComment) {
+            if (ch === '*' && next === '/') {
+                inBlockComment = false;
+                i += 1;
+            }
+            continue;
+        }
+
+        if (inSingle) {
+            if (!escaped && ch === "'") inSingle = false;
+            escaped = ch === '\\' && !escaped;
+            continue;
+        }
+
+        if (inDouble) {
+            if (!escaped && ch === '"') inDouble = false;
+            escaped = ch === '\\' && !escaped;
+            continue;
+        }
+
+        if (inBacktick) {
+            if (!escaped && ch === '`') inBacktick = false;
+            escaped = ch === '\\' && !escaped;
+            continue;
+        }
+
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+
+        if (ch === '/' && next === '*') {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+
+        if (ch === "'") {
+            inSingle = true;
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '"') {
+            inDouble = true;
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '`') {
+            inBacktick = true;
+            escaped = false;
+            continue;
+        }
+
+        if (ch === '{') {
+            depth += 1;
+        } else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return {
+                    start: openBraceIndex,
+                    end: i,
+                    body: source.slice(openBraceIndex + 1, i)
+                };
+            }
+        }
+    }
+
+    return null;
+}
+
+function extractObjectApis(snippet) {
+    const objectApis = [];
+    const cqueryRegex = /cs\.(?:cquery|cqlQuery)\(\s*"([^"]+)"/g;
+    let match = cqueryRegex.exec(snippet);
+    while (match) {
+        objectApis.push(match[1]);
+        match = cqueryRegex.exec(snippet);
+    }
+    return uniq(objectApis);
+}
+
+function extractInvokers(snippet) {
+    const invokers = [];
+    const invokerRegex = /PageClsInvoker\(userInfo\)\.invoker\(\s*"([^"]+)"\s*,\s*"([^"]+)"/g;
+    let match = invokerRegex.exec(snippet);
+    while (match) {
+        invokers.push(`${match[1]}.${match[2]}`);
+        match = invokerRegex.exec(snippet);
+    }
+    return uniq(invokers);
+}
+
+function buildReasonBranches(source) {
+    const branches = [];
+    const reasonRegex = /if\s*\(\s*"([^"]+)"\.equals\(reason\)\s*\)\s*\{/g;
+    let match = reasonRegex.exec(source);
+    const methodNameCount = {};
+
+    while (match) {
+        const reason = match[1];
+        const matchStart = match.index;
+        const openBraceOffset = match[0].lastIndexOf('{');
+        const openBraceIndex = matchStart + openBraceOffset;
+        const block = extractBraceBlock(source, openBraceIndex);
+        if (!block) {
+            match = reasonRegex.exec(source);
+            continue;
+        }
+
+        const methodBase = `handle${toPascalCase(reason)}`;
+        methodNameCount[methodBase] = (methodNameCount[methodBase] || 0) + 1;
+        const methodName = methodNameCount[methodBase] > 1
+            ? `${methodBase}${methodNameCount[methodBase]}`
+            : methodBase;
+
+        const startLine = lineNumberAt(source, matchStart);
+        const endLine = lineNumberAt(source, block.end);
+
+        branches.push({
+            reason,
+            methodName,
+            start: matchStart,
+            end: block.end,
+            startLine,
+            endLine,
+            snippet: source.slice(matchStart, block.end + 1),
+            body: block.body,
+            objectApis: extractObjectApis(block.body),
+            invokers: extractInvokers(block.body)
+        });
+
+        match = reasonRegex.exec(source);
+    }
+
+    return branches;
+}
+
+function buildClassSource({ className, jspFileName, branches, hasHelperBlock, sourcePath }) {
+    const switchCases = branches.length > 0
+        ? branches.map(branch => `            case "${branch.reason}":\n                return ${branch.methodName}(oppid);`).join('\n')
+        : '            default:\n                return fail("未识别到 reason 分支，请手动补充迁移逻辑");';
+
+    const handlerMethods = branches.length > 0
+        ? branches.map(branch => {
+            const objectApiText = branch.objectApis.length > 0 ? branch.objectApis.join(', ') : '无';
+            const invokerText = branch.invokers.length > 0 ? branch.invokers.join(', ') : '无';
+            return `
+    /**
+     * TODO: 从 JSP 迁移 reason 分支: ${branch.reason}
+     * 来源: ${jspFileName}:${branch.startLine}
+     * 依赖对象: ${objectApiText}
+     * 依赖调用: ${invokerText}
+     */
+    private Map<String, Object> ${branch.methodName}(String oppid) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", false);
+        result.put("oppid", oppid == null ? "" : oppid);
+        result.put("reason", "${branch.reason}");
+        result.put("message", "TODO: 请将 JSP 分支 '${branch.reason}' 迁移到该方法");
+        return result;
+    }
+`;
+        }).join('\n')
+        : `
+    private Map<String, Object> handleUnclassified(String oppid) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", false);
+        result.put("oppid", oppid == null ? "" : oppid);
+        result.put("message", "未识别到 reason 分支，请手动迁移");
+        return result;
+    }
+`;
+
+    return `package classes.${className};
+
+import com.cloudcc.core.*;
+import java.util.*;
+// @SOURCE_CONTENT_START
+public class ${className} {
+    private final UserInfo userInfo;
+    private final CCService cs;
+
+    public ${className}(UserInfo userInfo) {
+        this(userInfo, new CCService(userInfo));
+    }
+
+    public ${className}(UserInfo userInfo, CCService cs) {
+        this.userInfo = userInfo;
+        this.cs = cs;
+    }
+
+    /**
+     * 自动生成的迁移入口。
+     * JSP来源: ${sourcePath}
+     * helper块存在: ${hasHelperBlock ? '是' : '否'}
+     */
+    public Map<String, Object> execute(Map<String, Object> input) {
+        String oppid = getString(input, "oppid");
+        String reason = getString(input, "reason");
+        return execute(oppid, reason);
+    }
+
+    public Map<String, Object> execute(String oppid, String reason) {
+        if ("".equals(oppid)) {
+            return fail("缺少参数 oppid");
+        }
+        if ("".equals(reason)) {
+            return fail("缺少参数 reason");
+        }
+
+        switch (reason) {
+${switchCases}
+            default:
+                return fail("不支持的 reason: " + reason);
+        }
+    }
+
+${handlerMethods}
+
+    private String getString(Map<String, Object> input, String key) {
+        if (input == null || key == null) {
+            return "";
+        }
+        Object value = input.get(key);
+        return value == null ? "" : String.valueOf(value);
+    }
+
+    private Map<String, Object> fail(String message) {
+        Map<String, Object> result = new HashMap<>();
+        result.put("success", false);
+        result.put("message", message);
+        return result;
+    }
+}
+// @SOURCE_CONTENT_END
+`;
+}
+
+function buildClassTestSource({ className, firstReason }) {
+    const reason = firstReason || 'TODO_REASON';
+    return `package classes.${className};
+
+import com.cloudcc.core.*;
+import java.util.*;
+
+public class ${className}Test {
+    public static void main(String[] args) {
+        ${className} service = new ${className}(new UserInfo());
+        Map<String, Object> input = new HashMap<>();
+        input.put("oppid", "demo_oppid");
+        input.put("reason", "${reason}");
+        Map<String, Object> result = service.execute(input);
+        System.out.println(result);
+    }
+}
+`;
+}
+
+function buildComponentSource({ componentName, className, jspFileName, reasons }) {
+    const reasonList = JSON.stringify(reasons, null, 2);
+    const defaultReason = reasons[0] || '';
+
+    return `<template>
+  <div class="jsp-migrated-wrapper">
+    <header class="migrated-header">
+      <h3>{{ componentInfo.compName }}</h3>
+      <p>Legacy JSP: {{ legacyJsp }}</p>
+    </header>
+
+    <section class="migrated-panel">
+      <label>Opportunity ID</label>
+      <input v-model.trim="form.oppid" type="text" placeholder="请输入 oppid" />
+
+      <label>Reason</label>
+      <select v-model="form.reason">
+        <option v-for="item in reasons" :key="item" :value="item">{{ item }}</option>
+      </select>
+
+      <button type="button" @click="handleExecute">执行迁移入口</button>
+      <p class="hint">{{ hint }}</p>
+    </section>
+
+    <section class="migrated-result" v-if="lastPayload">
+      <h4>最近触发参数</h4>
+      <pre>{{ formattedPayload }}</pre>
+    </section>
+  </div>
+</template>
+
+<script>
+export default {
+  data() {
+    return {
+      componentInfo: {
+        component: "component-${componentName}",
+        compName: "compName-${componentName}",
+        compDesc: "Migrated from JSP ${jspFileName}",
+      },
+      legacyJsp: "${jspFileName}",
+      targetClass: "${className}",
+      reasons: ${reasonList},
+      form: {
+        oppid: "",
+        reason: "${defaultReason}",
+      },
+      hint: "TODO: 在宿主中接入自定义类调用逻辑。",
+      lastPayload: null,
+    };
+  },
+  computed: {
+    formattedPayload() {
+      return this.lastPayload ? JSON.stringify(this.lastPayload, null, 2) : "";
+    },
+  },
+  methods: {
+    handleExecute() {
+      const payload = {
+        oppid: this.form.oppid,
+        reason: this.form.reason,
+      };
+      this.lastPayload = payload;
+
+      if (!payload.oppid || !payload.reason) {
+        this.hint = "请先输入 oppid 并选择 reason。";
+        return;
+      }
+
+      this.$emit("execute-migrated-action", {
+        className: this.targetClass,
+        payload,
+      });
+      this.hint = \`已触发事件 execute-migrated-action，请在宿主中调用 \${this.targetClass}.execute(payload)\`;
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+.jsp-migrated-wrapper {
+  padding: 16px;
+  background: linear-gradient(160deg, #f2f6ff 0%, #ffffff 70%);
+  border: 1px solid #dbe4ff;
+  border-radius: 10px;
+  color: #1d2b53;
+}
+
+.migrated-header h3 {
+  margin: 0 0 6px;
+  font-size: 18px;
+}
+
+.migrated-header p {
+  margin: 0;
+  font-size: 12px;
+  color: #5b6b91;
+}
+
+.migrated-panel {
+  margin-top: 14px;
+  display: grid;
+  gap: 8px;
+}
+
+.migrated-panel label {
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.migrated-panel input,
+.migrated-panel select {
+  height: 34px;
+  border: 1px solid #c9d5ff;
+  border-radius: 6px;
+  padding: 0 10px;
+  outline: none;
+}
+
+.migrated-panel button {
+  margin-top: 4px;
+  width: 160px;
+  height: 34px;
+  border: 0;
+  border-radius: 6px;
+  background: #3451ff;
+  color: #fff;
+  cursor: pointer;
+}
+
+.hint {
+  margin: 0;
+  font-size: 12px;
+  color: #4f5f88;
+}
+
+.migrated-result {
+  margin-top: 16px;
+  background: #0f1530;
+  border-radius: 8px;
+  padding: 10px;
+}
+
+.migrated-result h4 {
+  margin: 0 0 8px;
+  font-size: 12px;
+  color: #d7def7;
+}
+
+.migrated-result pre {
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: #b8c7ff;
+  font-size: 12px;
+}
+</style>
+`;
+}
+
+function buildReport({
+    sourcePath,
+    helpDocPath,
+    jspContent,
+    helpDocContent,
+    pageDirective,
+    ccBlock,
+    ccBangBlock,
+    visualSegment,
+    branches,
+    objectApis,
+    invokers,
+    className,
+    componentName,
+    reportPath,
+    mode
+}) {
+    const lines = [];
+    lines.push('# JSP Migration Report');
+    lines.push('');
+    lines.push(`- generatedAt: ${new Date().toISOString()}`);
+    lines.push(`- mode: ${mode}`);
+    lines.push(`- sourceJsp: ${sourcePath}`);
+    lines.push(`- helpDoc: ${helpDocPath || '未提供'}`);
+    lines.push(`- outputClass: classes/${className}`);
+    lines.push(`- outputComponent: plugins/${componentName}`);
+    lines.push(`- reportFile: ${reportPath}`);
+    lines.push('');
+
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(`- jspLines: ${jspContent.split(/\r?\n/).length}`);
+    lines.push(`- reasonBranches: ${branches.length}`);
+    lines.push(`- helperBlockFound: ${ccBangBlock ? 'yes' : 'no'}`);
+    lines.push(`- visualSegmentFound: ${visualSegment ? 'yes' : 'no'}`);
+    lines.push(`- distinctObjectApis: ${objectApis.length}`);
+    lines.push(`- distinctInvokers: ${invokers.length}`);
+    lines.push('');
+
+    lines.push('## Page Directive');
+    lines.push('');
+    lines.push(`- cc:page: ${pageDirective || '未检测到'}`);
+    lines.push('');
+
+    lines.push('## Legacy Blocks');
+    lines.push('');
+    lines.push(`- <cc>: ${ccBlock ? `${lineNumberAt(jspContent, ccBlock.start)}-${lineNumberAt(jspContent, ccBlock.end)}` : 'not found'}`);
+    lines.push(`- <cc!>: ${ccBangBlock ? `${lineNumberAt(jspContent, ccBangBlock.start)}-${lineNumberAt(jspContent, ccBangBlock.end)}` : 'not found'}`);
+    lines.push(`- visualHtmlSegment: ${visualSegment ? `${lineNumberAt(jspContent, visualSegment.start)}-${lineNumberAt(jspContent, visualSegment.end)}` : 'not found'}`);
+    lines.push('');
+
+    lines.push('## Global Dependencies');
+    lines.push('');
+    lines.push(`- cquery/cqlQuery objects: ${objectApis.length > 0 ? objectApis.join(', ') : '无'}`);
+    lines.push(`- PageClsInvoker calls: ${invokers.length > 0 ? invokers.join(', ') : '无'}`);
+    lines.push('');
+
+    lines.push('## Reason Branches');
+    lines.push('');
+    if (branches.length === 0) {
+        lines.push('- 未识别到 `if("xxx".equals(reason))` 分支，请手工分析。');
+    } else {
+        branches.forEach(branch => {
+            lines.push(`### ${branch.reason}`);
+            lines.push(`- lineRange: ${branch.startLine}-${branch.endLine}`);
+            lines.push(`- generatedMethod: ${branch.methodName}`);
+            lines.push(`- objectApis: ${branch.objectApis.length > 0 ? branch.objectApis.join(', ') : '无'}`);
+            lines.push(`- invokers: ${branch.invokers.length > 0 ? branch.invokers.join(', ') : '无'}`);
+            lines.push('');
+        });
+    }
+
+    lines.push('## Help Doc Snapshot');
+    lines.push('');
+    if (!helpDocContent) {
+        lines.push('- 未提供帮助文档路径，跳过。');
+    } else {
+        const snapshot = helpDocContent
+            .split(/\r?\n/)
+            .map(line => line.trim())
+            .filter(Boolean)
+            .slice(0, 20);
+        if (snapshot.length === 0) {
+            lines.push('- 帮助文档为空或不可解析。');
+        } else {
+            snapshot.forEach(line => lines.push(`- ${line}`));
+        }
+    }
+
+    lines.push('');
+    lines.push('## Next Actions');
+    lines.push('');
+    lines.push(`- 在 \`classes/${className}/${className}.java\` 完成各 reason 分支迁移。`);
+    lines.push(`- 在 \`plugins/${componentName}/${componentName}.vue\` 接入真实触发流程。`);
+    lines.push('- 按报告中的 object/invoker 依赖逐项验证。');
+
+    return `${lines.join('\n')}\n`;
+}
+
+function parseMigrationInput({ jspPath, className, componentName }) {
+    const jspFileName = path.basename(jspPath);
+    const jspBaseName = jspFileName.replace(/\.[^.]+$/, '');
+
+    const resolvedClassName = className && className.trim()
+        ? className.trim()
+        : `${toPascalCase(jspBaseName)}MigratedService`;
+
+    const resolvedComponentName = componentName && componentName.trim()
+        ? componentName.trim()
+        : `${toKebabCase(jspBaseName)}-migrated`;
+
+    return {
+        jspFileName,
+        jspBaseName,
+        resolvedClassName,
+        resolvedComponentName
+    };
+}
+
+function prepareAnalysis({ jspContent, sourcePath }) {
+    const ccBlock = extractTagBlock(jspContent, '<cc>');
+    const ccBangBlock = extractTagBlock(jspContent, '<cc!>');
+    const pageMatch = jspContent.match(/<cc:page\s+([^>]*?)\/>/);
+    const pageDirective = pageMatch ? pageMatch[0] : '';
+
+    let visualSegment = null;
+    if (ccBlock) {
+        const visualStart = ccBlock.end;
+        const visualEnd = ccBangBlock ? ccBangBlock.start : jspContent.length;
+        const rawVisual = jspContent.slice(visualStart, visualEnd);
+        if (/<\s*(div|table|form|section|header|main|script|style|span|input|button|ul|ol|li)\b/i.test(rawVisual)) {
+            visualSegment = {
+                start: visualStart,
+                end: visualEnd,
+                content: rawVisual
+            };
+        }
+    }
+
+    const branches = buildReasonBranches(jspContent);
+    const objectApis = extractObjectApis(jspContent);
+    const invokers = extractInvokers(jspContent);
+
+    return {
+        sourcePath,
+        ccBlock,
+        ccBangBlock,
+        pageDirective,
+        visualSegment,
+        branches,
+        objectApis,
+        invokers
+    };
+}
+
+function buildResultText({
+    mode,
+    sourcePath,
+    classPath,
+    componentPath,
+    reportPath,
+    className,
+    componentName,
+    reasonCount,
+    objectApiCount,
+    invokerCount,
+    createdFiles
+}) {
+    const lines = [];
+    lines.push(`✓ JSP 迁移${mode === 'dry-run' ? '分析' : '生成'}完成`);
+    lines.push('');
+    lines.push(`source: ${sourcePath}`);
+    lines.push(`class: ${className}`);
+    lines.push(`component: ${componentName}`);
+    lines.push(`reason分支: ${reasonCount}`);
+    lines.push(`对象依赖数: ${objectApiCount}`);
+    lines.push(`invoker依赖数: ${invokerCount}`);
+    lines.push('');
+
+    if (mode === 'dry-run') {
+        lines.push('dry-run 模式未写入任何文件。');
+        lines.push(`报告预期路径: ${reportPath}`);
+    } else {
+        lines.push('已生成文件:');
+        createdFiles.forEach(file => lines.push(`- ${file}`));
+        lines.push('');
+        lines.push(`class目录: ${classPath}`);
+        lines.push(`component目录: ${componentPath}`);
+        lines.push(`报告路径: ${reportPath}`);
+    }
+
+    return lines.join('\n');
+}
+
+async function runMigration({
+    jspPath,
+    helpDocPath,
+    projectPath = process.cwd(),
+    outputProjectPath,
+    className,
+    componentName,
+    reportDir = 'migration-report',
+    mode = 'apply',
+    overwrite = false
+}) {
+    try {
+        if (!jspPath) {
+            return {
+                content: [{ type: 'text', text: '✗ 参数缺失: jspPath 必填' }]
+            };
+        }
+
+        const resolvedProjectPath = path.resolve(projectPath);
+        const resolvedOutputProjectPath = path.resolve(outputProjectPath || projectPath);
+        const sourcePath = path.isAbsolute(jspPath)
+            ? jspPath
+            : path.resolve(resolvedProjectPath, jspPath);
+
+        if (!fs.existsSync(sourcePath)) {
+            return {
+                content: [{ type: 'text', text: `✗ JSP 文件不存在: ${sourcePath}` }]
+            };
+        }
+
+        const helpPath = helpDocPath
+            ? (path.isAbsolute(helpDocPath) ? helpDocPath : path.resolve(resolvedProjectPath, helpDocPath))
+            : null;
+
+        const jspContent = fs.readFileSync(sourcePath, 'utf8');
+        const helpDocContent = helpPath && fs.existsSync(helpPath)
+            ? fs.readFileSync(helpPath, 'utf8')
+            : '';
+
+        const naming = parseMigrationInput({ jspPath: sourcePath, className, componentName });
+        const { jspFileName, jspBaseName, resolvedClassName, resolvedComponentName } = naming;
+
+        const analysis = prepareAnalysis({ jspContent, sourcePath });
+        const classSource = buildClassSource({
+            className: resolvedClassName,
+            jspFileName,
+            branches: analysis.branches,
+            hasHelperBlock: Boolean(analysis.ccBangBlock),
+            sourcePath
+        });
+
+        const classTestSource = buildClassTestSource({
+            className: resolvedClassName,
+            firstReason: analysis.branches[0] ? analysis.branches[0].reason : ''
+        });
+
+        const componentSource = buildComponentSource({
+            componentName: resolvedComponentName,
+            className: resolvedClassName,
+            jspFileName,
+            reasons: analysis.branches.map(item => item.reason)
+        });
+
+        const reportPath = path.join(resolvedOutputProjectPath, reportDir, `${jspBaseName}.migration.md`);
+        const reportContent = buildReport({
+            sourcePath,
+            helpDocPath: helpPath,
+            jspContent,
+            helpDocContent,
+            pageDirective: analysis.pageDirective,
+            ccBlock: analysis.ccBlock,
+            ccBangBlock: analysis.ccBangBlock,
+            visualSegment: analysis.visualSegment,
+            branches: analysis.branches,
+            objectApis: analysis.objectApis,
+            invokers: analysis.invokers,
+            className: resolvedClassName,
+            componentName: resolvedComponentName,
+            reportPath,
+            mode
+        });
+
+        const classDir = path.join(resolvedOutputProjectPath, 'classes', resolvedClassName);
+        const componentDir = path.join(resolvedOutputProjectPath, 'plugins', resolvedComponentName);
+
+        const fileMap = {
+            [path.join(classDir, `${resolvedClassName}.java`)]: classSource,
+            [path.join(classDir, `${resolvedClassName}Test.java`)]: classTestSource,
+            [path.join(classDir, 'config.json')]: JSON.stringify({
+                name: resolvedClassName,
+                version: '2'
+            }, null, 4),
+            [path.join(componentDir, `${resolvedComponentName}.vue`)]: componentSource,
+            [path.join(componentDir, 'config.json')]: JSON.stringify({
+                component: `component-${resolvedComponentName}`,
+                compName: `compName-${resolvedComponentName}`,
+                compDesc: `Migrated from JSP ${jspFileName}`
+            }),
+            [reportPath]: reportContent
+        };
+
+        if (mode === 'apply') {
+            const existingFiles = Object.keys(fileMap).filter(file => fs.existsSync(file));
+            if (!overwrite && existingFiles.length > 0) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `✗ 目标文件已存在（可设置 overwrite=true 覆盖）:\n${existingFiles.map(item => `- ${item}`).join('\n')}`
+                    }]
+                };
+            }
+
+            Object.keys(fileMap).forEach(filePath => {
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, fileMap[filePath], 'utf8');
+            });
+        }
+
+        const text = buildResultText({
+            mode,
+            sourcePath,
+            classPath: classDir,
+            componentPath: componentDir,
+            reportPath,
+            className: resolvedClassName,
+            componentName: resolvedComponentName,
+            reasonCount: analysis.branches.length,
+            objectApiCount: analysis.objectApis.length,
+            invokerCount: analysis.invokers.length,
+            createdFiles: Object.keys(fileMap)
+        });
+
+        return {
+            content: [{ type: 'text', text }]
+        };
+    } catch (error) {
+        return {
+            content: [{ type: 'text', text: `✗ JSP 迁移失败: ${error.message}` }]
+        };
+    }
+}
+
+async function analyzeJspMigration(params) {
+    return runMigration({ ...(params || {}), mode: 'dry-run' });
+}
+
+async function splitJspToCloudcc(params) {
+    return runMigration(params || {});
+}
+
+module.exports = {
+    analyzeJspMigration,
+    splitJspToCloudcc,
+    runMigrationForCli: runMigration
+};